From 43f9fdb3dba38d0d2d60e0d202cfec01428668a3 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Tue, 14 Apr 2020 17:54:37 -0400 Subject: [PATCH 01/27] WIP - optimization experiments --- opt-fix-notes-2.org | 180 ++++++++++++++++++++++++++++++++++++++++++++ src/stanc/stanc.ml | 25 +++--- 2 files changed, 193 insertions(+), 12 deletions(-) create mode 100644 opt-fix-notes-2.org diff --git a/opt-fix-notes-2.org b/opt-fix-notes-2.org new file mode 100644 index 0000000000..5cb27334e8 --- /dev/null +++ b/opt-fix-notes-2.org @@ -0,0 +1,180 @@ +* Basic tests +** files +stat_comp_benchmarks/benchmarks/eight_schools/eight_schools.stan +stat_comp_benchmarks/benchmarks/low_dim_gauss_mix/low_dim_gauss_mix.stan + +** Failing sets +*** 1 + { function_inlining= false + ; static_loop_unrolling= true + ; one_step_loop_unrolling= true + ; list_collapsing= true + ; block_fixing= true + ; constant_propagation= true + ; expression_propagation= true + ; copy_propagation= true + ; dead_code_elimination= true + ; partial_evaluation= true + ; lazy_code_motion= false + ; optimize_ad_levels= true + } +**** Adding expression prop made it fail to compile +*** 2 + { function_inlining= false + ; static_loop_unrolling= true + ; one_step_loop_unrolling= true + ; list_collapsing= true + ; block_fixing= true + ; constant_propagation= true + ; expression_propagation= false + ; copy_propagation= true + ; dead_code_elimination= true + ; partial_evaluation= true + ; lazy_code_motion= true + ; optimize_ad_levels= true + } +**** Adding lazy code motion gives gold fails +'stat_comp_benchmarks/benchmarks/eight_schools/eight_schools.stan' had fails '[('mu', 6.109845000000001, 2.33795743355, 5.844783999999999), ('tau', 3.6286705, 17.909876540440834, 8.07591206), ('theta.1', 7.568446000000002, 58.52058177134668, 12.6306438), ('theta.2', 7.978434, 50.99874420188001, 4.748827), ('theta.3', 3.998913, 26.64411834273667, 4.748827), ('theta.4', 6.635608, 55.76740554871998, 4.748827), ('theta.5', 2.3191904, 98.85220142277814, 4.748827), ('theta.6', 5.294193, 39.86568307933666, 4.748827), ('theta.7', 8.21416, 30.40222421866667, 4.748827), ('theta.8', 5.955347, 28.555317575736662, 4.748827), ('theta_tilde.1', 0.07762187, 3.146498216988974, 0.15829919999999995), ('theta_tilde.2', 0.29127192, 2.082355481716592, 0.15684631), ('theta_tilde.3', -0.3404136, 1.4504123902928, 0.15684631), ('theta_tilde.4', 0.0362377, 2.228888469351367, 0.15684631), ('theta_tilde.5', -0.78378907, 5.701379301019746, 0.15684631), ('theta_tilde.6', -0.1637409, 3.215517962164967, 0.15684631), ('theta_tilde.7', 0.5688685, 4.003366874360166, 0.15684631), ('theta_tilde.8', 0.3939001, 5.354923534725636, 0.15684631)]' and errors '[]' +** Minimal failing sets +*** Expression propagation only +*** Lazy code motion only, but it might need support +** Maximal working sets +*** 1 + { function_inlining= true + ; static_loop_unrolling= true + ; one_step_loop_unrolling= true + ; list_collapsing= true + ; block_fixing= true + ; constant_propagation= true + ; expression_propagation= false + ; copy_propagation= true + ; dead_code_elimination= true + ; partial_evaluation= true + ; lazy_code_motion= false + ; optimize_ad_levels= true + } +* Bigger tests +** files +stat_comp_benchmarks/benchmarks/arK/arK.stan +stat_comp_benchmarks/benchmarks/arma/arma.stan +stat_comp_benchmarks/benchmarks/eight_schools/eight_schools.stan +stat_comp_benchmarks/benchmarks/garch/garch.stan +stat_comp_benchmarks/benchmarks/gp_pois_regr/gp_pois_regr.stan +stat_comp_benchmarks/benchmarks/gp_regr/gen_gp_data.stan +stat_comp_benchmarks/benchmarks/gp_regr/gp_regr.stan +stat_comp_benchmarks/benchmarks/irt_2pl/irt_2pl.stan +stat_comp_benchmarks/benchmarks/low_dim_corr_gauss/low_dim_corr_gauss.stan, 20000 +stat_comp_benchmarks/benchmarks/low_dim_gauss_mix/low_dim_gauss_mix.stan +stat_comp_benchmarks/benchmarks/low_dim_gauss_mix_collapse/low_dim_gauss_mix_collapse.stan +stat_comp_benchmarks/benchmarks/sir/sir.stan +** REMOVED OUTLIER files +stat_comp_benchmarks/benchmarks/pkpd/one_comp_mm_elim_abs.stan +stat_comp_benchmarks/benchmarks/pkpd/sim_one_comp_mm_elim_abs.stan +*** Results + Both had weird errors with their 'gold' csv files +** Control? + PASSED +** Failing sets +*** 1 +**** settings + { function_inlining= true + ; static_loop_unrolling= true + ; one_step_loop_unrolling= true + ; list_collapsing= true + ; block_fixing= true + ; constant_propagation= true + ; expression_propagation= false + ; copy_propagation= true + ; dead_code_elimination= true + ; partial_evaluation= true + ; lazy_code_motion= false + ; optimize_ad_levels= true + } +**** results +TEST PASSED: 'stat_comp_benchmarks/benchmarks/arK/arK.stan' +TEST FAILED: 'stat_comp_benchmarks/benchmarks/arma/arma.stan' had fails '[]' and errors '['Did not compile!']' +TEST PASSED: 'stat_comp_benchmarks/benchmarks/eight_schools/eight_schools.stan' +TEST FAILED: 'stat_comp_benchmarks/benchmarks/garch/garch.stan' had fails '[]' and errors '['Did not compile!']' +TEST PASSED: 'stat_comp_benchmarks/benchmarks/gp_pois_regr/gp_pois_regr.stan' +TEST PASSED: 'stat_comp_benchmarks/benchmarks/gp_regr/gen_gp_data.stan' +TEST PASSED: 'stat_comp_benchmarks/benchmarks/gp_regr/gp_regr.stan' +TEST PASSED: 'stat_comp_benchmarks/benchmarks/irt_2pl/irt_2pl.stan' +TEST FAILED: 'stat_comp_benchmarks/benchmarks/low_dim_corr_gauss/low_dim_corr_gauss.stan' had fails '[]' and errors '['Did not compile!']' +TEST PASSED: 'stat_comp_benchmarks/benchmarks/low_dim_gauss_mix/low_dim_gauss_mix.stan' +TEST PASSED: 'stat_comp_benchmarks/benchmarks/low_dim_gauss_mix_collapse/low_dim_gauss_mix_collapse.stan' +TEST FAILED: 'stat_comp_benchmarks/benchmarks/pkpd/one_comp_mm_elim_abs.stan' had fails '[]' and errors '['Did not compile!']' +TEST FAILED: 'stat_comp_benchmarks/benchmarks/pkpd/sim_one_comp_mm_elim_abs.stan' had fails '[]' and errors '['Did not compile!']' +TEST FAILED: 'stat_comp_benchmarks/benchmarks/sir/sir.stan' had fails '[]' and errors '['Did not compile!']' +TEST PASSED: 'performance.compilation' +***** example sir.hpp +../stat_comp_benchmarks/benchmarks/sir/sir.hpp:166:12: error: could not convert ‘dydt’ from ‘vector’ to ‘vector’ + return dydt; +** Minimal failing sets +** Maximal working sets +*** 1 + { function_inlining= true + ; static_loop_unrolling= true + ; one_step_loop_unrolling= true + ; list_collapsing= true + ; block_fixing= true + ; constant_propagation= true + ; expression_propagation= false + ; copy_propagation= true + ; dead_code_elimination= true + ; partial_evaluation= true + ; lazy_code_motion= false + ; optimize_ad_levels= false + } +* Technical notes +** Remember to run the golds when switching sets! +** "has fails" means the gold check failed +** The fails are in format (k, mean, stdev, summary[k][0]) +* Notes +** Expression prop fails to compile +** Solid example of optimize_ad_levels in sir.hpp +** Performance appears to show dramatically worse performance (example) + It would be good to go through tests again to look at performance. But first I should get them all working, since some might be worth leaving in to get other things to work. +*** Profile + { function_inlining= true + ; static_loop_unrolling= true + ; one_step_loop_unrolling= true + ; list_collapsing= true + ; block_fixing= true + ; constant_propagation= true + ; expression_propagation= false + ; copy_propagation= true + ; dead_code_elimination= true + ; partial_evaluation= true + ; lazy_code_motion= false + ; optimize_ad_levels= true + } +*** Rates ++++ python ./comparePerformance.py reference_performance.csv performance.csv csv +Name, Old Result, New Result, Ratio, Performance change( 1 - new / old ) +stat_comp_benchmarks/benchmarks/arK/arK.stan, 0.02, 0.06, 0.3, -228.97% slower +stat_comp_benchmarks/benchmarks/arma/arma.stan, 0.02, 0.02, 0.72, -38.15% slower +stat_comp_benchmarks/benchmarks/eight_schools/eight_schools.stan, 0.01, 0.01, 0.55, -82.56% slower +stat_comp_benchmarks/benchmarks/garch/garch.stan, 0.03, 0.03, 0.93, -7.55% slower +stat_comp_benchmarks/benchmarks/gp_pois_regr/gp_pois_regr.stan, 0.05, 0.06, 0.87, -15.38% slower +stat_comp_benchmarks/benchmarks/gp_regr/gen_gp_data.stan, 0.06, 0.07, 0.98, -2.5% slower +stat_comp_benchmarks/benchmarks/gp_regr/gp_regr.stan, 0.01, 0.02, 0.52, -93.66% slower +stat_comp_benchmarks/benchmarks/irt_2pl/irt_2pl.stan, 0.22, 0.27, 0.84, -18.9% slower +stat_comp_benchmarks/benchmarks/low_dim_corr_gauss/low_dim_corr_gauss.stan, 0.02, 0.01, 1.48, 32.54% faster +stat_comp_benchmarks/benchmarks/low_dim_gauss_mix/low_dim_gauss_mix.stan, 0.11, 0.11, 1.01, 1.25% faster +stat_comp_benchmarks/benchmarks/low_dim_gauss_mix_collapse/low_dim_gauss_mix_collapse.stan, 0.18, 0.17, 1.08, 7.34% faster +stat_comp_benchmarks/benchmarks/sir/sir.stan, 20.38, 20.81, 0.98, -2.12% slower +performance.compilation, 156.65, 164.46, 0.95, -4.98% slower +Mean result: 0.8623900829040724 +*** Files +stat_comp_benchmarks/benchmarks/arK/arK.stan +stat_comp_benchmarks/benchmarks/arma/arma.stan +stat_comp_benchmarks/benchmarks/eight_schools/eight_schools.stan +stat_comp_benchmarks/benchmarks/garch/garch.stan +stat_comp_benchmarks/benchmarks/gp_pois_regr/gp_pois_regr.stan +stat_comp_benchmarks/benchmarks/gp_regr/gen_gp_data.stan +stat_comp_benchmarks/benchmarks/gp_regr/gp_regr.stan +stat_comp_benchmarks/benchmarks/irt_2pl/irt_2pl.stan +stat_comp_benchmarks/benchmarks/low_dim_corr_gauss/low_dim_corr_gauss.stan, 20000 +stat_comp_benchmarks/benchmarks/low_dim_gauss_mix/low_dim_gauss_mix.stan +stat_comp_benchmarks/benchmarks/low_dim_gauss_mix_collapse/low_dim_gauss_mix_collapse.stan +stat_comp_benchmarks/benchmarks/sir/sir.stan diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index 428b265f0a..118eba6472 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -125,18 +125,19 @@ let options = (* Whether or not to run each optimization. Currently it's all or nothing depending on the --O flag.*) let optimization_settings () : Optimize.optimization_settings = - { function_inlining= !optimize - ; static_loop_unrolling= !optimize - ; one_step_loop_unrolling= !optimize - ; list_collapsing= !optimize - ; block_fixing= !optimize - ; constant_propagation= !optimize - ; expression_propagation= !optimize - ; copy_propagation= !optimize - ; dead_code_elimination= !optimize - ; partial_evaluation= !optimize - ; lazy_code_motion= !optimize - ; optimize_ad_levels= true } + { function_inlining= true + ; static_loop_unrolling= true + ; one_step_loop_unrolling= true + ; list_collapsing= true + ; block_fixing= true + ; constant_propagation= true + ; expression_propagation= false + ; copy_propagation= true + ; dead_code_elimination= true + ; partial_evaluation= true + ; lazy_code_motion= false + ; optimize_ad_levels= true + } let print_warn_uninitialized (uninit_vars : (Location_span.t * string) Set.Poly.t) = From 08cd5db6e1986a62165f649b69119be50da0d390 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Wed, 15 Apr 2020 13:21:53 -0400 Subject: [PATCH 02/27] Fixed two bugs in autodiff level optimization Ad did not propogate to function arguments, so return value was always assumed to be data. Now arguments are assumed to be AD variables if they are of an autodiffable type. This is a conservative approximation - ideally we would search through function calls to determine which arguments actually may be AD variables. There was a bug introduced by using shadowed variables. It resulted in converting the result type of an indexed expression into an array type. --- opt-fix-notes-2.org | 180 -- src/analysis_and_optimization/Mir_utils.ml | 6 +- .../Monotone_framework.ml | 11 +- src/analysis_and_optimization/Optimize.ml | 56 +- src/middle/UnsizedType.ml | 7 + src/stanc/stanc.ml | 46 +- .../good/compiler-optimizations/cpp.expected | 1772 ++++++++--------- .../good/compiler-optimizations/dune | 2 +- test/unit/Optimize.ml | 4 +- 9 files changed, 895 insertions(+), 1189 deletions(-) delete mode 100644 opt-fix-notes-2.org diff --git a/opt-fix-notes-2.org b/opt-fix-notes-2.org deleted file mode 100644 index 5cb27334e8..0000000000 --- a/opt-fix-notes-2.org +++ /dev/null @@ -1,180 +0,0 @@ -* Basic tests -** files -stat_comp_benchmarks/benchmarks/eight_schools/eight_schools.stan -stat_comp_benchmarks/benchmarks/low_dim_gauss_mix/low_dim_gauss_mix.stan - -** Failing sets -*** 1 - { function_inlining= false - ; static_loop_unrolling= true - ; one_step_loop_unrolling= true - ; list_collapsing= true - ; block_fixing= true - ; constant_propagation= true - ; expression_propagation= true - ; copy_propagation= true - ; dead_code_elimination= true - ; partial_evaluation= true - ; lazy_code_motion= false - ; optimize_ad_levels= true - } -**** Adding expression prop made it fail to compile -*** 2 - { function_inlining= false - ; static_loop_unrolling= true - ; one_step_loop_unrolling= true - ; list_collapsing= true - ; block_fixing= true - ; constant_propagation= true - ; expression_propagation= false - ; copy_propagation= true - ; dead_code_elimination= true - ; partial_evaluation= true - ; lazy_code_motion= true - ; optimize_ad_levels= true - } -**** Adding lazy code motion gives gold fails -'stat_comp_benchmarks/benchmarks/eight_schools/eight_schools.stan' had fails '[('mu', 6.109845000000001, 2.33795743355, 5.844783999999999), ('tau', 3.6286705, 17.909876540440834, 8.07591206), ('theta.1', 7.568446000000002, 58.52058177134668, 12.6306438), ('theta.2', 7.978434, 50.99874420188001, 4.748827), ('theta.3', 3.998913, 26.64411834273667, 4.748827), ('theta.4', 6.635608, 55.76740554871998, 4.748827), ('theta.5', 2.3191904, 98.85220142277814, 4.748827), ('theta.6', 5.294193, 39.86568307933666, 4.748827), ('theta.7', 8.21416, 30.40222421866667, 4.748827), ('theta.8', 5.955347, 28.555317575736662, 4.748827), ('theta_tilde.1', 0.07762187, 3.146498216988974, 0.15829919999999995), ('theta_tilde.2', 0.29127192, 2.082355481716592, 0.15684631), ('theta_tilde.3', -0.3404136, 1.4504123902928, 0.15684631), ('theta_tilde.4', 0.0362377, 2.228888469351367, 0.15684631), ('theta_tilde.5', -0.78378907, 5.701379301019746, 0.15684631), ('theta_tilde.6', -0.1637409, 3.215517962164967, 0.15684631), ('theta_tilde.7', 0.5688685, 4.003366874360166, 0.15684631), ('theta_tilde.8', 0.3939001, 5.354923534725636, 0.15684631)]' and errors '[]' -** Minimal failing sets -*** Expression propagation only -*** Lazy code motion only, but it might need support -** Maximal working sets -*** 1 - { function_inlining= true - ; static_loop_unrolling= true - ; one_step_loop_unrolling= true - ; list_collapsing= true - ; block_fixing= true - ; constant_propagation= true - ; expression_propagation= false - ; copy_propagation= true - ; dead_code_elimination= true - ; partial_evaluation= true - ; lazy_code_motion= false - ; optimize_ad_levels= true - } -* Bigger tests -** files -stat_comp_benchmarks/benchmarks/arK/arK.stan -stat_comp_benchmarks/benchmarks/arma/arma.stan -stat_comp_benchmarks/benchmarks/eight_schools/eight_schools.stan -stat_comp_benchmarks/benchmarks/garch/garch.stan -stat_comp_benchmarks/benchmarks/gp_pois_regr/gp_pois_regr.stan -stat_comp_benchmarks/benchmarks/gp_regr/gen_gp_data.stan -stat_comp_benchmarks/benchmarks/gp_regr/gp_regr.stan -stat_comp_benchmarks/benchmarks/irt_2pl/irt_2pl.stan -stat_comp_benchmarks/benchmarks/low_dim_corr_gauss/low_dim_corr_gauss.stan, 20000 -stat_comp_benchmarks/benchmarks/low_dim_gauss_mix/low_dim_gauss_mix.stan -stat_comp_benchmarks/benchmarks/low_dim_gauss_mix_collapse/low_dim_gauss_mix_collapse.stan -stat_comp_benchmarks/benchmarks/sir/sir.stan -** REMOVED OUTLIER files -stat_comp_benchmarks/benchmarks/pkpd/one_comp_mm_elim_abs.stan -stat_comp_benchmarks/benchmarks/pkpd/sim_one_comp_mm_elim_abs.stan -*** Results - Both had weird errors with their 'gold' csv files -** Control? - PASSED -** Failing sets -*** 1 -**** settings - { function_inlining= true - ; static_loop_unrolling= true - ; one_step_loop_unrolling= true - ; list_collapsing= true - ; block_fixing= true - ; constant_propagation= true - ; expression_propagation= false - ; copy_propagation= true - ; dead_code_elimination= true - ; partial_evaluation= true - ; lazy_code_motion= false - ; optimize_ad_levels= true - } -**** results -TEST PASSED: 'stat_comp_benchmarks/benchmarks/arK/arK.stan' -TEST FAILED: 'stat_comp_benchmarks/benchmarks/arma/arma.stan' had fails '[]' and errors '['Did not compile!']' -TEST PASSED: 'stat_comp_benchmarks/benchmarks/eight_schools/eight_schools.stan' -TEST FAILED: 'stat_comp_benchmarks/benchmarks/garch/garch.stan' had fails '[]' and errors '['Did not compile!']' -TEST PASSED: 'stat_comp_benchmarks/benchmarks/gp_pois_regr/gp_pois_regr.stan' -TEST PASSED: 'stat_comp_benchmarks/benchmarks/gp_regr/gen_gp_data.stan' -TEST PASSED: 'stat_comp_benchmarks/benchmarks/gp_regr/gp_regr.stan' -TEST PASSED: 'stat_comp_benchmarks/benchmarks/irt_2pl/irt_2pl.stan' -TEST FAILED: 'stat_comp_benchmarks/benchmarks/low_dim_corr_gauss/low_dim_corr_gauss.stan' had fails '[]' and errors '['Did not compile!']' -TEST PASSED: 'stat_comp_benchmarks/benchmarks/low_dim_gauss_mix/low_dim_gauss_mix.stan' -TEST PASSED: 'stat_comp_benchmarks/benchmarks/low_dim_gauss_mix_collapse/low_dim_gauss_mix_collapse.stan' -TEST FAILED: 'stat_comp_benchmarks/benchmarks/pkpd/one_comp_mm_elim_abs.stan' had fails '[]' and errors '['Did not compile!']' -TEST FAILED: 'stat_comp_benchmarks/benchmarks/pkpd/sim_one_comp_mm_elim_abs.stan' had fails '[]' and errors '['Did not compile!']' -TEST FAILED: 'stat_comp_benchmarks/benchmarks/sir/sir.stan' had fails '[]' and errors '['Did not compile!']' -TEST PASSED: 'performance.compilation' -***** example sir.hpp -../stat_comp_benchmarks/benchmarks/sir/sir.hpp:166:12: error: could not convert ‘dydt’ from ‘vector’ to ‘vector’ - return dydt; -** Minimal failing sets -** Maximal working sets -*** 1 - { function_inlining= true - ; static_loop_unrolling= true - ; one_step_loop_unrolling= true - ; list_collapsing= true - ; block_fixing= true - ; constant_propagation= true - ; expression_propagation= false - ; copy_propagation= true - ; dead_code_elimination= true - ; partial_evaluation= true - ; lazy_code_motion= false - ; optimize_ad_levels= false - } -* Technical notes -** Remember to run the golds when switching sets! -** "has fails" means the gold check failed -** The fails are in format (k, mean, stdev, summary[k][0]) -* Notes -** Expression prop fails to compile -** Solid example of optimize_ad_levels in sir.hpp -** Performance appears to show dramatically worse performance (example) - It would be good to go through tests again to look at performance. But first I should get them all working, since some might be worth leaving in to get other things to work. -*** Profile - { function_inlining= true - ; static_loop_unrolling= true - ; one_step_loop_unrolling= true - ; list_collapsing= true - ; block_fixing= true - ; constant_propagation= true - ; expression_propagation= false - ; copy_propagation= true - ; dead_code_elimination= true - ; partial_evaluation= true - ; lazy_code_motion= false - ; optimize_ad_levels= true - } -*** Rates -+++ python ./comparePerformance.py reference_performance.csv performance.csv csv -Name, Old Result, New Result, Ratio, Performance change( 1 - new / old ) -stat_comp_benchmarks/benchmarks/arK/arK.stan, 0.02, 0.06, 0.3, -228.97% slower -stat_comp_benchmarks/benchmarks/arma/arma.stan, 0.02, 0.02, 0.72, -38.15% slower -stat_comp_benchmarks/benchmarks/eight_schools/eight_schools.stan, 0.01, 0.01, 0.55, -82.56% slower -stat_comp_benchmarks/benchmarks/garch/garch.stan, 0.03, 0.03, 0.93, -7.55% slower -stat_comp_benchmarks/benchmarks/gp_pois_regr/gp_pois_regr.stan, 0.05, 0.06, 0.87, -15.38% slower -stat_comp_benchmarks/benchmarks/gp_regr/gen_gp_data.stan, 0.06, 0.07, 0.98, -2.5% slower -stat_comp_benchmarks/benchmarks/gp_regr/gp_regr.stan, 0.01, 0.02, 0.52, -93.66% slower -stat_comp_benchmarks/benchmarks/irt_2pl/irt_2pl.stan, 0.22, 0.27, 0.84, -18.9% slower -stat_comp_benchmarks/benchmarks/low_dim_corr_gauss/low_dim_corr_gauss.stan, 0.02, 0.01, 1.48, 32.54% faster -stat_comp_benchmarks/benchmarks/low_dim_gauss_mix/low_dim_gauss_mix.stan, 0.11, 0.11, 1.01, 1.25% faster -stat_comp_benchmarks/benchmarks/low_dim_gauss_mix_collapse/low_dim_gauss_mix_collapse.stan, 0.18, 0.17, 1.08, 7.34% faster -stat_comp_benchmarks/benchmarks/sir/sir.stan, 20.38, 20.81, 0.98, -2.12% slower -performance.compilation, 156.65, 164.46, 0.95, -4.98% slower -Mean result: 0.8623900829040724 -*** Files -stat_comp_benchmarks/benchmarks/arK/arK.stan -stat_comp_benchmarks/benchmarks/arma/arma.stan -stat_comp_benchmarks/benchmarks/eight_schools/eight_schools.stan -stat_comp_benchmarks/benchmarks/garch/garch.stan -stat_comp_benchmarks/benchmarks/gp_pois_regr/gp_pois_regr.stan -stat_comp_benchmarks/benchmarks/gp_regr/gen_gp_data.stan -stat_comp_benchmarks/benchmarks/gp_regr/gp_regr.stan -stat_comp_benchmarks/benchmarks/irt_2pl/irt_2pl.stan -stat_comp_benchmarks/benchmarks/low_dim_corr_gauss/low_dim_corr_gauss.stan, 20000 -stat_comp_benchmarks/benchmarks/low_dim_gauss_mix/low_dim_gauss_mix.stan -stat_comp_benchmarks/benchmarks/low_dim_gauss_mix_collapse/low_dim_gauss_mix_collapse.stan -stat_comp_benchmarks/benchmarks/sir/sir.stan diff --git a/src/analysis_and_optimization/Mir_utils.ml b/src/analysis_and_optimization/Mir_utils.ml index 14ecaa69b6..134cffef9e 100644 --- a/src/analysis_and_optimization/Mir_utils.ml +++ b/src/analysis_and_optimization/Mir_utils.ml @@ -278,12 +278,12 @@ let rec update_expr_ad_levels autodiffable_variables let e2 = update_expr_ad_levels autodiffable_variables e2 in { pattern= EOr (e1, e2) ; meta= {e.meta with adlevel= ad_level_sup [e1; e2]} } - | Indexed (e, i_list) -> - let e = update_expr_ad_levels autodiffable_variables e in + | Indexed (ixed, i_list) -> + let ixed = update_expr_ad_levels autodiffable_variables ixed in let i_list = List.map ~f:(update_idx_ad_levels autodiffable_variables) i_list in - { pattern= Indexed (e, i_list) + { pattern= Indexed (ixed, i_list) ; meta= { e.meta with adlevel= ad_level_sup (e :: List.concat_map ~f:Index.bounds i_list) diff --git a/src/analysis_and_optimization/Monotone_framework.ml b/src/analysis_and_optimization/Monotone_framework.ml index cf2d681878..e761e01bc7 100644 --- a/src/analysis_and_optimization/Monotone_framework.ml +++ b/src/analysis_and_optimization/Monotone_framework.ml @@ -742,7 +742,7 @@ let autodiff_level_rev_transfer | Decl {decl_id; _} -> Set.Poly.singleton decl_id | _ -> Set.Poly.empty in - transfer_gen_kill_alt p gen kill + transfer_gen_kill_alt p gen kill (* gens and then kills *) end : TRANSFER_FUNCTION with type labels = int and type properties = string Set.Poly.t ) @@ -1020,6 +1020,15 @@ let lazy_expressions_mfp let used_not_latest_expressions_mfp = Mf4.mfp () in (latest_expr, used_not_latest_expressions_mfp) +(** Debugging tool to print out MFP sets **) +let print_mfp to_string (mfp : (int, 'a entry_exit) Map.Poly.t) : unit = + let print_set s = + [%sexp (Set.Poly.map ~f:to_string s : string Set.Poly.t)] |> Sexp.to_string_hum + in + Map.iteri mfp ~f:(fun ~key ~data -> + print_endline (string_of_int key ^ ":\t " + ^ print_set data.entry ^ " \t-> " ^ print_set data.exit)) + (** Perform the analysis for ad-levels, using both the fwd and reverse pass *) let autodiff_level_mfp (module Flowgraph : Monotone_framework_sigs.FLOWGRAPH diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml index da1235f53f..0c3efdfd6d 100644 --- a/src/analysis_and_optimization/Optimize.ml +++ b/src/analysis_and_optimization/Optimize.ml @@ -47,9 +47,10 @@ let transform_program (mir : Program.Typed.t) Apply the transformation to each function body and to each program block separately. *) let transform_program_blockwise (mir : Program.Typed.t) - (transform : Stmt.Located.t -> Stmt.Located.t) : Program.Typed.t = - let transform' s = - match transform {pattern= SList s; meta= Location_span.empty} with + (transform : Stmt.Located.t Program.fun_def option -> Stmt.Located.t -> + Stmt.Located.t) : Program.Typed.t = + let transform' fd s = + match transform fd {pattern= SList s; meta= Location_span.empty} with | {pattern= SList l; _} -> l | _ -> raise @@ -57,14 +58,15 @@ let transform_program_blockwise (mir : Program.Typed.t) in let transformed_functions = List.map mir.functions_block ~f:(fun fs -> - {fs with fdbody= transform fs.fdbody} ) + {fs with fdbody= transform (Some fs) fs.fdbody} ) in { mir with functions_block= transformed_functions - ; prepare_data= transform' mir.prepare_data - ; transform_inits= transform' mir.transform_inits - ; log_prob= transform' mir.log_prob - ; generate_quantities= transform' mir.generate_quantities } + ; prepare_data= transform' None mir.prepare_data + ; transform_inits= transform' None mir.transform_inits + ; log_prob= transform' None mir.log_prob + ; generate_quantities= transform' None mir.generate_quantities + } let map_no_loc l = List.map ~f:(fun s -> Stmt.Fixed.{pattern= s; meta= Location_span.empty}) l @@ -421,7 +423,7 @@ let rec contains_top_break_or_continue Stmt.Fixed.({pattern; _}) = | None -> false | Some b -> contains_top_break_or_continue b ) -let unroll_static_loops_statement = +let unroll_static_loops_statement _ = let f stmt = match stmt with | Stmt.Fixed.Pattern.For {loopvar; lower; upper; body} -> ( @@ -460,7 +462,7 @@ let unroll_static_loops_statement = let static_loop_unrolling mir = transform_program_blockwise mir unroll_static_loops_statement -let unroll_loop_one_step_statement = +let unroll_loop_one_step_statement _ = let f stmt = match stmt with | Stmt.Fixed.Pattern.For {loopvar; lower; upper; body} -> @@ -503,7 +505,7 @@ let unroll_loop_one_step_statement = let one_step_loop_unrolling mir = transform_program_blockwise mir unroll_loop_one_step_statement -let collapse_lists_statement = +let collapse_lists_statement _ = let rec collapse_lists l = match l with | [] -> [] @@ -809,11 +811,12 @@ let lazy_code_motion (mir : Program.Typed.t) = @ [lazy_code_motion_stmt (Map.find_exn flowgraph_to_mir 1)] ) ; meta= Location_span.empty } in - transform_program_blockwise mir (fun x -> transform (preprocess_flowgraph x)) + transform_program_blockwise mir (fun _ x -> transform (preprocess_flowgraph x)) let block_fixing mir = transform_program_blockwise mir - (map_rec_stmt_loc (fun stmt -> + (fun _ x -> + (map_rec_stmt_loc (fun stmt -> match stmt with | IfElse ( e @@ -832,6 +835,7 @@ let block_fixing mir = | For {loopvar; lower; upper; body= {pattern= SList l; meta}} -> For {loopvar; lower; upper; body= {pattern= Block l; meta}} | _ -> stmt )) + x) (* TODO: implement SlicStan style optimizer for choosing best program block for each statement. *) (* TODO: add optimization pass to move declarations down as much as possible and introduce as @@ -840,7 +844,14 @@ let block_fixing mir = (* TODO: add pass to get rid of redundant declarations? *) let optimize_ad_levels (mir : Program.Typed.t) = - let transform s = + let global_initial_ad_variables = + Set.Poly.of_list + (List.filter_map + ~f:(fun (v, Program.({out_block; _})) -> + match out_block with Parameters -> Some v | _ -> None ) + mir.output_vars) + in + let transform fundef_opt s = let rev_flowgraph, flowgraph_to_mir = Monotone_framework.inverse_flowgraph_of_stmt s in @@ -848,11 +859,18 @@ let optimize_ad_levels (mir : Program.Typed.t) = let (module Rev_Flowgraph) = rev_flowgraph in let (module Fwd_Flowgraph) = fwd_flowgraph in let initial_ad_variables = - Set.Poly.of_list - (List.filter_map - ~f:(fun (v, Program.({out_block; _})) -> - match out_block with Parameters -> Some v | _ -> None ) - mir.output_vars) + match (fundef_opt : Stmt.Located.t Program.fun_def option) with + | None -> global_initial_ad_variables + | Some {fdargs; _} -> + Set.Poly.union global_initial_ad_variables + (Set.Poly.of_list + (List.filter_map fdargs + ~f:(fun (_, name, ut) -> + if UnsizedType.is_autodiffable ut then + Some name + else + None + ))) in let ad_levels = Monotone_framework.autodiff_level_mfp diff --git a/src/middle/UnsizedType.ml b/src/middle/UnsizedType.ml index f2e032338a..48eb0229a9 100644 --- a/src/middle/UnsizedType.ml +++ b/src/middle/UnsizedType.ml @@ -105,6 +105,13 @@ let is_real_type = function true | _ -> false +let rec is_autodiffable = function + | UReal | UVector | URowVector | UMatrix -> + true + |UArray t -> + is_autodiffable t + | _ -> false + let is_scalar_type = function UReal | UInt -> true | _ -> false let is_int_type = function UInt | UArray UInt -> true | _ -> false let is_fun_type = function UFun _ -> true | _ -> false diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index 118eba6472..abdc90efe8 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -25,7 +25,7 @@ let dump_tx_mir_pretty = ref false let dump_opt_mir = ref false let dump_opt_mir_pretty = ref false let dump_stan_math_sigs = ref false -let optimize = ref false +let optimize_lvl = ref 0 let output_file = ref "" let generate_data = ref false let warn_uninitialized = ref false @@ -98,8 +98,8 @@ let options = , " Take a string to set the model name (default = \ \"$model_filename_model\")" ) ; ( "--O" - , Arg.Set optimize - , " Allow the compiler to apply all optimizations to the Stan \ + , Arg.Set_int optimize_lvl + , "Allow the compiler to apply all optimizations to the Stan \ code.WARNING: This is currently an experimental feature!" ) ; ( "--o" , Arg.Set_string output_file @@ -124,20 +124,28 @@ let options = (* Whether or not to run each optimization. Currently it's all or nothing depending on the --O flag.*) -let optimization_settings () : Optimize.optimization_settings = - { function_inlining= true - ; static_loop_unrolling= true - ; one_step_loop_unrolling= true - ; list_collapsing= true - ; block_fixing= true - ; constant_propagation= true - ; expression_propagation= false - ; copy_propagation= true - ; dead_code_elimination= true - ; partial_evaluation= true - ; lazy_code_motion= false - ; optimize_ad_levels= true - } +let optimization_settings lvl : Optimize.optimization_settings = + let max_safe : Optimize.optimization_settings = + { function_inlining= true + ; static_loop_unrolling= true + ; one_step_loop_unrolling= true + ; list_collapsing= true + ; block_fixing= true + ; constant_propagation= true + ; expression_propagation= false + ; copy_propagation= true + ; dead_code_elimination= true + ; partial_evaluation= true + ; lazy_code_motion= false + ; optimize_ad_levels= false + } + in match lvl with + | 1 -> + max_safe + | 2 -> + {max_safe with optimize_ad_levels= true} + | _ -> + raise (Failure ("Unsupported optimization level " ^ string_of_int lvl)) let print_warn_uninitialized (uninit_vars : (Location_span.t * string) Set.Poly.t) = @@ -213,9 +221,9 @@ let use_file filename = [%sexp (tx_mir : Middle.Program.Typed.t)] ; if !dump_tx_mir_pretty then Program.Typed.pp Format.std_formatter tx_mir ; let opt_mir = - if !optimize then ( + if !optimize_lvl > 0 then ( let opt = - Optimize.optimization_suite (optimization_settings ()) tx_mir + Optimize.optimization_suite (optimization_settings !optimize_lvl) tx_mir in if !dump_opt_mir then Sexp.pp_hum Format.std_formatter diff --git a/test/integration/good/compiler-optimizations/cpp.expected b/test/integration/good/compiler-optimizations/cpp.expected index 23d155647d..645298a11d 100644 --- a/test/integration/good/compiler-optimizations/cpp.expected +++ b/test/integration/good/compiler-optimizations/cpp.expected @@ -1,4 +1,4 @@ - $ ../../../../../install/default/bin/stanc --O --print-cpp optimizations.stan + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp optimizations.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -100,14 +100,12 @@ static const std::vector locations_array__ = {" (found before start of p " (in 'optimizations.stan', line 5, column 8 to column 20)", " (in 'optimizations.stan', line 2, column 33 to line 6, column 5)", " (in 'optimizations.stan', line 28, column 4 to column 19)", - " (in 'optimizations.stan', line 10, column 12 to column 26)", " (in 'optimizations.stan', line 9, column 8 to line 10, column 26)", " (in 'optimizations.stan', line 8, column 20 to line 12, column 5)", " (in 'optimizations.stan', line 30, column 17 to column 28)", " (in 'optimizations.stan', line 33, column 6 to column 22)", " (in 'optimizations.stan', line 31, column 33 to line 34, column 5)", " (in 'optimizations.stan', line 36, column 8 to column 21)", - " (in 'optimizations.stan', line 35, column 21 to line 37, column 5)", " (in 'optimizations.stan', line 35, column 4 to line 37, column 5)", " (in 'optimizations.stan', line 41, column 16 to column 29)", " (in 'optimizations.stan', line 40, column 12 to line 41, column 29)", @@ -168,7 +166,6 @@ static const std::vector locations_array__ = {" (found before start of p " (in 'optimizations.stan', line 134, column 4 to column 15)", " (in 'optimizations.stan', line 137, column 8 to column 23)", " (in 'optimizations.stan', line 138, column 8 to column 24)", - " (in 'optimizations.stan', line 135, column 21 to line 139, column 5)", " (in 'optimizations.stan', line 135, column 4 to line 139, column 5)", " (in 'optimizations.stan', line 140, column 4 to column 25)", " (in 'optimizations.stan', line 143, column 4 to column 26)", @@ -178,6 +175,7 @@ static const std::vector locations_array__ = {" (found before start of p " (in 'optimizations.stan', line 147, column 4 to column 23)", " (in 'optimizations.stan', line 4, column 10 to column 17)", " (in 'optimizations.stan', line 3, column 8 to line 4, column 17)", + " (in 'optimizations.stan', line 10, column 12 to column 26)", " (in 'optimizations.stan', line 11, column 8 to column 21)", " (in 'optimizations.stan', line 16, column 8 to column 18)"}; @@ -190,19 +188,13 @@ nrfun_lp(const T0__& x, const int& y, T_lp__& lp__, T_lp_accum__& lp_accum__, using local_scalar_t__ = typename boost::math::tools::promote_args::type; try { - int sym34__; - int sym33__; - { - current_statement__ = 87; - if (logical_gt(x, 342)) { - { - current_statement__ = 86; - return ; - } - } else ; - current_statement__ = 7; - lp_accum__.add(y); - } + current_statement__ = 84; + if (logical_gt(x, 342)) { + current_statement__ = 83; + return ; + } + current_statement__ = 7; + lp_accum__.add(y); } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); // Next line prevents compiler griping about no return @@ -229,20 +221,13 @@ rfun(const int& y, std::ostream* pstream__) { (void) propto__; try { - int sym37__; - int sym36__; - int sym35__; - { - current_statement__ = 11; - if (logical_gt(y, 2)) { - { - current_statement__ = 10; - return (y + 24); - } - } else ; - current_statement__ = 88; - return (y + 2); - } + current_statement__ = 10; + if (logical_gt(y, 2)) { + current_statement__ = 85; + return (y + 24); + } + current_statement__ = 86; + return (y + 2); } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); // Next line prevents compiler griping about no return @@ -265,12 +250,10 @@ rfun_lp(T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__) { using local_scalar_t__ = double; try { - { - current_statement__ = 55; - lp_accum__.add(2); - current_statement__ = 89; - return 24; - } + current_statement__ = 53; + lp_accum__.add(2); + current_statement__ = 87; + return 24; } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); // Next line prevents compiler griping about no return @@ -351,40 +334,6 @@ class optimizations_model : public model_base_crtp { stan::io::reader in__(params_r__, params_i__); try { - local_scalar_t__ sym112__; - int sym111__; - int sym110__; - int sym109__; - int sym108__; - int sym107__; - int sym106__; - int sym105__; - int sym104__; - int sym103__; - int sym102__; - int sym101__; - int sym100__; - int sym99__; - int sym98__; - int sym97__; - int sym96__; - int sym95__; - int sym94__; - int sym93__; - int sym92__; - int sym91__; - int sym90__; - int sym89__; - int sym88__; - int sym87__; - int sym86__; - int sym85__; - int sym84__; - int sym83__; - int sym82__; - int sym81__; - int sym80__; - int sym79__; local_scalar_t__ theta; current_statement__ = 1; @@ -426,22 +375,16 @@ class optimizations_model : public model_base_crtp { current_statement__ = 9; for (size_t sym1__ = 1; sym1__ <= 1; ++sym1__) { - { - current_statement__ = 7; - lp_accum__.add(3); - }} + current_statement__ = 7; + lp_accum__.add(3);} int sym4__; for (size_t sym3__ = 1; sym3__ <= 1; ++sym3__) { { - { - { - sym4__ = 27; - break; - } - } - sym4__ = 5; + sym4__ = 27; break; - }} + } + sym4__ = 5; + break;} if (pstream__) { stan_print(pstream__, sym4__); stan_print(pstream__, "\n"); @@ -449,606 +392,660 @@ class optimizations_model : public model_base_crtp { int sym7__; for (size_t sym6__ = 1; sym6__ <= 1; ++sym6__) { { - { - { - sym7__ = 28; - break; - } - } - sym7__ = 6; + sym7__ = 28; break; - }} + } + sym7__ = 6; + break;} if (sym7__) { - { - current_statement__ = 13; - if (pstream__) { - stan_print(pstream__, "a"); - stan_print(pstream__, "\n"); - } + current_statement__ = 12; + if (pstream__) { + stan_print(pstream__, "a"); + stan_print(pstream__, "\n"); } - } else ; + } int sym10__; int sym13__; for (size_t sym9__ = 1; sym9__ <= 1; ++sym9__) { { - { - { - sym10__ = 31; - break; - } - } - sym10__ = 9; + sym10__ = 31; break; - }} + } + sym10__ = 9; + break;} for (size_t sym12__ = 1; sym12__ <= 1; ++sym12__) { { - { - { - sym13__ = 29; - break; - } - } - sym13__ = 7; + sym13__ = 29; break; - }} + } + sym13__ = 7; + break;} if (logical_lte(sym10__, sym13__)) { { { - { - int sym16__; - for (size_t sym15__ = 1; sym15__ <= 1; ++sym15__) { - { - { - { - sym16__ = 32; - break; - } - } - sym16__ = 10; - break; - }} - lp_accum__.add(sym16__); - current_statement__ = 14; - for (size_t sym17__ = 1; sym17__ <= 1; ++sym17__) { - { - current_statement__ = 7; - lp_accum__.add(3); - }} - } - sym109__ = (sym10__ + 1); - for (size_t sym12__ = 1; sym12__ <= 1; ++sym12__) { + int sym16__; + for (size_t sym15__ = 1; sym15__ <= 1; ++sym15__) { { - { - { - sym13__ = 29; - sym109__ = (sym10__ + 1); - break; - } - } - sym13__ = 7; - sym109__ = (sym10__ + 1); + sym16__ = 32; break; - }} + } + sym16__ = 10; + break;} + lp_accum__.add(sym16__); + current_statement__ = 13; + for (size_t sym17__ = 1; sym17__ <= 1; ++sym17__) { + current_statement__ = 7; + lp_accum__.add(3);} } - for (size_t i = sym109__; i <= sym13__; ++i) { + for (size_t sym12__ = 1; sym12__ <= 1; ++sym12__) { { + sym13__ = 29; + break; + } + sym13__ = 7; + break;} + } + for (size_t i = (sym10__ + 1); i <= sym13__; ++i) { + { + int sym16__; + for (size_t sym15__ = 1; sym15__ <= 1; ++sym15__) { { - int sym16__; - for (size_t sym15__ = 1; sym15__ <= 1; ++sym15__) { - { - { - { - sym16__ = 32; - break; - } - } - sym16__ = 10; - break; - }} - lp_accum__.add(sym16__); - current_statement__ = 14; - for (size_t sym17__ = 1; sym17__ <= 1; ++sym17__) { - { - current_statement__ = 7; - lp_accum__.add(3); - }} + sym16__ = 32; + break; } - for (size_t sym12__ = 1; sym12__ <= 1; ++sym12__) { - { - { - { - sym13__ = 29; - break; - } - } - sym13__ = 7; - break; - }} - }} + sym16__ = 10; + break;} + lp_accum__.add(sym16__); + current_statement__ = 13; + for (size_t sym17__ = 1; sym17__ <= 1; ++sym17__) { + current_statement__ = 7; + lp_accum__.add(3);} + } + for (size_t sym12__ = 1; sym12__ <= 1; ++sym12__) { + { + sym13__ = 29; + break; + } + sym13__ = 7; + break;}} + } + { + { + current_statement__ = 15; + lp_accum__.add(53); + } + { + current_statement__ = 15; + lp_accum__.add(53); + } + { + current_statement__ = 15; + lp_accum__.add(53); } - } else ; + { + current_statement__ = 15; + lp_accum__.add(53); + } + { + current_statement__ = 15; + lp_accum__.add(53); + } + } { { - { - current_statement__ = 16; - lp_accum__.add(53); - } { { - current_statement__ = 16; - lp_accum__.add(53); + { + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + } } - } - { { - current_statement__ = 16; - lp_accum__.add(53); + current_statement__ = 18; + if (logical_lte(2, (2 * 2))) { + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + } } - } - { { - current_statement__ = 16; - lp_accum__.add(53); + current_statement__ = 18; + if (logical_lte(3, (3 * 2))) { + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + } } } - { + } + { + current_statement__ = 19; + if (logical_lte(2, (2 + 2))) { { - current_statement__ = 16; - lp_accum__.add(53); + current_statement__ = 18; + if (logical_lte(2, (2 * 2))) { + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + } } - } + { + current_statement__ = 18; + if (logical_lte(3, (3 * 2))) { + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + } + } + { + current_statement__ = 18; + if (logical_lte(4, (4 * 2))) { + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + } + } + } } - } - { { - { + current_statement__ = 19; + if (logical_lte(3, (3 + 2))) { { - { + current_statement__ = 18; + if (logical_lte(3, (3 * 2))) { { - { - { - { - current_statement__ = 19; - lp_accum__.add(53); - } - { - { - current_statement__ = 19; - lp_accum__.add(53); - } - } - } - } - } - { - { - sym111__ = (2 * 2); - if (logical_lte(2, sym111__)) { - { - { - sym108__ = (2 + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym108__; k <= sym111__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else ; - } - } - { - { - sym111__ = (3 * 2); - if (logical_lte(3, sym111__)) { - { - { - sym108__ = (3 + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym108__; k <= sym111__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else ; - } + current_statement__ = 17; + lp_accum__.add(53); } - } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + } } - } - { { - sym107__ = (2 + 2); - if (logical_lte(2, sym107__)) { - { - { - sym110__ = (2 * 2); - if (logical_lte(2, sym110__)) { - { - { - sym106__ = (2 + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym106__; k <= sym110__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else { - sym106__ = (2 + 1); - } - } - current_statement__ = 20; - for (size_t j = sym106__; j <= sym107__; ++j) { - { - sym111__ = (j * 2); - if (logical_lte(j, sym111__)) { - { - { - sym108__ = (j + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym108__; k <= sym111__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else ; - }} - } - } else ; + current_statement__ = 18; + if (logical_lte(4, (4 * 2))) { + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + } } - } - { { - sym107__ = (3 + 2); - if (logical_lte(3, sym107__)) { - { - { - sym110__ = (3 * 2); - if (logical_lte(3, sym110__)) { - { - { - sym106__ = (3 + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym106__; k <= sym110__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else { - sym106__ = (3 + 1); - } - } - current_statement__ = 20; - for (size_t j = sym106__; j <= sym107__; ++j) { - { - sym111__ = (j * 2); - if (logical_lte(j, sym111__)) { - { - { - sym108__ = (j + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym108__; k <= sym111__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else ; - }} - } - } else ; + current_statement__ = 18; + if (logical_lte(5, (5 * 2))) { + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + } } - } - { + } + } + { + current_statement__ = 19; + if (logical_lte(4, (4 + 2))) { { - sym107__ = (4 + 2); - if (logical_lte(4, sym107__)) { - { - { - sym110__ = (4 * 2); - if (logical_lte(4, sym110__)) { - { - { - sym106__ = (4 + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym106__; k <= sym110__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else { - sym106__ = (4 + 1); - } - } - current_statement__ = 20; - for (size_t j = sym106__; j <= sym107__; ++j) { - { - sym111__ = (j * 2); - if (logical_lte(j, sym111__)) { - { - { - sym108__ = (j + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym108__; k <= sym111__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else ; - }} - } - } else ; + current_statement__ = 18; + if (logical_lte(4, (4 * 2))) { + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + } + } + { + current_statement__ = 18; + if (logical_lte(5, (5 * 2))) { + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + } } - } - { { - sym107__ = (5 + 2); - if (logical_lte(5, sym107__)) { - { - { - sym110__ = (5 * 2); - if (logical_lte(5, sym110__)) { - { - { - sym106__ = (5 + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym106__; k <= sym110__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else { - sym106__ = (5 + 1); - } - } - current_statement__ = 20; - for (size_t j = sym106__; j <= sym107__; ++j) { - { - sym111__ = (j * 2); - if (logical_lte(j, sym111__)) { - { - { - sym108__ = (j + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym108__; k <= sym111__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else ; - }} - } - } else ; + current_statement__ = 18; + if (logical_lte(6, (6 * 2))) { + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + } } - } + } } - } - current_statement__ = 27; - for (size_t i = 1; i <= 5; ++i) { { - current_statement__ = 24; - if (logical_gt(i, 4)) { + current_statement__ = 19; + if (logical_lte(5, (5 + 2))) { { - break; + current_statement__ = 18; + if (logical_lte(5, (5 * 2))) { + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + } } - } else ; - current_statement__ = 25; - lp_accum__.add(2); - }} - current_statement__ = 32; - for (size_t i = 1; i <= 5; ++i) { - { - current_statement__ = 29; - if (logical_gt(i, 4)) { { - continue; + current_statement__ = 18; + if (logical_lte(6, (6 * 2))) { + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + } } - } else ; - current_statement__ = 30; - lp_accum__.add(2); - }} - current_statement__ = 37; - for (size_t i = 1; i <= 5; ++i) { - { - current_statement__ = 34; - if (logical_gt(i, 4)) { { - continue; + current_statement__ = 18; + if (logical_lte(7, (7 * 2))) { + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + { + current_statement__ = 17; + lp_accum__.add(53); + } + } } - } else ; - current_statement__ = 35; - lp_accum__.add(2); - }} - current_statement__ = 38; + } + } + } + current_statement__ = 25; + for (size_t i = 1; i <= 5; ++i) { + current_statement__ = 22; + if (logical_gt(i, 4)) { + break; + } + current_statement__ = 23; + lp_accum__.add(2);} + current_statement__ = 30; + for (size_t i = 1; i <= 5; ++i) { + current_statement__ = 27; + if (logical_gt(i, 4)) { + continue; + } + current_statement__ = 28; + lp_accum__.add(2);} + current_statement__ = 35; + for (size_t i = 1; i <= 5; ++i) { + current_statement__ = 32; + if (logical_gt(i, 4)) { + continue; + } + current_statement__ = 33; + lp_accum__.add(2);} + current_statement__ = 36; lp_accum__.add(3); - current_statement__ = 39; + current_statement__ = 37; lp_accum__.add(2); - current_statement__ = 40; + current_statement__ = 38; lp_accum__.add(247); - current_statement__ = 41; + current_statement__ = 39; lp_accum__.add(576); - current_statement__ = 42; + current_statement__ = 40; lp_accum__.add(5880); double z; - current_statement__ = 44; + current_statement__ = 42; lp_accum__.add(5880); - current_statement__ = 45; + current_statement__ = 43; lp_accum__.add(5880); - current_statement__ = 46; + current_statement__ = 44; lp_accum__.add(2); { double y; - current_statement__ = 48; + current_statement__ = 46; lp_accum__.add(24); } { double y; - current_statement__ = 51; + current_statement__ = 49; lp_accum__.add(245); } { - current_statement__ = 53; + current_statement__ = 51; lp_accum__.add(2); } int sym20__; for (size_t sym19__ = 1; sym19__ <= 1; ++sym19__) { - { - current_statement__ = 55; - lp_accum__.add(2); - break; - }} - current_statement__ = 58; + current_statement__ = 53; + lp_accum__.add(2); + break;} + current_statement__ = 56; while (576) { - { - break; - } + break; } int sym23__; for (size_t sym22__ = 1; sym22__ <= 1; ++sym22__) { - { - current_statement__ = 55; - lp_accum__.add(2); - sym23__ = 24; - break; - }} + current_statement__ = 53; + lp_accum__.add(2); + sym23__ = 24; + break;} while (sym23__) { { - { - break; - } - for (size_t sym22__ = 1; sym22__ <= 1; ++sym22__) { - { - current_statement__ = 55; - lp_accum__.add(2); - sym23__ = 24; - break; - }} + break; } + for (size_t sym22__ = 1; sym22__ <= 1; ++sym22__) { + current_statement__ = 53; + lp_accum__.add(2); + sym23__ = 24; + break;} } + current_statement__ = 59; + for (size_t i = 31; i <= 225; ++i) { continue;} current_statement__ = 61; - for (size_t i = 31; i <= 225; ++i) { { - continue; - }} - current_statement__ = 63; - for (size_t i = 31; i <= 225; ++i) { { - break; - }} + for (size_t i = 31; i <= 225; ++i) { break;} int sym26__; for (size_t sym25__ = 1; sym25__ <= 1; ++sym25__) { - { - current_statement__ = 55; - lp_accum__.add(2); - sym26__ = 24; - break; - }} - for (size_t i = sym26__; i <= 225; ++i) { { - continue; - }} + current_statement__ = 53; + lp_accum__.add(2); + sym26__ = 24; + break;} + for (size_t i = sym26__; i <= 225; ++i) { continue;} int sym29__; for (size_t sym28__ = 1; sym28__ <= 1; ++sym28__) { - { - current_statement__ = 55; - lp_accum__.add(2); - sym29__ = 24; - break; - }} - for (size_t i = sym29__; i <= 225; ++i) { { - break; - }} + current_statement__ = 53; + lp_accum__.add(2); + sym29__ = 24; + break;} + for (size_t i = sym29__; i <= 225; ++i) { break;} int sym32__; for (size_t sym31__ = 1; sym31__ <= 1; ++sym31__) { - { - current_statement__ = 55; - lp_accum__.add(2); - break; - }} + current_statement__ = 53; + lp_accum__.add(2); + break;} { - current_statement__ = 66; + current_statement__ = 64; lp_accum__.add(1); - current_statement__ = 67; + current_statement__ = 65; lp_accum__.add(24); } { { - current_statement__ = 69; + current_statement__ = 67; lp_accum__.add(1); } } double temp; { - { - current_statement__ = 73; - if (pstream__) { - stan_print(pstream__, "hello"); - stan_print(pstream__, "\n"); - } + current_statement__ = 71; + if (pstream__) { + stan_print(pstream__, "hello"); + stan_print(pstream__, "\n"); } } double temp2; { { - { - current_statement__ = 76; - lp_accum__.add(4); - current_statement__ = 77; - lp_accum__.add(6); - } - { - { - current_statement__ = 76; - lp_accum__.add(4); - current_statement__ = 77; - lp_accum__.add(6); - } - } + current_statement__ = 74; + lp_accum__.add(4); + current_statement__ = 75; + lp_accum__.add(6); + } + { + current_statement__ = 74; + lp_accum__.add(4); + current_statement__ = 75; + lp_accum__.add(6); } } double dataonlyvar; - current_statement__ = 81; + current_statement__ = 78; lp_accum__.add(159); - double paramvar; + local_scalar_t__ paramvar; { - { - sym112__ = (theta * 34); - } + current_statement__ = 80; + paramvar = (theta * 34); } - current_statement__ = 85; - lp_accum__.add(sym112__); + current_statement__ = 82; + lp_accum__.add(paramvar); } } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); @@ -1078,23 +1075,6 @@ class optimizations_model : public model_base_crtp { stan::math::accumulator lp_accum__; try { - double sym78__; - double sym77__; - double sym76__; - double sym75__; - double sym74__; - double sym73__; - double sym72__; - double sym71__; - double sym70__; - double sym69__; - Eigen::Matrix sym68__; - int sym67__; - int sym66__; - double sym65__; - int sym64__; - int sym63__; - double sym62__; double theta; current_statement__ = 1; @@ -1131,153 +1111,107 @@ class optimizations_model : public model_base_crtp { current_statement__ = 5; x_cov_in__ = in__.vector(3); - assign(sym68__, nil_index_list(), + current_statement__ = 5; + assign(x_cov, nil_index_list(), stan::math::cov_matrix_constrain(x_cov_in__, 2), - "assigning variable sym68__"); - assign(x_cov, nil_index_list(), sym68__, "assigning variable x_cov"); + "assigning variable x_cov"); vars__.push_back(theta); vars__.push_back(phi); { { { { - { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), - "x_matrix")); - } - { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), - "x_matrix")); - } - } - { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(3), - cons_list(index_uni(1), nil_index_list())), - "x_matrix")); - } - } - } + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); } - } - { { - { - { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), - "x_matrix")); - } - { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(2), - cons_list(index_uni(2), nil_index_list())), - "x_matrix")); - } - } - { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(3), - cons_list(index_uni(2), nil_index_list())), - "x_matrix")); - } - } - } - } + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(2), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); + } + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(3), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); } } } - } - { { { - vars__.push_back(x_vector[(1 - 1)]); - } - { { - vars__.push_back(x_vector[(2 - 1)]); + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), "x_matrix")); + } + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(2), + cons_list(index_uni(2), nil_index_list())), "x_matrix")); + } + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(3), + cons_list(index_uni(2), nil_index_list())), "x_matrix")); } } } } + { + { + vars__.push_back(x_vector[(1 - 1)]); + } + { + vars__.push_back(x_vector[(2 - 1)]); + } + } { { { { - { - { - vars__.push_back( - rvalue(sym68__, - cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), - "sym68__")); - } - { - { - vars__.push_back( - rvalue(sym68__, - cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), - "sym68__")); - } - } - } + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "x_cov")); + } + { + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(2), + cons_list(index_uni(1), nil_index_list())), "x_cov")); } } + } + { { { - { - { - { - vars__.push_back( - rvalue(sym68__, - cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), - "sym68__")); - } - { - { - vars__.push_back( - rvalue(sym68__, - cons_list(index_uni(2), - cons_list(index_uni(2), nil_index_list())), - "sym68__")); - } - } - } - } + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), "x_cov")); + } + { + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(2), + cons_list(index_uni(2), nil_index_list())), "x_cov")); } } } } if (logical_negation((primitive_value(emit_transformed_parameters__) || primitive_value(emit_generated_quantities__)))) { - { - return ; - } - } else ; + return ; + } if (logical_negation(emit_generated_quantities__)) { - { - return ; - } - } else ; + return ; + } } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); // Next line prevents compiler griping about no return @@ -1293,38 +1227,16 @@ class optimizations_model : public model_base_crtp { vars__.reserve(num_params_r__); try { - double sym61__; - double sym60__; - double sym59__; - double sym58__; - double sym57__; - double sym56__; - double sym55__; - double sym54__; - double sym53__; - double sym52__; - double sym51__; - double sym50__; - double sym49__; - double sym48__; - double sym47__; - double sym46__; - double sym45__; - double sym44__; - std::vector sym43__; - std::vector sym42__; - std::vector sym41__; - int sym40__; - int sym39__; - int sym38__; int pos__; double theta; - sym55__ = context__.vals_r("theta")[(1 - 1)]; + current_statement__ = 1; + theta = context__.vals_r("theta")[(1 - 1)]; double phi; - sym54__ = context__.vals_r("phi")[(1 - 1)]; + current_statement__ = 2; + phi = context__.vals_r("phi")[(1 - 1)]; current_statement__ = 3; validate_non_negative_index("x_matrix", "3", 3); current_statement__ = 3; @@ -1334,81 +1246,67 @@ class optimizations_model : public model_base_crtp { { std::vector x_matrix_flat__; - assign(sym42__, nil_index_list(), context__.vals_r("x_matrix"), - "assigning variable sym42__"); + current_statement__ = 3; + assign(x_matrix_flat__, nil_index_list(), + context__.vals_r("x_matrix"), "assigning variable x_matrix_flat__"); { { { { - { - { - current_statement__ = 3; - assign(x_matrix, - cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), - sym42__[(1 - 1)], "assigning variable x_matrix"); - current_statement__ = 3; - pos__ = 2; - } - { - { - current_statement__ = 3; - assign(x_matrix, - cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), - sym42__[(pos__ - 1)], "assigning variable x_matrix"); - current_statement__ = 3; - pos__ = (pos__ + 1); - } - } - { - { - current_statement__ = 3; - assign(x_matrix, - cons_list(index_uni(3), - cons_list(index_uni(1), nil_index_list())), - sym42__[(pos__ - 1)], "assigning variable x_matrix"); - current_statement__ = 3; - pos__ = (pos__ + 1); - } - } - } + current_statement__ = 3; + assign(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + x_matrix_flat__[(1 - 1)], "assigning variable x_matrix"); + current_statement__ = 3; + pos__ = (1 + 1); + } + { + current_statement__ = 3; + assign(x_matrix, + cons_list(index_uni(2), + cons_list(index_uni(1), nil_index_list())), + x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); + current_statement__ = 3; + pos__ = (pos__ + 1); + } + { + current_statement__ = 3; + assign(x_matrix, + cons_list(index_uni(3), + cons_list(index_uni(1), nil_index_list())), + x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); + current_statement__ = 3; + pos__ = (pos__ + 1); } } + } + { { { - { - { - { - assign(x_matrix, - cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), - sym42__[(pos__ - 1)], "assigning variable x_matrix"); - current_statement__ = 3; - pos__ = (pos__ + 1); - } - { - { - current_statement__ = 3; - assign(x_matrix, - cons_list(index_uni(2), - cons_list(index_uni(2), nil_index_list())), - sym42__[(pos__ - 1)], "assigning variable x_matrix"); - current_statement__ = 3; - pos__ = (pos__ + 1); - } - } - { - { - current_statement__ = 3; - assign(x_matrix, - cons_list(index_uni(3), - cons_list(index_uni(2), nil_index_list())), - sym42__[(pos__ - 1)], "assigning variable x_matrix"); - } - } - } - } + current_statement__ = 3; + assign(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), + x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); + current_statement__ = 3; + pos__ = (pos__ + 1); + } + { + current_statement__ = 3; + assign(x_matrix, + cons_list(index_uni(2), + cons_list(index_uni(2), nil_index_list())), + x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); + current_statement__ = 3; + pos__ = (pos__ + 1); + } + { + current_statement__ = 3; + assign(x_matrix, + cons_list(index_uni(3), + cons_list(index_uni(2), nil_index_list())), + x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); } } } @@ -1421,24 +1319,21 @@ class optimizations_model : public model_base_crtp { { std::vector x_vector_flat__; - assign(sym43__, nil_index_list(), context__.vals_r("x_vector"), - "assigning variable sym43__"); + current_statement__ = 4; + assign(x_vector_flat__, nil_index_list(), + context__.vals_r("x_vector"), "assigning variable x_vector_flat__"); { { - { - current_statement__ = 4; - assign(x_vector, cons_list(index_uni(1), nil_index_list()), - sym43__[(1 - 1)], "assigning variable x_vector"); - current_statement__ = 4; - pos__ = 2; - } - { - { - current_statement__ = 4; - assign(x_vector, cons_list(index_uni(2), nil_index_list()), - sym43__[(pos__ - 1)], "assigning variable x_vector"); - } - } + current_statement__ = 4; + assign(x_vector, cons_list(index_uni(1), nil_index_list()), + x_vector_flat__[(1 - 1)], "assigning variable x_vector"); + current_statement__ = 4; + pos__ = (1 + 1); + } + { + current_statement__ = 4; + assign(x_vector, cons_list(index_uni(2), nil_index_list()), + x_vector_flat__[(pos__ - 1)], "assigning variable x_vector"); } } } @@ -1451,59 +1346,49 @@ class optimizations_model : public model_base_crtp { { std::vector x_cov_flat__; - assign(sym41__, nil_index_list(), context__.vals_r("x_cov"), - "assigning variable sym41__"); + current_statement__ = 5; + assign(x_cov_flat__, nil_index_list(), context__.vals_r("x_cov"), + "assigning variable x_cov_flat__"); { { { { - { - { - current_statement__ = 5; - assign(x_cov, - cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), - sym41__[(1 - 1)], "assigning variable x_cov"); - current_statement__ = 5; - pos__ = 2; - } - { - { - current_statement__ = 5; - assign(x_cov, - cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), - sym41__[(pos__ - 1)], "assigning variable x_cov"); - current_statement__ = 5; - pos__ = (pos__ + 1); - } - } - } + current_statement__ = 5; + assign(x_cov, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + x_cov_flat__[(1 - 1)], "assigning variable x_cov"); + current_statement__ = 5; + pos__ = (1 + 1); + } + { + current_statement__ = 5; + assign(x_cov, + cons_list(index_uni(2), + cons_list(index_uni(1), nil_index_list())), + x_cov_flat__[(pos__ - 1)], "assigning variable x_cov"); + current_statement__ = 5; + pos__ = (pos__ + 1); } } + } + { { { - { - { - { - assign(x_cov, - cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), - sym41__[(pos__ - 1)], "assigning variable x_cov"); - current_statement__ = 5; - pos__ = (pos__ + 1); - } - { - { - current_statement__ = 5; - assign(x_cov, - cons_list(index_uni(2), - cons_list(index_uni(2), nil_index_list())), - sym41__[(pos__ - 1)], "assigning variable x_cov"); - } - } - } - } + current_statement__ = 5; + assign(x_cov, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), + x_cov_flat__[(pos__ - 1)], "assigning variable x_cov"); + current_statement__ = 5; + pos__ = (pos__ + 1); + } + { + current_statement__ = 5; + assign(x_cov, + cons_list(index_uni(2), + cons_list(index_uni(2), nil_index_list())), + x_cov_flat__[(pos__ - 1)], "assigning variable x_cov"); } } } @@ -1512,133 +1397,92 @@ class optimizations_model : public model_base_crtp { current_statement__ = 5; assign(x_cov, nil_index_list(), stan::math::cov_matrix_free(x_cov), "assigning variable x_cov"); - vars__.push_back(sym55__); - vars__.push_back(sym54__); + vars__.push_back(theta); + vars__.push_back(phi); { { { { - { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), - "x_matrix")); - } - { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), - "x_matrix")); - } - } - { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(3), - cons_list(index_uni(1), nil_index_list())), - "x_matrix")); - } - } - } + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); } - } - { { - { - { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), - "x_matrix")); - } - { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(2), - cons_list(index_uni(2), nil_index_list())), - "x_matrix")); - } - } - { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(3), - cons_list(index_uni(2), nil_index_list())), - "x_matrix")); - } - } - } - } + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(2), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); + } + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(3), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); } } } - } - { { - { - vars__.push_back(x_vector[(1 - 1)]); - } { { - vars__.push_back(x_vector[(2 - 1)]); + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), "x_matrix")); + } + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(2), + cons_list(index_uni(2), nil_index_list())), "x_matrix")); + } + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(3), + cons_list(index_uni(2), nil_index_list())), "x_matrix")); } } } } + { + { + vars__.push_back(x_vector[(1 - 1)]); + } + { + vars__.push_back(x_vector[(2 - 1)]); + } + } { { { { - { - { - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), "x_cov")); - } - { - { - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), - "x_cov")); - } - } - } + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "x_cov")); + } + { + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(2), + cons_list(index_uni(1), nil_index_list())), "x_cov")); } } + } + { { { - { - { - { - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), - "x_cov")); - } - { - { - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(2), - cons_list(index_uni(2), nil_index_list())), - "x_cov")); - } - } - } - } + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), "x_cov")); + } + { + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(2), + cons_list(index_uni(2), nil_index_list())), "x_cov")); } } } @@ -1689,22 +1533,22 @@ class optimizations_model : public model_base_crtp { param_names__.push_back(std::string() + "theta"); param_names__.push_back(std::string() + "phi"); - for (size_t sym113__ = 1; sym113__ <= 2; ++sym113__) { + for (size_t sym33__ = 1; sym33__ <= 2; ++sym33__) { { - for (size_t sym114__ = 1; sym114__ <= 3; ++sym114__) { + for (size_t sym34__ = 1; sym34__ <= 3; ++sym34__) { { - param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym114__) + '.' + std::to_string(sym113__)); + param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym34__) + '.' + std::to_string(sym33__)); }} }} - for (size_t sym113__ = 1; sym113__ <= 2; ++sym113__) { + for (size_t sym33__ = 1; sym33__ <= 2; ++sym33__) { { - param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym113__)); + param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym33__)); }} - for (size_t sym113__ = 1; sym113__ <= 2; ++sym113__) { + for (size_t sym33__ = 1; sym33__ <= 2; ++sym33__) { { - for (size_t sym114__ = 1; sym114__ <= 2; ++sym114__) { + for (size_t sym34__ = 1; sym34__ <= 2; ++sym34__) { { - param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym114__) + '.' + std::to_string(sym113__)); + param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym34__) + '.' + std::to_string(sym33__)); }} }} if (emit_transformed_parameters__) { @@ -1723,20 +1567,20 @@ class optimizations_model : public model_base_crtp { param_names__.push_back(std::string() + "theta"); param_names__.push_back(std::string() + "phi"); - for (size_t sym113__ = 1; sym113__ <= 2; ++sym113__) { + for (size_t sym33__ = 1; sym33__ <= 2; ++sym33__) { { - for (size_t sym114__ = 1; sym114__ <= 3; ++sym114__) { + for (size_t sym34__ = 1; sym34__ <= 3; ++sym34__) { { - param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym114__) + '.' + std::to_string(sym113__)); + param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym34__) + '.' + std::to_string(sym33__)); }} }} - for (size_t sym113__ = 1; sym113__ <= 2; ++sym113__) { + for (size_t sym33__ = 1; sym33__ <= 2; ++sym33__) { { - param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym113__)); + param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym33__)); }} - for (size_t sym113__ = 1; sym113__ <= 3; ++sym113__) { + for (size_t sym33__ = 1; sym33__ <= 3; ++sym33__) { { - param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym113__)); + param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym33__)); }} if (emit_transformed_parameters__) { diff --git a/test/integration/good/compiler-optimizations/dune b/test/integration/good/compiler-optimizations/dune index f4d4d7da5b..11e53d1e67 100644 --- a/test/integration/good/compiler-optimizations/dune +++ b/test/integration/good/compiler-optimizations/dune @@ -3,7 +3,7 @@ (deps (package stanc) (:stanfiles optimizations.stan)) (action (with-stdout-to %{targets} - (run %{bin:run_bin_on_args} "%{bin:stanc} --O --print-cpp" %{stanfiles})))) + (run %{bin:run_bin_on_args} "%{bin:stanc} --O 2 --print-cpp" %{stanfiles})))) (alias (name runtest) diff --git a/test/unit/Optimize.ml b/test/unit/Optimize.ml index 466e4ae2b9..50307cb650 100644 --- a/test/unit/Optimize.ml +++ b/test/unit/Optimize.ml @@ -3601,8 +3601,8 @@ let%expect_test "adlevel_optimization 2" = w_trans = 1; { data int x; - data array[real, 2] y; - data real z; + array[real, 2] y; + real z; data real z_data; if((1 > 2)) y[1] = (y[1] + x); else y[2] = (y[2] + w); if((2 > 1)) z = y[1]; From d35a553c2dd51e4eaa76d0fd4982a9284e39f2f1 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Thu, 16 Apr 2020 15:41:06 -0400 Subject: [PATCH 03/27] Disallowed dead code elimination from touching any global vars, fixing an issue where it removed a global initialization. This was actually caused by code the was insterted in codegen and was never represented in the MIR. That breaks the separation of concern in the compiler. There are also issues with constant propagation not propagating to the parameters block, and DCE not checking the parameters block for liveness. --- .../Dependence_analysis.ml | 10 ------- src/analysis_and_optimization/Mir_utils.ml | 10 +++++++ src/analysis_and_optimization/Mir_utils.mli | 2 ++ .../Monotone_framework.ml | 16 +++++++++-- src/stan_math_backend/Stan_math_code_gen.ml | 6 ++-- src/stanc/stanc.ml | 28 +++++++++++++++++-- 6 files changed, 53 insertions(+), 19 deletions(-) diff --git a/src/analysis_and_optimization/Dependence_analysis.ml b/src/analysis_and_optimization/Dependence_analysis.ml index 609c997405..aa66764d76 100644 --- a/src/analysis_and_optimization/Dependence_analysis.ml +++ b/src/analysis_and_optimization/Dependence_analysis.ml @@ -170,16 +170,6 @@ let prog_rhs_variables in union_map labels ~f:label_vars -let rec var_declarations Stmt.Fixed.({pattern; _}) : string Set.Poly.t = - match pattern with - | Decl {decl_id; _} -> Set.Poly.singleton decl_id - | IfElse (_, s, None) | While (_, s) | For {body= s; _} -> var_declarations s - | IfElse (_, s1, Some s2) -> - Set.Poly.union (var_declarations s1) (var_declarations s2) - | Block slist | SList slist -> - Set.Poly.union_list (List.map ~f:var_declarations slist) - | _ -> Set.Poly.empty - let stmt_uninitialized_variables (exceptions : string Set.Poly.t) (stmt : Stmt.Located.t) : (Location_span.t * string) Set.Poly.t = let flowgraph, flowgraph_to_mir = diff --git a/src/analysis_and_optimization/Mir_utils.ml b/src/analysis_and_optimization/Mir_utils.ml index 134cffef9e..dd8ec7f18e 100644 --- a/src/analysis_and_optimization/Mir_utils.ml +++ b/src/analysis_and_optimization/Mir_utils.ml @@ -2,6 +2,16 @@ open Core_kernel open Middle open Dataflow_types +let rec var_declarations Stmt.Fixed.({pattern; _}) : string Set.Poly.t = + match pattern with + | Decl {decl_id; _} -> Set.Poly.singleton decl_id + | IfElse (_, s, None) | While (_, s) | For {body= s; _} -> var_declarations s + | IfElse (_, s1, Some s2) -> + Set.Poly.union (var_declarations s1) (var_declarations s2) + | Block slist | SList slist -> + Set.Poly.union_list (List.map ~f:var_declarations slist) + | _ -> Set.Poly.empty + let rec map_rec_expr f e = let recurse = map_rec_expr f in Expr.Fixed.{e with pattern= f (Pattern.map recurse e.pattern)} diff --git a/src/analysis_and_optimization/Mir_utils.mli b/src/analysis_and_optimization/Mir_utils.mli index 6e409838fc..95ebef2d48 100644 --- a/src/analysis_and_optimization/Mir_utils.mli +++ b/src/analysis_and_optimization/Mir_utils.mli @@ -1,6 +1,8 @@ open Core_kernel open Middle open Dataflow_types +val var_declarations : + ('a, 'b) Stmt.Fixed.t -> string Set.Poly.t val map_rec_expr : (Expr.Typed.t Expr.Fixed.Pattern.t -> Expr.Typed.t Expr.Fixed.Pattern.t) diff --git a/src/analysis_and_optimization/Monotone_framework.ml b/src/analysis_and_optimization/Monotone_framework.ml index e761e01bc7..49b6b9ebb6 100644 --- a/src/analysis_and_optimization/Monotone_framework.ml +++ b/src/analysis_and_optimization/Monotone_framework.ml @@ -943,9 +943,19 @@ let live_variables_mfp (prog : Program.Typed.t) (* NOTE: global generated quantities, (transformed) parameters and target are always observable so should be live. *) let initial = - Set.Poly.add - (Set.Poly.of_list (List.map ~f:fst prog.output_vars)) - "target" + Set.Poly.union_list + [ Set.Poly.of_list (List.map ~f:fst prog.output_vars) + (* It is not strictly necessary to exclude data variables from DCE. + However, + 1. We don't currently check for usage of data variables in + corners of the MIR, such as in the sizes of parameters + 2. There is code added in codegen that is never represented in + the MIR that may use data variables as if they're initialized + *) + ; Set.Poly.of_list (List.map ~f:fst prog.input_vars) + ; Set.Poly.union_list (List.map ~f:var_declarations prog.prepare_data) + ; Set.Poly.singleton "target" + ] end : INITIALTYPE with type vals = string ) diff --git a/src/stan_math_backend/Stan_math_code_gen.ml b/src/stan_math_backend/Stan_math_code_gen.ml index 302fc4c63f..80983aeec8 100644 --- a/src/stan_math_backend/Stan_math_code_gen.ml +++ b/src/stan_math_backend/Stan_math_code_gen.ml @@ -212,9 +212,9 @@ let pp_validate_data ppf (name, st) = (* Read in data steps: 1. context__.validate_dims() (what is this?) - 1. find vals_%s__ from context__.vals_%s(vident) - 1. keep track of pos__ - 1. run checks on resulting vident + 2. find vals_%s__ from context__.vals_%s(vident) + 3. keep track of pos__ + 4. run checks on resulting vident *) let pp_ctor ppf p = let params = diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index abdc90efe8..cdad36ab57 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -125,6 +125,21 @@ let options = (* Whether or not to run each optimization. Currently it's all or nothing depending on the --O flag.*) let optimization_settings lvl : Optimize.optimization_settings = + let _ : Optimize.optimization_settings = + { function_inlining= false + ; static_loop_unrolling= false + ; one_step_loop_unrolling= false + ; list_collapsing= false + ; block_fixing= false + ; constant_propagation= false + ; expression_propagation= false + ; copy_propagation= false + ; dead_code_elimination= false + ; partial_evaluation= false + ; lazy_code_motion= false + ; optimize_ad_levels= false + } + in let max_safe : Optimize.optimization_settings = { function_inlining= true ; static_loop_unrolling= true @@ -137,13 +152,20 @@ let optimization_settings lvl : Optimize.optimization_settings = ; dead_code_elimination= true ; partial_evaluation= true ; lazy_code_motion= false - ; optimize_ad_levels= false + ; optimize_ad_levels= true } in match lvl with | 1 -> - max_safe + {max_safe with + (* partial_evaluation= false + * ; one_step_loop_unrolling= false + * ; static_loop_unrolling= false + * ; optimize_ad_levels= false *) + dead_code_elimination= true + (* ; copy_propagation= false *) + } | 2 -> - {max_safe with optimize_ad_levels= true} + max_safe | _ -> raise (Failure ("Unsupported optimization level " ^ string_of_int lvl)) From 8d8f70650d3086a96dd8ca3fc8ea0a75e2a36680 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Thu, 16 Apr 2020 15:47:38 -0400 Subject: [PATCH 04/27] dune promote --- test/integration/good/compiler-optimizations/cpp.expected | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/integration/good/compiler-optimizations/cpp.expected b/test/integration/good/compiler-optimizations/cpp.expected index 645298a11d..a9834e0ad3 100644 --- a/test/integration/good/compiler-optimizations/cpp.expected +++ b/test/integration/good/compiler-optimizations/cpp.expected @@ -1389,6 +1389,8 @@ class optimizations_model : public model_base_crtp { cons_list(index_uni(2), cons_list(index_uni(2), nil_index_list())), x_cov_flat__[(pos__ - 1)], "assigning variable x_cov"); + current_statement__ = 5; + pos__ = (pos__ + 1); } } } From 911a170b07141c8306ad067fa694d31836b5ce7e Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Thu, 16 Apr 2020 18:05:01 -0400 Subject: [PATCH 05/27] Fixed a bug with liveness analysis and else-less if statements (includes debug code) Variables could be killed by if-else statement if they were assigned in the if body and had no else. --- .../Dataflow_utils.ml | 2 +- .../Monotone_framework.ml | 32 +++-- src/analysis_and_optimization/Optimize.ml | 12 +- src/stanc/stanc.ml | 15 +-- .../good/compiler-optimizations/cpp.expected | 114 +++++++++++------- test/unit/Dataflow_utils.ml | 5 +- 6 files changed, 116 insertions(+), 64 deletions(-) diff --git a/src/analysis_and_optimization/Dataflow_utils.ml b/src/analysis_and_optimization/Dataflow_utils.ml index 63111ca0a7..e591be1c14 100644 --- a/src/analysis_and_optimization/Dataflow_utils.ml +++ b/src/analysis_and_optimization/Dataflow_utils.ml @@ -24,7 +24,7 @@ let branching_traverse_statement stmt ~join ~init ~f = | IfElse (pred, then_s, else_s_opt) -> let s', c = f init then_s in Option.value_map else_s_opt - ~default:(s', IfElse (pred, c, None)) + ~default:(join s' init, IfElse (pred, c, None)) ~f:(fun else_s -> let s'', c' = f init else_s in (join s' s'', IfElse (pred, c, Some c')) ) diff --git a/src/analysis_and_optimization/Monotone_framework.ml b/src/analysis_and_optimization/Monotone_framework.ml index 49b6b9ebb6..d7c5e826ad 100644 --- a/src/analysis_and_optimization/Monotone_framework.ml +++ b/src/analysis_and_optimization/Monotone_framework.ml @@ -5,6 +5,19 @@ open Monotone_framework_sigs open Mir_utils open Middle +(** Debugging tool to print out MFP sets **) +let print_mfp to_string (mfp : (int, 'a entry_exit) Map.Poly.t) (flowgraph_to_mir : (int, Stmt.Located.Non_recursive.t) Map.Poly.t) : unit = + let print_set s = + [%sexp (Set.Poly.map ~f:to_string s : string Set.Poly.t)] |> Sexp.to_string_hum + in + let print_stmt s = + [%sexp (s : Stmt.Located.Non_recursive.t)] |> Sexp.to_string_hum + in + Map.iteri mfp ~f:(fun ~key ~data -> + print_endline (string_of_int key ^ ":\n " + ^ print_stmt (Map.Poly.find_exn flowgraph_to_mir key) ^ ":\n " + ^ print_set data.entry ^ " \t-> " ^ print_set data.exit)) + (** Compute the inverse flowgraph of a Stan statement (for reverse analyses) *) let inverse_flowgraph_of_stmt (stmt : Stmt.Located.t) : (module FLOWGRAPH with type labels = int) @@ -943,6 +956,7 @@ let live_variables_mfp (prog : Program.Typed.t) (* NOTE: global generated quantities, (transformed) parameters and target are always observable so should be live. *) let initial = + let i = Set.Poly.union_list [ Set.Poly.of_list (List.map ~f:fst prog.output_vars) (* It is not strictly necessary to exclude data variables from DCE. @@ -956,6 +970,11 @@ let live_variables_mfp (prog : Program.Typed.t) ; Set.Poly.union_list (List.map ~f:var_declarations prog.prepare_data) ; Set.Poly.singleton "target" ] + in + let _ = + 1 + (* print_endline ([%sexp (i : string Set.Poly.t)] |> Sexp.to_string_hum) *) + in i end : INITIALTYPE with type vals = string ) @@ -965,7 +984,9 @@ let live_variables_mfp (prog : Program.Typed.t) let (module Mf) = monotone_framework (module Rev_Flowgraph) (module Lattice) (module Transfer) in - Mf.mfp () + let mfp = Mf.mfp () in + (* let _ = print_mfp ident mfp flowgraph_to_mir in *) + mfp (** Instantiate all four instances of the monotone framework for lazy code motion, reusing code between them *) @@ -1030,15 +1051,6 @@ let lazy_expressions_mfp let used_not_latest_expressions_mfp = Mf4.mfp () in (latest_expr, used_not_latest_expressions_mfp) -(** Debugging tool to print out MFP sets **) -let print_mfp to_string (mfp : (int, 'a entry_exit) Map.Poly.t) : unit = - let print_set s = - [%sexp (Set.Poly.map ~f:to_string s : string Set.Poly.t)] |> Sexp.to_string_hum - in - Map.iteri mfp ~f:(fun ~key ~data -> - print_endline (string_of_int key ^ ":\t " - ^ print_set data.entry ^ " \t-> " ^ print_set data.exit)) - (** Perform the analysis for ad-levels, using both the fwd and reverse pass *) let autodiff_level_mfp (module Flowgraph : Monotone_framework_sigs.FLOWGRAPH diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml index 0c3efdfd6d..70b8868f38 100644 --- a/src/analysis_and_optimization/Optimize.ml +++ b/src/analysis_and_optimization/Optimize.ml @@ -610,7 +610,17 @@ let dead_code_elimination (mir : Program.Typed.t) = | Stmt.Fixed.Pattern.Assignment ((x, _, []), rhs) -> if Set.Poly.mem live_variables_s x || can_side_effect_expr rhs then stmt - else Skip + else + (* let s = + * "Killing var " ^ x + * ^ " at ix " ^ string_of_int i + * ^ " with entry set " ^ + * ([%sexp (live_variables_s : string Set.Poly.t)] |> Sexp.to_string_hum) + * ^ " with stmt " ^ + * ([%sexp (stmt : (Expr.Typed.t, Stmt.Located.t) Stmt.Fixed.Pattern.t)] |> Sexp.to_string_hum) + * in + * let _ = print_endline s in *) + Skip | Assignment ((x, _, is), rhs) -> if Set.Poly.mem live_variables_s x diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index cdad36ab57..867774a788 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -149,23 +149,20 @@ let optimization_settings lvl : Optimize.optimization_settings = ; constant_propagation= true ; expression_propagation= false ; copy_propagation= true - ; dead_code_elimination= true + ; dead_code_elimination= false ; partial_evaluation= true ; lazy_code_motion= false ; optimize_ad_levels= true } in match lvl with | 1 -> - {max_safe with - (* partial_evaluation= false - * ; one_step_loop_unrolling= false - * ; static_loop_unrolling= false - * ; optimize_ad_levels= false *) - dead_code_elimination= true - (* ; copy_propagation= false *) + { max_safe with + dead_code_elimination = true } | 2 -> - max_safe + { max_safe with + dead_code_elimination = true + } | _ -> raise (Failure ("Unsupported optimization level " ^ string_of_int lvl)) diff --git a/test/integration/good/compiler-optimizations/cpp.expected b/test/integration/good/compiler-optimizations/cpp.expected index a9834e0ad3..c66d962a8d 100644 --- a/test/integration/good/compiler-optimizations/cpp.expected +++ b/test/integration/good/compiler-optimizations/cpp.expected @@ -126,13 +126,22 @@ static const std::vector locations_array__ = {" (found before start of p " (in 'optimizations.stan', line 55, column 8 to column 20)", " (in 'optimizations.stan', line 52, column 21 to line 56, column 5)", " (in 'optimizations.stan', line 52, column 4 to line 56, column 5)", + " (in 'optimizations.stan', line 57, column 4 to column 10)", " (in 'optimizations.stan', line 58, column 4 to column 16)", + " (in 'optimizations.stan', line 60, column 6 to column 12)", + " (in 'optimizations.stan', line 59, column 4 to line 60, column 12)", " (in 'optimizations.stan', line 61, column 4 to column 16)", " (in 'optimizations.stan', line 64, column 4 to column 16)", + " (in 'optimizations.stan', line 65, column 4 to column 16)", " (in 'optimizations.stan', line 66, column 4 to column 16)", + " (in 'optimizations.stan', line 68, column 6 to column 19)", + " (in 'optimizations.stan', line 67, column 4 to line 68, column 19)", " (in 'optimizations.stan', line 69, column 4 to column 16)", " (in 'optimizations.stan', line 70, column 4 to column 11)", + " (in 'optimizations.stan', line 71, column 4 to column 10)", " (in 'optimizations.stan', line 72, column 4 to column 16)", + " (in 'optimizations.stan', line 74, column 6 to column 12)", + " (in 'optimizations.stan', line 73, column 4 to line 74, column 12)", " (in 'optimizations.stan', line 75, column 4 to column 16)", " (in 'optimizations.stan', line 78, column 4 to column 16)", " (in 'optimizations.stan', line 80, column 8 to column 19)", @@ -188,9 +197,9 @@ nrfun_lp(const T0__& x, const int& y, T_lp__& lp__, T_lp_accum__& lp_accum__, using local_scalar_t__ = typename boost::math::tools::promote_args::type; try { - current_statement__ = 84; + current_statement__ = 93; if (logical_gt(x, 342)) { - current_statement__ = 83; + current_statement__ = 92; return ; } current_statement__ = 7; @@ -223,10 +232,10 @@ rfun(const int& y, std::ostream* pstream__) { try { current_statement__ = 10; if (logical_gt(y, 2)) { - current_statement__ = 85; + current_statement__ = 94; return (y + 24); } - current_statement__ = 86; + current_statement__ = 95; return (y + 2); } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); @@ -250,9 +259,9 @@ rfun_lp(T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__) { using local_scalar_t__ = double; try { - current_statement__ = 53; + current_statement__ = 62; lp_accum__.add(2); - current_statement__ = 87; + current_statement__ = 96; return 24; } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); @@ -916,51 +925,72 @@ class optimizations_model : public model_base_crtp { current_statement__ = 33; lp_accum__.add(2);} current_statement__ = 36; - lp_accum__.add(3); + x = 3; current_statement__ = 37; - lp_accum__.add(2); - current_statement__ = 38; - lp_accum__.add(247); + lp_accum__.add(3); current_statement__ = 39; - lp_accum__.add(576); + if (logical_gt(theta, 2)) { + current_statement__ = 38; + x = 2; + } current_statement__ = 40; - lp_accum__.add(5880); - double z; - + lp_accum__.add(x); + current_statement__ = 41; + lp_accum__.add(247); current_statement__ = 42; - lp_accum__.add(5880); + x = 576; current_statement__ = 43; - lp_accum__.add(5880); - current_statement__ = 44; + lp_accum__.add(576); + current_statement__ = 45; + if (logical_gt(theta, 46)) { + current_statement__ = 44; + x = 5880; + } + current_statement__ = 46; + lp_accum__.add(x); + double z; + + current_statement__ = 48; + z = x; + current_statement__ = 49; + lp_accum__.add(x); + current_statement__ = 51; + if (logical_gt(theta, 46)) { + current_statement__ = 50; + z = x; + } + current_statement__ = 52; + lp_accum__.add(z); + current_statement__ = 53; lp_accum__.add(2); { double y; - current_statement__ = 46; + current_statement__ = 55; lp_accum__.add(24); } { double y; - current_statement__ = 49; + current_statement__ = 58; lp_accum__.add(245); } { - current_statement__ = 51; + current_statement__ = 60; lp_accum__.add(2); } int sym20__; for (size_t sym19__ = 1; sym19__ <= 1; ++sym19__) { - current_statement__ = 53; + current_statement__ = 62; lp_accum__.add(2); break;} - current_statement__ = 56; + current_statement__ = 65; while (576) { break; } int sym23__; for (size_t sym22__ = 1; sym22__ <= 1; ++sym22__) { - current_statement__ = 53; + current_statement__ = 62; lp_accum__.add(2); sym23__ = 24; break;} @@ -969,50 +999,50 @@ class optimizations_model : public model_base_crtp { break; } for (size_t sym22__ = 1; sym22__ <= 1; ++sym22__) { - current_statement__ = 53; + current_statement__ = 62; lp_accum__.add(2); sym23__ = 24; break;} } - current_statement__ = 59; + current_statement__ = 68; for (size_t i = 31; i <= 225; ++i) { continue;} - current_statement__ = 61; + current_statement__ = 70; for (size_t i = 31; i <= 225; ++i) { break;} int sym26__; for (size_t sym25__ = 1; sym25__ <= 1; ++sym25__) { - current_statement__ = 53; + current_statement__ = 62; lp_accum__.add(2); sym26__ = 24; break;} for (size_t i = sym26__; i <= 225; ++i) { continue;} int sym29__; for (size_t sym28__ = 1; sym28__ <= 1; ++sym28__) { - current_statement__ = 53; + current_statement__ = 62; lp_accum__.add(2); sym29__ = 24; break;} for (size_t i = sym29__; i <= 225; ++i) { break;} int sym32__; for (size_t sym31__ = 1; sym31__ <= 1; ++sym31__) { - current_statement__ = 53; + current_statement__ = 62; lp_accum__.add(2); break;} { - current_statement__ = 64; + current_statement__ = 73; lp_accum__.add(1); - current_statement__ = 65; + current_statement__ = 74; lp_accum__.add(24); } { { - current_statement__ = 67; + current_statement__ = 76; lp_accum__.add(1); } } double temp; { - current_statement__ = 71; + current_statement__ = 80; if (pstream__) { stan_print(pstream__, "hello"); stan_print(pstream__, "\n"); @@ -1022,29 +1052,31 @@ class optimizations_model : public model_base_crtp { { { - current_statement__ = 74; + current_statement__ = 83; lp_accum__.add(4); - current_statement__ = 75; + current_statement__ = 84; lp_accum__.add(6); } { - current_statement__ = 74; + current_statement__ = 83; lp_accum__.add(4); - current_statement__ = 75; + current_statement__ = 84; lp_accum__.add(6); } } double dataonlyvar; - current_statement__ = 78; - lp_accum__.add(159); + current_statement__ = 86; + dataonlyvar = 3; + current_statement__ = 87; + lp_accum__.add(dataonlyvar); local_scalar_t__ paramvar; { - current_statement__ = 80; + current_statement__ = 89; paramvar = (theta * 34); } - current_statement__ = 82; + current_statement__ = 91; lp_accum__.add(paramvar); } } catch (const std::exception& e) { diff --git a/test/unit/Dataflow_utils.ml b/test/unit/Dataflow_utils.ml index 96976e0202..b8e598deaa 100644 --- a/test/unit/Dataflow_utils.ml +++ b/test/unit/Dataflow_utils.ml @@ -292,8 +292,9 @@ let%expect_test "Predecessor graph example" = {| ((7 9 13) ((1 ()) (2 (1)) (3 (2)) (4 (3)) (5 (4)) (6 (5)) (7 (6)) (8 (5)) - (9 (8 16 19 22)) (10 (9)) (11 (10)) (12 (11)) (13 (12)) (14 (13)) (15 (14)) - (16 (15)) (17 (16)) (18 (17)) (19 (18)) (20 (17)) (21 (20)) (22 (19 21)))) + (9 (8 16 19 22)) (10 (9)) (11 (10)) (12 (11)) (13 (12)) (14 (11 13)) + (15 (14)) (16 (15)) (17 (14 16)) (18 (17)) (19 (18)) (20 (17)) (21 (20)) + (22 (19 21)))) |}] let%expect_test "Controlflow graph example" = From 5fca414cb9f38ab11f470351f067446efc1feb02 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Thu, 16 Apr 2020 23:23:19 -0400 Subject: [PATCH 06/27] Fixed an issue where inlines functions would not simulate return statements When a function is inlined, the strategy here is to wrap the function body in a dummy loop, then replace returns with breaks. One issue is early return from internal loops - in those cases, a break would only break out of the inner loop. The solution is a flag variable to indicate whether a 'return' break has been called, and then to check if that flag is set after each loop. Then, if a 'return' break is called from an inner loop, there's a cascade of breaks all the way out of the dummy loop. --- src/analysis_and_optimization/Optimize.ml | 83 ++++++++++++++++++----- src/stanc/stanc.ml | 23 +++++-- 2 files changed, 86 insertions(+), 20 deletions(-) diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml index 70b8868f38..d92dce6cca 100644 --- a/src/analysis_and_optimization/Optimize.ml +++ b/src/analysis_and_optimization/Optimize.ml @@ -128,32 +128,83 @@ let subst_args_stmt args es = subst_stmt m (* TODO: only handle early returns if that's necessary *) +(* The strategy here is to wrap the function body in a dummy loop, then replace + returns with breaks. One issue is early return from internal loops - in + those cases, a break would only break out of the inner loop. The solution is + a flag variable to indicate whether a 'return' break has been called, and + then to check if that flag is set after each loop. Then, if a 'return' break + is called from an inner loop, there's a cascade of breaks all the way out of + the dummy loop. *) let handle_early_returns opt_triple b = + let returned = Gensym.generate () in let f = function | Stmt.Fixed.Pattern.Return opt_ret -> ( - match (opt_triple, opt_ret) with - | None, None -> Stmt.Fixed.Pattern.Break - | Some (Some _, _, name), Some e -> + match (opt_triple, opt_ret) with + | None, None -> Stmt.Fixed.Pattern.Break + | Some (Some _, _, name), Some e -> SList [ Stmt.Fixed. + { pattern= Assignment ((returned, UInt, []), + Expr.Fixed. + { pattern= Lit (Int, "1") + ; meta= + Expr.Typed.Meta. + {type_= UInt; adlevel= DataOnly; loc= Location_span.empty} }) + ; meta= Location_span.empty } + ; Stmt.Fixed. { pattern= Assignment ((name, Expr.Typed.type_of e, []), e) ; meta= Location_span.empty } ; {pattern= Break; meta= Location_span.empty} ] - | _, _ -> raise_s [%sexp ("" : string)] ) + | _, _ -> raise_s [%sexp ("" : string)] ) + | (Stmt.Fixed.Pattern.For _ as loop) -> + Stmt.Fixed.Pattern.SList + [ Stmt.Fixed. + { pattern= loop + ; meta= Location_span.empty } + ; Stmt.Fixed. + { pattern= IfElse + ( Expr.Fixed. + { pattern= Var returned + ; meta= + Expr.Typed.Meta. + {type_= UInt; adlevel= DataOnly; loc= Location_span.empty} } + , {pattern= Break; meta= Location_span.empty} + , None) + ; meta= Location_span.empty } + ] | x -> x in - Stmt.Fixed.Pattern.For - { loopvar= Gensym.generate () - ; lower= - Expr.Fixed. - { pattern= Lit (Int, "1") - ; meta= - Expr.Typed.Meta. - {type_= UInt; adlevel= DataOnly; loc= Location_span.empty} } - ; upper= - { pattern= Lit (Int, "1") - ; meta= {type_= UInt; adlevel= DataOnly; loc= Location_span.empty} } - ; body= map_rec_stmt_loc f b } + Stmt.Fixed.Pattern.SList + [ Stmt.Fixed. + { pattern= Decl + { decl_adtype= DataOnly + ; decl_id= returned + ; decl_type= Sized SInt + } + ; meta= Location_span.empty } + ; Stmt.Fixed. + { pattern= Assignment ((returned, UInt, []), + Expr.Fixed. + { pattern= Lit (Int, "0") + ; meta= + Expr.Typed.Meta. + {type_= UInt; adlevel= DataOnly; loc= Location_span.empty} }) + ; meta= Location_span.empty } + ; Stmt.Fixed. + { pattern= Stmt.Fixed.Pattern.For + { loopvar= Gensym.generate () + ; lower= + Expr.Fixed. + { pattern= Lit (Int, "1") + ; meta= + Expr.Typed.Meta. + {type_= UInt; adlevel= DataOnly; loc= Location_span.empty} } + ; upper= + { pattern= Lit (Int, "1") + ; meta= {type_= UInt; adlevel= DataOnly; loc= Location_span.empty} } + ; body= map_rec_stmt_loc f b } + ; meta= Location_span.empty } + ] let rec inline_function_expression adt fim (Expr.Fixed.({pattern; _}) as e) = match pattern with diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index 867774a788..eb56752f5c 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -140,7 +140,7 @@ let optimization_settings lvl : Optimize.optimization_settings = ; optimize_ad_levels= false } in - let max_safe : Optimize.optimization_settings = + let _ : Optimize.optimization_settings = { function_inlining= true ; static_loop_unrolling= true ; one_step_loop_unrolling= true @@ -149,7 +149,22 @@ let optimization_settings lvl : Optimize.optimization_settings = ; constant_propagation= true ; expression_propagation= false ; copy_propagation= true - ; dead_code_elimination= false + ; dead_code_elimination= true + ; partial_evaluation= true + ; lazy_code_motion= false + ; optimize_ad_levels= true + } + in + let max_safe : Optimize.optimization_settings = + { function_inlining= false + ; static_loop_unrolling= true + ; one_step_loop_unrolling= true + ; list_collapsing= true + ; block_fixing= true + ; constant_propagation= true + ; expression_propagation= false + ; copy_propagation= true + ; dead_code_elimination= true ; partial_evaluation= true ; lazy_code_motion= false ; optimize_ad_levels= true @@ -157,11 +172,11 @@ let optimization_settings lvl : Optimize.optimization_settings = in match lvl with | 1 -> { max_safe with - dead_code_elimination = true + function_inlining = true } | 2 -> { max_safe with - dead_code_elimination = true + function_inlining = true } | _ -> raise (Failure ("Unsupported optimization level " ^ string_of_int lvl)) From 7dd371e2b4b0214a52ad004cd0208df2ebc5b2dd Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Fri, 17 Apr 2020 12:45:18 -0400 Subject: [PATCH 07/27] Fixed how function inlining handles variable name replacement It was conflicting with the dummy variables introduced by inlining. --- src/analysis_and_optimization/Optimize.ml | 63 +-- src/stanc/stanc.ml | 6 +- .../good/compiler-optimizations/cpp.expected | 485 ++++++++++-------- test/unit/Optimize.ml | 269 +++++++--- 4 files changed, 471 insertions(+), 352 deletions(-) diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml index d92dce6cca..92151c1ef9 100644 --- a/src/analysis_and_optimization/Optimize.ml +++ b/src/analysis_and_optimization/Optimize.ml @@ -91,6 +91,22 @@ let replace_fresh_local_vars s' = { type_= Type.to_unsized decl_type ; adlevel= decl_adtype ; loc= Location_span.empty } } ) + | Stmt.Fixed.Pattern.For {loopvar; lower; upper; body} -> + let fresh_name = Gensym.generate () in + ( Stmt.Fixed.Pattern.For + { loopvar= fresh_name + ; lower= lower + ; upper= upper + ; body= body } + , Map.Poly.set m ~key:loopvar + ~data: + Expr.Fixed. + { pattern= Var fresh_name + ; meta= + Expr.Typed.Meta. + { type_= UInt + ; adlevel= DataOnly + ; loc= Location_span.empty } } ) | Assignment ((var_name, ut, l), e) -> let var_name = match Map.Poly.find m var_name with @@ -104,25 +120,6 @@ let replace_fresh_local_vars s' = let s, m = map_rec_state_stmt_loc f Map.Poly.empty s' in subst_stmt m s -let replace_fresh_local_vars_triple (d_list, s_list, e) = - let s = - slist_no_loc - ([slist_no_loc d_list] @ [slist_no_loc s_list] @ [Return (Some e)]) - in - let s = - (replace_fresh_local_vars {pattern= s; meta= Location_span.empty}).pattern - in - match s with - | SList - [ {pattern= SList d_list; _} - ; {pattern= SList s_list; _} - ; {pattern= Return (Some e); _} ] -> - ( List.map ~f:(fun x -> x.pattern) d_list - , List.map ~f:(fun x -> x.pattern) s_list - , e ) - | _ -> - raise_s [%sexp (s : (Expr.Typed.t, Stmt.Located.t) Stmt.Fixed.Pattern.t)] - let subst_args_stmt args es = let m = Map.Poly.of_alist_exn (List.zip_exn args es) in subst_stmt m @@ -206,6 +203,7 @@ let handle_early_returns opt_triple b = ; meta= Location_span.empty } ] +(* Triple is (declaration list, statement list, return expression) *) let rec inline_function_expression adt fim (Expr.Fixed.({pattern; _}) as e) = match pattern with | Var _ -> ([], [], e) @@ -224,16 +222,20 @@ let rec inline_function_expression adt fim (Expr.Fixed.({pattern; _}) as e) = | None -> (d_list, s_list, {e with pattern= FunApp (t, s, es)}) | Some (rt, args, b) -> let x = Gensym.generate () in - let b = handle_early_returns (Some (rt, adt, x)) b in - let d_list2, s_list2, e = - replace_fresh_local_vars_triple - ( [ Decl + let handle = handle_early_returns (Some (rt, adt, x)) in + let d_list2, s_list2, (e:Expr.Typed.t) = + ( [ Stmt.Fixed.Pattern.Decl { decl_adtype= adt ; decl_id= x ; decl_type= Option.value_exn rt } ] - , [ (subst_args_stmt args es - {pattern= b; meta= Location_span.empty}) - .pattern ] + (* We should minimize the code that's having its variables + replaced to avoid conflict with the (two) new dummy + variables introduced by inlining *) + , [ handle + (replace_fresh_local_vars + (subst_args_stmt args es + b)) + ] , { pattern= Var x ; meta= Expr.Typed.Meta. @@ -662,15 +664,6 @@ let dead_code_elimination (mir : Program.Typed.t) = if Set.Poly.mem live_variables_s x || can_side_effect_expr rhs then stmt else - (* let s = - * "Killing var " ^ x - * ^ " at ix " ^ string_of_int i - * ^ " with entry set " ^ - * ([%sexp (live_variables_s : string Set.Poly.t)] |> Sexp.to_string_hum) - * ^ " with stmt " ^ - * ([%sexp (stmt : (Expr.Typed.t, Stmt.Located.t) Stmt.Fixed.Pattern.t)] |> Sexp.to_string_hum) - * in - * let _ = print_endline s in *) Skip | Assignment ((x, _, is), rhs) -> if diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index eb56752f5c..8d34a364ce 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -163,7 +163,7 @@ let optimization_settings lvl : Optimize.optimization_settings = ; block_fixing= true ; constant_propagation= true ; expression_propagation= false - ; copy_propagation= true + ; copy_propagation= false ; dead_code_elimination= true ; partial_evaluation= true ; lazy_code_motion= false @@ -171,9 +171,7 @@ let optimization_settings lvl : Optimize.optimization_settings = } in match lvl with | 1 -> - { max_safe with - function_inlining = true - } + max_safe | 2 -> { max_safe with function_inlining = true diff --git a/test/integration/good/compiler-optimizations/cpp.expected b/test/integration/good/compiler-optimizations/cpp.expected index c66d962a8d..17e6540181 100644 --- a/test/integration/good/compiler-optimizations/cpp.expected +++ b/test/integration/good/compiler-optimizations/cpp.expected @@ -99,11 +99,9 @@ static const std::vector locations_array__ = {" (found before start of p " (in 'optimizations.stan', line 27, column 4 to column 11)", " (in 'optimizations.stan', line 5, column 8 to column 20)", " (in 'optimizations.stan', line 2, column 33 to line 6, column 5)", - " (in 'optimizations.stan', line 28, column 4 to column 19)", " (in 'optimizations.stan', line 9, column 8 to line 10, column 26)", " (in 'optimizations.stan', line 8, column 20 to line 12, column 5)", " (in 'optimizations.stan', line 30, column 17 to column 28)", - " (in 'optimizations.stan', line 33, column 6 to column 22)", " (in 'optimizations.stan', line 31, column 33 to line 34, column 5)", " (in 'optimizations.stan', line 36, column 8 to column 21)", " (in 'optimizations.stan', line 35, column 4 to line 37, column 5)", @@ -197,9 +195,9 @@ nrfun_lp(const T0__& x, const int& y, T_lp__& lp__, T_lp_accum__& lp_accum__, using local_scalar_t__ = typename boost::math::tools::promote_args::type; try { - current_statement__ = 93; + current_statement__ = 91; if (logical_gt(x, 342)) { - current_statement__ = 92; + current_statement__ = 90; return ; } current_statement__ = 7; @@ -230,12 +228,12 @@ rfun(const int& y, std::ostream* pstream__) { (void) propto__; try { - current_statement__ = 10; + current_statement__ = 9; if (logical_gt(y, 2)) { - current_statement__ = 94; + current_statement__ = 92; return (y + 24); } - current_statement__ = 95; + current_statement__ = 93; return (y + 2); } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); @@ -259,9 +257,9 @@ rfun_lp(T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__) { using local_scalar_t__ = double; try { - current_statement__ = 62; + current_statement__ = 60; lp_accum__.add(2); - current_statement__ = 96; + current_statement__ = 94; return 24; } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); @@ -382,121 +380,140 @@ class optimizations_model : public model_base_crtp { { double x; - current_statement__ = 9; - for (size_t sym1__ = 1; sym1__ <= 1; ++sym1__) { + int sym1__; + + for (size_t sym2__ = 1; sym2__ <= 1; ++sym2__) { current_statement__ = 7; lp_accum__.add(3);} + int sym3__; int sym4__; - for (size_t sym3__ = 1; sym3__ <= 1; ++sym3__) { + + for (size_t sym5__ = 1; sym5__ <= 1; ++sym5__) { { - sym4__ = 27; + sym3__ = 27; break; } - sym4__ = 5; + sym3__ = 5; break;} if (pstream__) { - stan_print(pstream__, sym4__); + stan_print(pstream__, sym3__); stan_print(pstream__, "\n"); } + int sym6__; int sym7__; - for (size_t sym6__ = 1; sym6__ <= 1; ++sym6__) { + + for (size_t sym8__ = 1; sym8__ <= 1; ++sym8__) { { - sym7__ = 28; + sym6__ = 28; break; } - sym7__ = 6; + sym6__ = 6; break;} - if (sym7__) { - current_statement__ = 12; + if (sym6__) { + current_statement__ = 11; if (pstream__) { stan_print(pstream__, "a"); stan_print(pstream__, "\n"); } } + int sym9__; + int sym12__; int sym10__; - int sym13__; - for (size_t sym9__ = 1; sym9__ <= 1; ++sym9__) { + + for (size_t sym11__ = 1; sym11__ <= 1; ++sym11__) { { - sym10__ = 31; + sym9__ = 31; break; } - sym10__ = 9; + sym9__ = 9; break;} - for (size_t sym12__ = 1; sym12__ <= 1; ++sym12__) { + int sym13__; + + for (size_t sym14__ = 1; sym14__ <= 1; ++sym14__) { { - sym13__ = 29; + sym12__ = 29; break; } - sym13__ = 7; + sym12__ = 7; break;} - if (logical_lte(sym10__, sym13__)) { + if (logical_lte(sym9__, sym12__)) { { { + int sym15__; int sym16__; - for (size_t sym15__ = 1; sym15__ <= 1; ++sym15__) { + + for (size_t sym17__ = 1; sym17__ <= 1; ++sym17__) { { - sym16__ = 32; + sym15__ = 32; break; } - sym16__ = 10; + sym15__ = 10; break;} - lp_accum__.add(sym16__); - current_statement__ = 13; - for (size_t sym17__ = 1; sym17__ <= 1; ++sym17__) { + lp_accum__.add(sym15__); + int sym18__; + + for (size_t sym19__ = 1; sym19__ <= 1; ++sym19__) { current_statement__ = 7; lp_accum__.add(3);} } - for (size_t sym12__ = 1; sym12__ <= 1; ++sym12__) { + int sym13__; + + for (size_t sym14__ = 1; sym14__ <= 1; ++sym14__) { { - sym13__ = 29; + sym12__ = 29; break; } - sym13__ = 7; + sym12__ = 7; break;} } - for (size_t i = (sym10__ + 1); i <= sym13__; ++i) { + for (size_t i = (sym9__ + 1); i <= sym12__; ++i) { { + int sym15__; int sym16__; - for (size_t sym15__ = 1; sym15__ <= 1; ++sym15__) { + + for (size_t sym17__ = 1; sym17__ <= 1; ++sym17__) { { - sym16__ = 32; + sym15__ = 32; break; } - sym16__ = 10; + sym15__ = 10; break;} - lp_accum__.add(sym16__); - current_statement__ = 13; - for (size_t sym17__ = 1; sym17__ <= 1; ++sym17__) { + lp_accum__.add(sym15__); + int sym18__; + + for (size_t sym19__ = 1; sym19__ <= 1; ++sym19__) { current_statement__ = 7; lp_accum__.add(3);} } - for (size_t sym12__ = 1; sym12__ <= 1; ++sym12__) { + int sym13__; + + for (size_t sym14__ = 1; sym14__ <= 1; ++sym14__) { { - sym13__ = 29; + sym12__ = 29; break; } - sym13__ = 7; + sym12__ = 7; break;}} } { { - current_statement__ = 15; + current_statement__ = 13; lp_accum__.add(53); } { - current_statement__ = 15; + current_statement__ = 13; lp_accum__.add(53); } { - current_statement__ = 15; + current_statement__ = 13; lp_accum__.add(53); } { - current_statement__ = 15; + current_statement__ = 13; lp_accum__.add(53); } { - current_statement__ = 15; + current_statement__ = 13; lp_accum__.add(53); } } @@ -506,49 +523,49 @@ class optimizations_model : public model_base_crtp { { { { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } } } { - current_statement__ = 18; + current_statement__ = 16; if (logical_lte(2, (2 * 2))) { { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } } } { - current_statement__ = 18; + current_statement__ = 16; if (logical_lte(3, (3 * 2))) { { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } } @@ -556,67 +573,67 @@ class optimizations_model : public model_base_crtp { } } { - current_statement__ = 19; + current_statement__ = 17; if (logical_lte(2, (2 + 2))) { { - current_statement__ = 18; + current_statement__ = 16; if (logical_lte(2, (2 * 2))) { { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } } } { - current_statement__ = 18; + current_statement__ = 16; if (logical_lte(3, (3 * 2))) { { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } } } { - current_statement__ = 18; + current_statement__ = 16; if (logical_lte(4, (4 * 2))) { { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } } @@ -624,79 +641,79 @@ class optimizations_model : public model_base_crtp { } } { - current_statement__ = 19; + current_statement__ = 17; if (logical_lte(3, (3 + 2))) { { - current_statement__ = 18; + current_statement__ = 16; if (logical_lte(3, (3 * 2))) { { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } } } { - current_statement__ = 18; + current_statement__ = 16; if (logical_lte(4, (4 * 2))) { { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } } } { - current_statement__ = 18; + current_statement__ = 16; if (logical_lte(5, (5 * 2))) { { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } } @@ -704,91 +721,91 @@ class optimizations_model : public model_base_crtp { } } { - current_statement__ = 19; + current_statement__ = 17; if (logical_lte(4, (4 + 2))) { { - current_statement__ = 18; + current_statement__ = 16; if (logical_lte(4, (4 * 2))) { { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } } } { - current_statement__ = 18; + current_statement__ = 16; if (logical_lte(5, (5 * 2))) { { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } } } { - current_statement__ = 18; + current_statement__ = 16; if (logical_lte(6, (6 * 2))) { { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } } @@ -796,103 +813,103 @@ class optimizations_model : public model_base_crtp { } } { - current_statement__ = 19; + current_statement__ = 17; if (logical_lte(5, (5 + 2))) { { - current_statement__ = 18; + current_statement__ = 16; if (logical_lte(5, (5 * 2))) { { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } } } { - current_statement__ = 18; + current_statement__ = 16; if (logical_lte(6, (6 * 2))) { { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } } } { - current_statement__ = 18; + current_statement__ = 16; if (logical_lte(7, (7 * 2))) { { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } { - current_statement__ = 17; + current_statement__ = 15; lp_accum__.add(53); } } @@ -900,97 +917,101 @@ class optimizations_model : public model_base_crtp { } } } - current_statement__ = 25; + current_statement__ = 23; for (size_t i = 1; i <= 5; ++i) { - current_statement__ = 22; + current_statement__ = 20; if (logical_gt(i, 4)) { break; } - current_statement__ = 23; + current_statement__ = 21; lp_accum__.add(2);} - current_statement__ = 30; + current_statement__ = 28; for (size_t i = 1; i <= 5; ++i) { - current_statement__ = 27; + current_statement__ = 25; if (logical_gt(i, 4)) { continue; } - current_statement__ = 28; + current_statement__ = 26; lp_accum__.add(2);} - current_statement__ = 35; + current_statement__ = 33; for (size_t i = 1; i <= 5; ++i) { - current_statement__ = 32; + current_statement__ = 30; if (logical_gt(i, 4)) { continue; } - current_statement__ = 33; + current_statement__ = 31; lp_accum__.add(2);} - current_statement__ = 36; + current_statement__ = 34; x = 3; - current_statement__ = 37; + current_statement__ = 35; lp_accum__.add(3); - current_statement__ = 39; + current_statement__ = 37; if (logical_gt(theta, 2)) { - current_statement__ = 38; + current_statement__ = 36; x = 2; } - current_statement__ = 40; + current_statement__ = 38; lp_accum__.add(x); - current_statement__ = 41; + current_statement__ = 39; lp_accum__.add(247); - current_statement__ = 42; + current_statement__ = 40; x = 576; - current_statement__ = 43; + current_statement__ = 41; lp_accum__.add(576); - current_statement__ = 45; + current_statement__ = 43; if (logical_gt(theta, 46)) { - current_statement__ = 44; + current_statement__ = 42; x = 5880; } - current_statement__ = 46; + current_statement__ = 44; lp_accum__.add(x); double z; - current_statement__ = 48; + current_statement__ = 46; z = x; + current_statement__ = 47; + lp_accum__.add(z); current_statement__ = 49; - lp_accum__.add(x); - current_statement__ = 51; if (logical_gt(theta, 46)) { - current_statement__ = 50; + current_statement__ = 48; z = x; } - current_statement__ = 52; + current_statement__ = 50; lp_accum__.add(z); - current_statement__ = 53; + current_statement__ = 51; lp_accum__.add(2); { double y; - current_statement__ = 55; + current_statement__ = 53; lp_accum__.add(24); } { double y; - current_statement__ = 58; + current_statement__ = 56; lp_accum__.add(245); } { - current_statement__ = 60; + current_statement__ = 58; lp_accum__.add(2); } int sym20__; - for (size_t sym19__ = 1; sym19__ <= 1; ++sym19__) { - current_statement__ = 62; + int sym21__; + + for (size_t sym22__ = 1; sym22__ <= 1; ++sym22__) { + current_statement__ = 60; lp_accum__.add(2); break;} - current_statement__ = 65; + current_statement__ = 63; while (576) { break; } int sym23__; - for (size_t sym22__ = 1; sym22__ <= 1; ++sym22__) { - current_statement__ = 62; + int sym24__; + + for (size_t sym25__ = 1; sym25__ <= 1; ++sym25__) { + current_statement__ = 60; lp_accum__.add(2); sym23__ = 24; break;} @@ -998,51 +1019,59 @@ class optimizations_model : public model_base_crtp { { break; } - for (size_t sym22__ = 1; sym22__ <= 1; ++sym22__) { - current_statement__ = 62; + int sym24__; + + for (size_t sym25__ = 1; sym25__ <= 1; ++sym25__) { + current_statement__ = 60; lp_accum__.add(2); sym23__ = 24; break;} } - current_statement__ = 68; + current_statement__ = 66; for (size_t i = 31; i <= 225; ++i) { continue;} - current_statement__ = 70; + current_statement__ = 68; for (size_t i = 31; i <= 225; ++i) { break;} int sym26__; - for (size_t sym25__ = 1; sym25__ <= 1; ++sym25__) { - current_statement__ = 62; + int sym27__; + + for (size_t sym28__ = 1; sym28__ <= 1; ++sym28__) { + current_statement__ = 60; lp_accum__.add(2); sym26__ = 24; break;} for (size_t i = sym26__; i <= 225; ++i) { continue;} int sym29__; - for (size_t sym28__ = 1; sym28__ <= 1; ++sym28__) { - current_statement__ = 62; + int sym30__; + + for (size_t sym31__ = 1; sym31__ <= 1; ++sym31__) { + current_statement__ = 60; lp_accum__.add(2); sym29__ = 24; break;} for (size_t i = sym29__; i <= 225; ++i) { break;} int sym32__; - for (size_t sym31__ = 1; sym31__ <= 1; ++sym31__) { - current_statement__ = 62; + int sym33__; + + for (size_t sym34__ = 1; sym34__ <= 1; ++sym34__) { + current_statement__ = 60; lp_accum__.add(2); break;} { - current_statement__ = 73; + current_statement__ = 71; lp_accum__.add(1); - current_statement__ = 74; + current_statement__ = 72; lp_accum__.add(24); } { { - current_statement__ = 76; + current_statement__ = 74; lp_accum__.add(1); } } double temp; { - current_statement__ = 80; + current_statement__ = 78; if (pstream__) { stan_print(pstream__, "hello"); stan_print(pstream__, "\n"); @@ -1052,31 +1081,31 @@ class optimizations_model : public model_base_crtp { { { - current_statement__ = 83; + current_statement__ = 81; lp_accum__.add(4); - current_statement__ = 84; + current_statement__ = 82; lp_accum__.add(6); } { - current_statement__ = 83; + current_statement__ = 81; lp_accum__.add(4); - current_statement__ = 84; + current_statement__ = 82; lp_accum__.add(6); } } double dataonlyvar; - current_statement__ = 86; + current_statement__ = 84; dataonlyvar = 3; - current_statement__ = 87; + current_statement__ = 85; lp_accum__.add(dataonlyvar); local_scalar_t__ paramvar; { - current_statement__ = 89; + current_statement__ = 87; paramvar = (theta * 34); } - current_statement__ = 91; + current_statement__ = 89; lp_accum__.add(paramvar); } } catch (const std::exception& e) { @@ -1156,19 +1185,19 @@ class optimizations_model : public model_base_crtp { vars__.push_back( rvalue(x_matrix, cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), "x_matrix")); + cons_list(index_uni(0), nil_index_list())), "x_matrix")); } { vars__.push_back( rvalue(x_matrix, cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), "x_matrix")); + cons_list(index_uni(0), nil_index_list())), "x_matrix")); } { vars__.push_back( rvalue(x_matrix, cons_list(index_uni(3), - cons_list(index_uni(1), nil_index_list())), "x_matrix")); + cons_list(index_uni(0), nil_index_list())), "x_matrix")); } } } @@ -1178,29 +1207,29 @@ class optimizations_model : public model_base_crtp { vars__.push_back( rvalue(x_matrix, cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), "x_matrix")); + cons_list(index_uni(0), nil_index_list())), "x_matrix")); } { vars__.push_back( rvalue(x_matrix, cons_list(index_uni(2), - cons_list(index_uni(2), nil_index_list())), "x_matrix")); + cons_list(index_uni(0), nil_index_list())), "x_matrix")); } { vars__.push_back( rvalue(x_matrix, cons_list(index_uni(3), - cons_list(index_uni(2), nil_index_list())), "x_matrix")); + cons_list(index_uni(0), nil_index_list())), "x_matrix")); } } } } { { - vars__.push_back(x_vector[(1 - 1)]); + vars__.push_back(x_vector[(0 - 1)]); } { - vars__.push_back(x_vector[(2 - 1)]); + vars__.push_back(x_vector[(0 - 1)]); } } { @@ -1210,13 +1239,13 @@ class optimizations_model : public model_base_crtp { vars__.push_back( rvalue(x_cov, cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), "x_cov")); + cons_list(index_uni(0), nil_index_list())), "x_cov")); } { vars__.push_back( rvalue(x_cov, cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), "x_cov")); + cons_list(index_uni(0), nil_index_list())), "x_cov")); } } } @@ -1226,13 +1255,13 @@ class optimizations_model : public model_base_crtp { vars__.push_back( rvalue(x_cov, cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), "x_cov")); + cons_list(index_uni(0), nil_index_list())), "x_cov")); } { vars__.push_back( rvalue(x_cov, cons_list(index_uni(2), - cons_list(index_uni(2), nil_index_list())), "x_cov")); + cons_list(index_uni(0), nil_index_list())), "x_cov")); } } } @@ -1567,22 +1596,22 @@ class optimizations_model : public model_base_crtp { param_names__.push_back(std::string() + "theta"); param_names__.push_back(std::string() + "phi"); - for (size_t sym33__ = 1; sym33__ <= 2; ++sym33__) { + for (size_t sym35__ = 1; sym35__ <= 2; ++sym35__) { { - for (size_t sym34__ = 1; sym34__ <= 3; ++sym34__) { + for (size_t sym36__ = 1; sym36__ <= 3; ++sym36__) { { - param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym34__) + '.' + std::to_string(sym33__)); + param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym36__) + '.' + std::to_string(sym35__)); }} }} - for (size_t sym33__ = 1; sym33__ <= 2; ++sym33__) { + for (size_t sym35__ = 1; sym35__ <= 2; ++sym35__) { { - param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym33__)); + param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym35__)); }} - for (size_t sym33__ = 1; sym33__ <= 2; ++sym33__) { + for (size_t sym35__ = 1; sym35__ <= 2; ++sym35__) { { - for (size_t sym34__ = 1; sym34__ <= 2; ++sym34__) { + for (size_t sym36__ = 1; sym36__ <= 2; ++sym36__) { { - param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym34__) + '.' + std::to_string(sym33__)); + param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym36__) + '.' + std::to_string(sym35__)); }} }} if (emit_transformed_parameters__) { @@ -1601,20 +1630,20 @@ class optimizations_model : public model_base_crtp { param_names__.push_back(std::string() + "theta"); param_names__.push_back(std::string() + "phi"); - for (size_t sym33__ = 1; sym33__ <= 2; ++sym33__) { + for (size_t sym35__ = 1; sym35__ <= 2; ++sym35__) { { - for (size_t sym34__ = 1; sym34__ <= 3; ++sym34__) { + for (size_t sym36__ = 1; sym36__ <= 3; ++sym36__) { { - param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym34__) + '.' + std::to_string(sym33__)); + param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym36__) + '.' + std::to_string(sym35__)); }} }} - for (size_t sym33__ = 1; sym33__ <= 2; ++sym33__) { + for (size_t sym35__ = 1; sym35__ <= 2; ++sym35__) { { - param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym33__)); + param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym35__)); }} - for (size_t sym33__ = 1; sym33__ <= 3; ++sym33__) { + for (size_t sym35__ = 1; sym35__ <= 3; ++sym35__) { { - param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym33__)); + param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym35__)); }} if (emit_transformed_parameters__) { diff --git a/test/unit/Optimize.ml b/test/unit/Optimize.ml index 50307cb650..09dcfa7555 100644 --- a/test/unit/Optimize.ml +++ b/test/unit/Optimize.ml @@ -153,16 +153,21 @@ let%expect_test "inline functions" = log_prob { { - for(sym1__ in 1:1) { + data int sym1__; + sym1__ = 0; + for(sym2__ in 1:1) { FnPrint__(3); FnPrint__(FnMakeRowVec__(FnMakeRowVec__(3, 2), FnMakeRowVec__(4, 6))); } - real sym4__; - for(sym3__ in 1:1) { - sym4__ = (53 ^ 2); + real sym3__; + data int sym4__; + sym4__ = 0; + for(sym5__ in 1:1) { + sym4__ = 1; + sym3__ = (53 ^ 2); break; } - FnReject__(sym4__); + FnReject__(sym3__); } } @@ -219,10 +224,15 @@ let%expect_test "inline functions 2" = } if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return; if(PNot__(emit_generated_quantities__)) return; - for(sym3__ in 1:1) { - for(sym1__ in 1:1) { + data int sym7__; + sym7__ = 0; + for(sym8__ in 1:1) { + data int sym5__; + sym5__ = 0; + for(sym6__ in 1:1) { } + if(sym7__) break; } } |}] @@ -292,7 +302,16 @@ let%expect_test "list collapsing" = (((pattern (Block (((pattern - (For (loopvar sym1__) + (Decl (decl_adtype DataOnly) (decl_id sym1__) + (decl_type (Sized SInt)))) + (meta )) + ((pattern + (Assignment (sym1__ UInt ()) + ((pattern (Lit Int 0)) + (meta ((type_ UInt) (loc ) (adlevel DataOnly)))))) + (meta )) + ((pattern + (For (loopvar sym2__) (lower ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc ) (adlevel DataOnly))))) @@ -339,11 +358,20 @@ let%expect_test "list collapsing" = (meta ))))) (meta )) ((pattern - (Decl (decl_adtype AutoDiffable) (decl_id sym4__) + (Decl (decl_adtype AutoDiffable) (decl_id sym3__) (decl_type (Unsized UReal)))) (meta )) ((pattern - (For (loopvar sym3__) + (Decl (decl_adtype DataOnly) (decl_id sym4__) + (decl_type (Sized SInt)))) + (meta )) + ((pattern + (Assignment (sym4__ UInt ()) + ((pattern (Lit Int 0)) + (meta ((type_ UInt) (loc ) (adlevel DataOnly)))))) + (meta )) + ((pattern + (For (loopvar sym5__) (lower ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc ) (adlevel DataOnly))))) @@ -354,7 +382,12 @@ let%expect_test "list collapsing" = ((pattern (Block (((pattern - (Assignment (sym4__ UReal ()) + (Assignment (sym4__ UInt ()) + ((pattern (Lit Int 1)) + (meta ((type_ UInt) (loc ) (adlevel DataOnly)))))) + (meta )) + ((pattern + (Assignment (sym3__ UReal ()) ((pattern (FunApp StanLib Pow__ (((pattern (Lit Int 53)) @@ -370,7 +403,7 @@ let%expect_test "list collapsing" = (meta )) ((pattern (NRFunApp CompilerInternal FnReject__ - (((pattern (Var sym4__)) + (((pattern (Var sym3__)) (meta ((type_ UReal) (loc ) (adlevel AutoDiffable))))))) (meta ))))) (meta )))) @@ -502,25 +535,34 @@ let%expect_test "inline function in for loop" = log_prob { { - int sym3__; - int sym6__; - for(sym2__ in 1:1) { + int sym1__; + int sym4__; + data int sym2__; + sym2__ = 0; + for(sym3__ in 1:1) { FnPrint__("f"); - sym3__ = 42; + sym2__ = 1; + sym1__ = 42; break; } - for(sym5__ in 1:1) { + data int sym5__; + sym5__ = 0; + for(sym6__ in 1:1) { FnPrint__("g"); - sym6__ = (3 + 24); + sym5__ = 1; + sym4__ = (3 + 24); break; } - for(i in sym3__:sym6__) { + for(i in sym1__:sym4__) { { FnPrint__("body"); } - for(sym5__ in 1:1) { + data int sym5__; + sym5__ = 0; + for(sym6__ in 1:1) { FnPrint__("g"); - sym6__ = (3 + 24); + sym5__ = 1; + sym4__ = (3 + 24); break; } } @@ -582,37 +624,54 @@ let%expect_test "inline function in for loop 2" = log_prob { { - int sym9__; - int sym12__; - for(sym8__ in 1:1) { + int sym7__; + int sym10__; + data int sym8__; + sym8__ = 0; + for(sym9__ in 1:1) { FnPrint__("f"); - sym9__ = 42; + sym8__ = 1; + sym7__ = 42; break; } - for(sym11__ in 1:1) { + data int sym14__; + sym14__ = 0; + for(sym15__ in 1:1) { FnPrint__("g"); - int sym13__; - for(sym5__ in 1:1) { + int sym11__; + data int sym12__; + sym12__ = 0; + for(sym13__ in 1:1) { FnPrint__("f"); - sym13__ = 42; + sym12__ = 1; + sym11__ = 42; break; } - sym12__ = (sym13__ + 24); + if(sym14__) break; + sym14__ = 1; + sym10__ = (sym11__ + 24); break; } - for(i in sym9__:sym12__) { + for(i in sym7__:sym10__) { { FnPrint__("body"); } - for(sym11__ in 1:1) { + data int sym14__; + sym14__ = 0; + for(sym15__ in 1:1) { FnPrint__("g"); - int sym13__; - for(sym5__ in 1:1) { + int sym11__; + data int sym12__; + sym12__ = 0; + for(sym13__ in 1:1) { FnPrint__("f"); - sym13__ = 42; + sym12__ = 1; + sym11__ = 42; break; } - sym12__ = (sym13__ + 24); + if(sym14__) break; + sym14__ = 1; + sym10__ = (sym11__ + 24); break; } } @@ -672,17 +731,23 @@ let%expect_test "inline function in while loop" = log_prob { { - int sym3__; - for(sym2__ in 1:1) { + int sym1__; + data int sym2__; + sym2__ = 0; + for(sym3__ in 1:1) { FnPrint__("g"); - sym3__ = (3 + 24); + sym2__ = 1; + sym1__ = (3 + 24); break; } - while(sym3__) { + while(sym1__) { FnPrint__("body"); - for(sym2__ in 1:1) { + data int sym2__; + sym2__ = 0; + for(sym3__ in 1:1) { FnPrint__("g"); - sym3__ = (3 + 24); + sym2__ = 1; + sym1__ = (3 + 24); break; } } @@ -742,13 +807,16 @@ let%expect_test "inline function in if then else" = log_prob { { - int sym3__; - for(sym2__ in 1:1) { + int sym1__; + data int sym2__; + sym2__ = 0; + for(sym3__ in 1:1) { FnPrint__("g"); - sym3__ = (3 + 24); + sym2__ = 1; + sym1__ = (3 + 24); break; } - if(sym3__) FnPrint__("body"); + if(sym1__) FnPrint__("body"); } } @@ -817,28 +885,37 @@ let%expect_test "inline function in ternary if " = log_prob { { - int sym3__; - int sym6__; - int sym9__; - for(sym2__ in 1:1) { + int sym1__; + int sym4__; + int sym7__; + data int sym2__; + sym2__ = 0; + for(sym3__ in 1:1) { FnPrint__("f"); - sym3__ = 42; + sym2__ = 1; + sym1__ = 42; break; } - if(sym3__) { - for(sym5__ in 1:1) { + if(sym1__) { + data int sym5__; + sym5__ = 0; + for(sym6__ in 1:1) { FnPrint__("g"); - sym6__ = (3 + 24); + sym5__ = 1; + sym4__ = (3 + 24); break; } } else { - for(sym8__ in 1:1) { + data int sym8__; + sym8__ = 0; + for(sym9__ in 1:1) { FnPrint__("h"); - sym9__ = (4 + 4); + sym8__ = 1; + sym7__ = (4 + 4); break; } } - FnPrint__(sym3__ ?sym6__: sym9__); + FnPrint__(sym1__ ?sym4__: sym7__); } } @@ -891,17 +968,21 @@ let%expect_test "inline function multiple returns " = log_prob { { - int sym3__; - for(sym2__ in 1:1) { + int sym1__; + data int sym2__; + sym2__ = 0; + for(sym3__ in 1:1) { if(2) { FnPrint__("f"); - sym3__ = 42; + sym2__ = 1; + sym1__ = 42; break; } - sym3__ = 6; + sym2__ = 1; + sym1__ = 6; break; } - FnPrint__(sym3__); + FnPrint__(sym1__); } } @@ -950,19 +1031,25 @@ let%expect_test "inline function indices " = log_prob { { array[array[int, 2], 2] a; - int sym6__; - int sym3__; - for(sym5__ in 1:1) { + int sym4__; + int sym1__; + data int sym5__; + sym5__ = 0; + for(sym6__ in 1:1) { FnPrint__(2); - sym6__ = 42; + sym5__ = 1; + sym4__ = 42; break; } - for(sym2__ in 1:1) { + data int sym2__; + sym2__ = 0; + for(sym3__ in 1:1) { FnPrint__(1); - sym3__ = 42; + sym2__ = 1; + sym1__ = 42; break; } - FnPrint__(a[sym3__, sym6__]); + FnPrint__(a[sym1__, sym4__]); } } @@ -1010,21 +1097,27 @@ let%expect_test "inline function and " = log_prob { { - int sym3__; - int sym6__; - for(sym2__ in 1:1) { + int sym1__; + int sym4__; + data int sym2__; + sym2__ = 0; + for(sym3__ in 1:1) { FnPrint__(1); - sym3__ = 42; + sym2__ = 1; + sym1__ = 42; break; } - if(sym3__) { - for(sym5__ in 1:1) { + if(sym1__) { + data int sym5__; + sym5__ = 0; + for(sym6__ in 1:1) { FnPrint__(2); - sym6__ = 42; + sym5__ = 1; + sym4__ = 42; break; } } - FnPrint__(sym3__ && sym6__); + FnPrint__(sym1__ && sym4__); } } @@ -1071,21 +1164,27 @@ let%expect_test "inline function or " = log_prob { { - int sym3__; - int sym6__; - for(sym2__ in 1:1) { + int sym1__; + int sym4__; + data int sym2__; + sym2__ = 0; + for(sym3__ in 1:1) { FnPrint__(1); - sym3__ = 42; + sym2__ = 1; + sym1__ = 42; break; } - if(sym3__) ; else { - for(sym5__ in 1:1) { + if(sym1__) ; else { + data int sym5__; + sym5__ = 0; + for(sym6__ in 1:1) { FnPrint__(2); - sym6__ = 42; + sym5__ = 1; + sym4__ = 42; break; } } - FnPrint__(sym3__ || sym6__); + FnPrint__(sym1__ || sym4__); } } From eee89c848afda1675b73ef2a2d478e48e7f30822 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Fri, 17 Apr 2020 13:49:36 -0400 Subject: [PATCH 08/27] Copy propagation no longer propagates assignments to global variables, similar to DCE --- .../Monotone_framework.ml | 44 +++++++++---------- src/analysis_and_optimization/Optimize.ml | 4 +- src/stanc/stanc.ml | 4 +- .../good/compiler-optimizations/cpp.expected | 2 +- test/unit/Optimize.ml | 17 +++---- 5 files changed, 33 insertions(+), 38 deletions(-) diff --git a/src/analysis_and_optimization/Monotone_framework.ml b/src/analysis_and_optimization/Monotone_framework.ml index d7c5e826ad..9e8333def7 100644 --- a/src/analysis_and_optimization/Monotone_framework.ml +++ b/src/analysis_and_optimization/Monotone_framework.ml @@ -290,6 +290,7 @@ let expression_propagation_transfer (** The transfer function for a copy propagation analysis *) let copy_propagation_transfer + (globals : string Set.Poly.t) (flowgraph_to_mir : (int, Stmt.Located.Non_recursive.t) Map.Poly.t) = ( module struct type labels = int @@ -302,10 +303,11 @@ let copy_propagation_transfer let mir_node = (Map.find_exn flowgraph_to_mir l).pattern in Some ( match mir_node with - | Assignment ((s, _, []), {pattern= Var t; meta}) -> - Map.set m ~key:s ~data:Expr.Fixed.{pattern= Var t; meta} + | Assignment ((s, _, []), {pattern= Var t; meta}) + when not (Set.Poly.mem globals s) -> + Map.set m ~key:s ~data:Expr.Fixed.{pattern= Var t; meta} | Decl {decl_id= s; _} | Assignment ((s, _, _ :: _), _) -> - Map.remove m s + Map.remove m s | Assignment (_, _) |TargetPE _ |NRFunApp (_, _, _) @@ -943,6 +945,21 @@ let initialized_vars_mfp (total : string Set.Poly.t) in Mf.mfp () +let globals (prog : Program.Typed.t) = + Set.Poly.union_list + [ Set.Poly.of_list (List.map ~f:fst prog.output_vars) + (* It is not strictly necessary to exclude data variables from DCE. + However, + 1. We don't currently check for usage of data variables in + corners of the MIR, such as in the sizes of parameters + 2. There is code added in codegen that is never represented in + the MIR that may use data variables as if they're initialized + *) + ; Set.Poly.of_list (List.map ~f:fst prog.input_vars) + ; Set.Poly.union_list (List.map ~f:var_declarations prog.prepare_data) + ; Set.Poly.singleton "target" + ] + (** Monotone framework instance for live_variables analysis. Expects reverse flowgraph. *) let live_variables_mfp (prog : Program.Typed.t) @@ -955,26 +972,7 @@ let live_variables_mfp (prog : Program.Typed.t) (* NOTE: global generated quantities, (transformed) parameters and target are always observable so should be live. *) - let initial = - let i = - Set.Poly.union_list - [ Set.Poly.of_list (List.map ~f:fst prog.output_vars) - (* It is not strictly necessary to exclude data variables from DCE. - However, - 1. We don't currently check for usage of data variables in - corners of the MIR, such as in the sizes of parameters - 2. There is code added in codegen that is never represented in - the MIR that may use data variables as if they're initialized - *) - ; Set.Poly.of_list (List.map ~f:fst prog.input_vars) - ; Set.Poly.union_list (List.map ~f:var_declarations prog.prepare_data) - ; Set.Poly.singleton "target" - ] - in - let _ = - 1 - (* print_endline ([%sexp (i : string Set.Poly.t)] |> Sexp.to_string_hum) *) - in i + let initial = globals prog end : INITIALTYPE with type vals = string ) diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml index 92151c1ef9..831c8787c0 100644 --- a/src/analysis_and_optimization/Optimize.ml +++ b/src/analysis_and_optimization/Optimize.ml @@ -630,7 +630,9 @@ let expression_propagation = propagation (Monotone_framework.expression_propagation_transfer can_side_effect_expr) -let copy_propagation = propagation Monotone_framework.copy_propagation_transfer +let copy_propagation prog = + let globals = Monotone_framework.globals prog in + propagation (Monotone_framework.copy_propagation_transfer globals) prog let is_skip_break_continue s = match s with diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index 8d34a364ce..59d7280854 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -156,7 +156,7 @@ let optimization_settings lvl : Optimize.optimization_settings = } in let max_safe : Optimize.optimization_settings = - { function_inlining= false + { function_inlining= true ; static_loop_unrolling= true ; one_step_loop_unrolling= true ; list_collapsing= true @@ -174,7 +174,7 @@ let optimization_settings lvl : Optimize.optimization_settings = max_safe | 2 -> { max_safe with - function_inlining = true + copy_propagation = true } | _ -> raise (Failure ("Unsupported optimization level " ^ string_of_int lvl)) diff --git a/test/integration/good/compiler-optimizations/cpp.expected b/test/integration/good/compiler-optimizations/cpp.expected index 17e6540181..bd9c551233 100644 --- a/test/integration/good/compiler-optimizations/cpp.expected +++ b/test/integration/good/compiler-optimizations/cpp.expected @@ -970,7 +970,7 @@ class optimizations_model : public model_base_crtp { current_statement__ = 46; z = x; current_statement__ = 47; - lp_accum__.add(z); + lp_accum__.add(x); current_statement__ = 49; if (logical_gt(theta, 46)) { current_statement__ = 48; diff --git a/test/unit/Optimize.ml b/test/unit/Optimize.ml index 09dcfa7555..57e478aae0 100644 --- a/test/unit/Optimize.ml +++ b/test/unit/Optimize.ml @@ -1768,14 +1768,12 @@ let%expect_test "copy propagation" = let ast = Parse.parse_string Parser.Incremental.program {| - transformed data { + model { int i; int j; j = i; int k; k = 2 * j; - } - model { for (x in 1:i) { print(i + j + k); } @@ -1788,16 +1786,13 @@ let%expect_test "copy propagation" = Fmt.strf "@[%a@]" Program.Typed.pp mir |> print_endline ; [%expect {| - prepare_data { - data int i; - data int j; - j = i; - data int k; - k = (2 * i); - } - log_prob { { + int i; + int j; + j = i; + int k; + k = (2 * i); for(x in 1:i) { FnPrint__(((i + i) + k)); } From a7fefca8f47de4591c4e940088f36ada66fc969a Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Sat, 18 Apr 2020 11:09:56 -0400 Subject: [PATCH 09/27] For DCE, globals are always alive. It's hard to predict when they'll be used, and the division in the blocks introduces additional complications. I think this isn't an unreasonable model, but slightly better would be livening them at the end of each Stan block. --- .../Monotone_framework.ml | 12 ++++++++---- .../Partial_evaluator.ml | 9 +++++---- src/stanc/stanc.ml | 19 ++++++++++++------- 3 files changed, 25 insertions(+), 15 deletions(-) diff --git a/src/analysis_and_optimization/Monotone_framework.ml b/src/analysis_and_optimization/Monotone_framework.ml index 9e8333def7..b75d17ae0a 100644 --- a/src/analysis_and_optimization/Monotone_framework.ml +++ b/src/analysis_and_optimization/Monotone_framework.ml @@ -464,6 +464,7 @@ let top_free_vars_stmt (** The transfer function for a live variables analysis *) let live_variables_transfer + (never_kill : string Set.Poly.t) (flowgraph_to_mir : (int, Stmt.Located.Non_recursive.t) Map.Poly.t) = ( module struct type labels = int @@ -485,7 +486,7 @@ let live_variables_transfer |Assignment ((_, _, _ :: _), _) -> Set.Poly.empty in - transfer_gen_kill p gen kill + transfer_gen_kill p gen (Set.Poly.diff kill never_kill) end : TRANSFER_FUNCTION with type labels = int and type properties = string Set.Poly.t ) @@ -966,24 +967,27 @@ let live_variables_mfp (prog : Program.Typed.t) (module Rev_Flowgraph : Monotone_framework_sigs.FLOWGRAPH with type labels = int) (flowgraph_to_mir : (int, Stmt.Located.Non_recursive.t) Map.Poly.t) = + let never_kill = globals prog in let variables = ( module struct type vals = string (* NOTE: global generated quantities, (transformed) parameters and target are always observable so should be live. *) - let initial = globals prog + let initial = never_kill end : INITIALTYPE with type vals = string ) in let (module Lattice) = powerset_lattice variables in - let (module Transfer) = live_variables_transfer flowgraph_to_mir in + let (module Transfer) = live_variables_transfer never_kill flowgraph_to_mir in let (module Mf) = monotone_framework (module Rev_Flowgraph) (module Lattice) (module Transfer) in let mfp = Mf.mfp () in - (* let _ = print_mfp ident mfp flowgraph_to_mir in *) + (* let _ = print_endline "STARTING BLOCK {" in + * let _ = print_mfp ident mfp flowgraph_to_mir in + * let _ = print_endline "} ENDING BLOCK" in *) mfp (** Instantiate all four instances of the monotone framework for lazy diff --git a/src/analysis_and_optimization/Partial_evaluator.ml b/src/analysis_and_optimization/Partial_evaluator.ml index db85f9640f..11c16281ee 100644 --- a/src/analysis_and_optimization/Partial_evaluator.ml +++ b/src/analysis_and_optimization/Partial_evaluator.ml @@ -554,10 +554,11 @@ let rec eval_expr (e : Expr.Typed.t) = | "Minus__", [{pattern= FunApp (StanLib, "exp", l'); _}; x] when is_int 1 x -> FunApp (StanLib, "expm1", l') - | "Plus__", [{pattern= FunApp (StanLib, "Times__", [x; y]); _}; z] - |"Plus__", [z; {pattern= FunApp (StanLib, "Times__", [x; y]); _}] - -> - FunApp (StanLib, "fma", [x; y; z]) + (* DO NOT MERGE THIS TO MASTER, JUST FOR TESTING *) + (* | "Plus__", [{pattern= FunApp (StanLib, "Times__", [x; y]); _}; z] + * |"Plus__", [z; {pattern= FunApp (StanLib, "Times__", [x; y]); _}] + * -> + * FunApp (StanLib, "fma", [x; y; z]) *) | "Minus__", [x; {pattern= FunApp (StanLib, "gamma_p", l); _}] when is_int 1 x -> FunApp (StanLib, "gamma_q", l) diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index 59d7280854..79f09d89f4 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -141,18 +141,21 @@ let optimization_settings lvl : Optimize.optimization_settings = } in let _ : Optimize.optimization_settings = - { function_inlining= true + (*Good for all except: + example-models/ARM/Ch.23/electric_1b.stan + *example-models/bugs_examples/vol1/kidney/kidney.stan *) + { function_inlining= false ; static_loop_unrolling= true ; one_step_loop_unrolling= true ; list_collapsing= true ; block_fixing= true ; constant_propagation= true ; expression_propagation= false - ; copy_propagation= true - ; dead_code_elimination= true + ; copy_propagation= false + ; dead_code_elimination= false ; partial_evaluation= true ; lazy_code_motion= false - ; optimize_ad_levels= true + ; optimize_ad_levels= false } in let max_safe : Optimize.optimization_settings = @@ -163,7 +166,7 @@ let optimization_settings lvl : Optimize.optimization_settings = ; block_fixing= true ; constant_propagation= true ; expression_propagation= false - ; copy_propagation= false + ; copy_propagation= true ; dead_code_elimination= true ; partial_evaluation= true ; lazy_code_motion= false @@ -171,10 +174,12 @@ let optimization_settings lvl : Optimize.optimization_settings = } in match lvl with | 1 -> - max_safe + { max_safe with + function_inlining = false + } | 2 -> { max_safe with - copy_propagation = true + function_inlining = true } | _ -> raise (Failure ("Unsupported optimization level " ^ string_of_int lvl)) From 57a67c8c4de58f45cc7390d374927cba264e359f Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Sat, 18 Apr 2020 13:45:44 -0400 Subject: [PATCH 10/27] Changed the way that inlining reassigns variable names. Variable names were being replaced globally across the function body, so sometimes names would collide. For example, when two for-loops in series both use 'i' as their index, the first loop index would get replaced adding i => sym1__ to the map, then the second would add i=>sym2__ to the map, replacing the first one. Then 'i' would be replaced by sym2__ in both loops, but it hadn't been declared in the first loop. Instead, variables with the same name should be replaced by the same new variable name, they shouldn't overwrite eachother in the map. These won't collide since they didn't collide in the original function body. However, this means that two different variables with different types may both be added to the map, so the map should only keep track of string->string name conversions, not string->expr variable conversions. Along the way I added code to support name->name substitutions and reduced code duplication in mir_utils. --- src/analysis_and_optimization/Mir_utils.ml | 45 +++++++++++++------- src/analysis_and_optimization/Mir_utils.mli | 5 +++ src/analysis_and_optimization/Optimize.ml | 46 ++++++++++----------- src/stanc/stanc.ml | 2 +- 4 files changed, 56 insertions(+), 42 deletions(-) diff --git a/src/analysis_and_optimization/Mir_utils.ml b/src/analysis_and_optimization/Mir_utils.ml index dd8ec7f18e..27de740fa7 100644 --- a/src/analysis_and_optimization/Mir_utils.ml +++ b/src/analysis_and_optimization/Mir_utils.ml @@ -199,33 +199,46 @@ let rec summation_terms (Expr.Fixed.({pattern; _}) as rhs) = let stmt_of_block b = Stmt.Fixed.{pattern= SList b; meta= Stmt.Located.Meta.empty} -let rec subst_expr m (Expr.Fixed.({pattern; _}) as e) = - match pattern with - | Var s -> ( match Map.find m s with Some e' -> e' | None -> e ) - | _ -> Expr.Fixed.{e with pattern= Pattern.map (subst_expr m) pattern} +let rec fn_subst_expr m e = + match m e with + | Some e' -> e' + | _ -> Expr.Fixed.{e with pattern= Pattern.map (fn_subst_expr m) e.pattern} -let subst_idx m = Index.map (subst_expr m) +let fn_subst_idx m = Index.map (fn_subst_expr m) -let subst_stmt_base_helper g h b = +let fn_subst_stmt_base_helper g h b = Stmt.Fixed.Pattern.( match b with | Assignment ((x, ut, l), e2) -> Assignment ((x, ut, List.map ~f:h l), g e2) | x -> map g (fun y -> y) x) -let subst_stmt_base m = subst_stmt_base_helper (subst_expr m) (subst_idx m) -let subst_stmt m = map_rec_stmt_loc (subst_stmt_base m) +let fn_subst_stmt_base m = fn_subst_stmt_base_helper (fn_subst_expr m) (fn_subst_idx m) +let fn_subst_stmt m = map_rec_stmt_loc (fn_subst_stmt_base m) -let rec expr_subst_expr m e = - match Map.find m e with - | Some e' -> e' - | None -> - Expr.Fixed.{e with pattern= Pattern.map (expr_subst_expr m) e.pattern} +let name_map m (e : Expr.Typed.t) = + match e.pattern with + | Var s -> + (match Map.Poly.find m s with + | Some s' -> Some {e with pattern = Var s'} + | None -> None) + | _ -> None -let expr_subst_idx m = Index.map (expr_subst_expr m) +let name_subst_stmt m = fn_subst_stmt (name_map m) -let expr_subst_stmt_base m = - subst_stmt_base_helper (expr_subst_expr m) (expr_subst_idx m) +let var_map m (e : Expr.Typed.t) = + match e.pattern with + | Var s -> Map.find m s + | _ -> None +let subst_expr m e = fn_subst_expr (var_map m) e +let subst_idx m = Index.map (subst_expr m) +let subst_stmt_base m = fn_subst_stmt_base_helper (subst_expr m) (subst_idx m) +let subst_stmt m = map_rec_stmt_loc (subst_stmt_base m) +let expr_map m (e : Expr.Typed.t) = Map.find m e +let expr_subst_expr m e = fn_subst_expr (expr_map m) e +let expr_subst_idx m = Index.map (expr_subst_expr m) +let expr_subst_stmt_base m = + fn_subst_stmt_base_helper (expr_subst_expr m) (expr_subst_idx m) let expr_subst_stmt m = map_rec_stmt_loc (expr_subst_stmt_base m) let rec expr_depth Expr.Fixed.({pattern; _}) = diff --git a/src/analysis_and_optimization/Mir_utils.mli b/src/analysis_and_optimization/Mir_utils.mli index 95ebef2d48..20f1f3e680 100644 --- a/src/analysis_and_optimization/Mir_utils.mli +++ b/src/analysis_and_optimization/Mir_utils.mli @@ -146,6 +146,11 @@ val subst_stmt : (string, Expr.Typed.t) Map.Poly.t -> Stmt.Located.t -> Stmt.Located.t (** Substitute variables occurring anywhere in a statement according to the provided Map. *) +val name_subst_stmt : + (string, string) Map.Poly.t -> Stmt.Located.t -> Stmt.Located.t +(** Substitute subexpressions occurring anywhere in a statement according to the provided Map. *) + + val expr_subst_expr : Expr.Typed.t Expr.Typed.Map.t -> Expr.Typed.t -> Expr.Typed.t (** Substitute subexpressions in an expression according to the provided Map, trying diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml index 831c8787c0..0d5803fcef 100644 --- a/src/analysis_and_optimization/Optimize.ml +++ b/src/analysis_and_optimization/Optimize.ml @@ -80,45 +80,41 @@ let slist_concat_no_loc l stmt = let replace_fresh_local_vars s' = let f m = function | Stmt.Fixed.Pattern.Decl {decl_adtype; decl_type; decl_id} -> - let fresh_name = Gensym.generate () in - ( Stmt.Fixed.Pattern.Decl {decl_adtype; decl_id= fresh_name; decl_type} - , Map.Poly.set m ~key:decl_id - ~data: - Expr.Fixed. - { pattern= Var fresh_name - ; meta= - Expr.Typed.Meta. - { type_= Type.to_unsized decl_type - ; adlevel= decl_adtype - ; loc= Location_span.empty } } ) + let new_name = match Map.Poly.find m decl_id with + | Some existing -> existing + | None -> Gensym.generate () + in + ( Stmt.Fixed.Pattern.Decl {decl_adtype; decl_id= new_name; decl_type} + , Map.Poly.set m ~key:decl_id ~data:new_name + ) | Stmt.Fixed.Pattern.For {loopvar; lower; upper; body} -> - let fresh_name = Gensym.generate () in + let new_name = match Map.Poly.find m loopvar with + | Some existing -> existing + | None -> Gensym.generate () + in ( Stmt.Fixed.Pattern.For - { loopvar= fresh_name + { loopvar= new_name ; lower= lower ; upper= upper ; body= body } - , Map.Poly.set m ~key:loopvar - ~data: - Expr.Fixed. - { pattern= Var fresh_name - ; meta= - Expr.Typed.Meta. - { type_= UInt - ; adlevel= DataOnly - ; loc= Location_span.empty } } ) + , Map.Poly.set m ~key:loopvar ~data:new_name) | Assignment ((var_name, ut, l), e) -> let var_name = match Map.Poly.find m var_name with | None -> var_name - | Some Expr.Fixed.({pattern= Var var_name; _}) -> var_name - | Some e -> raise_s [%sexp (e : Expr.Typed.t)] + | Some var_name -> var_name in (Stmt.Fixed.Pattern.Assignment ((var_name, ut, l), e), m) | x -> (x, m) in let s, m = map_rec_state_stmt_loc f Map.Poly.empty s' in - subst_stmt m s + (* let _ = Map.Poly.iteri m ~f:(fun ~key ~data -> + * print_endline ( + * key ^ " -> " ^ data + * ) + * ) + * in *) + name_subst_stmt m s let subst_args_stmt args es = let m = Map.Poly.of_alist_exn (List.zip_exn args es) in diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index 79f09d89f4..491e36f183 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -175,7 +175,7 @@ let optimization_settings lvl : Optimize.optimization_settings = in match lvl with | 1 -> { max_safe with - function_inlining = false + function_inlining = true } | 2 -> { max_safe with From b4fbc4a13f599704bf425ac8dd36f5f016bd5ab6 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Sat, 18 Apr 2020 14:22:32 -0400 Subject: [PATCH 11/27] Fixed issue with expression prop - FnReadData has side effects --- src/analysis_and_optimization/Optimize.ml | 1 + src/stanc/stanc.ml | 6 +++--- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml index 0d5803fcef..c986963902 100644 --- a/src/analysis_and_optimization/Optimize.ml +++ b/src/analysis_and_optimization/Optimize.ml @@ -609,6 +609,7 @@ let rec can_side_effect_expr (e : Expr.Typed.t) = String.suffix f 3 = "_lp" || List.exists ~f:can_side_effect_expr es || (t = CompilerInternal && f = Internal_fun.to_string FnReadParam) + || (t = CompilerInternal && f = Internal_fun.to_string FnReadData) || (t = CompilerInternal && f = Internal_fun.to_string FnWriteParam) || (t = CompilerInternal && f = Internal_fun.to_string FnUnconstrain) | TernaryIf (e1, e2, e3) -> List.exists ~f:can_side_effect_expr [e1; e2; e3] diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index 491e36f183..9fd54b1f51 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -165,7 +165,7 @@ let optimization_settings lvl : Optimize.optimization_settings = ; list_collapsing= true ; block_fixing= true ; constant_propagation= true - ; expression_propagation= false + ; expression_propagation= true ; copy_propagation= true ; dead_code_elimination= true ; partial_evaluation= true @@ -175,11 +175,11 @@ let optimization_settings lvl : Optimize.optimization_settings = in match lvl with | 1 -> { max_safe with - function_inlining = true + expression_propagation = true } | 2 -> { max_safe with - function_inlining = true + expression_propagation = true } | _ -> raise (Failure ("Unsupported optimization level " ^ string_of_int lvl)) From 075cc70bfee0eca1daa846f6fa63d5890c7efb1c Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Sat, 18 Apr 2020 14:34:54 -0400 Subject: [PATCH 12/27] Expression prop - Added additional builtin function to side effects --- src/analysis_and_optimization/Optimize.ml | 5 +++++ src/stanc/stanc.ml | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml index c986963902..f14474954b 100644 --- a/src/analysis_and_optimization/Optimize.ml +++ b/src/analysis_and_optimization/Optimize.ml @@ -611,6 +611,11 @@ let rec can_side_effect_expr (e : Expr.Typed.t) = || (t = CompilerInternal && f = Internal_fun.to_string FnReadParam) || (t = CompilerInternal && f = Internal_fun.to_string FnReadData) || (t = CompilerInternal && f = Internal_fun.to_string FnWriteParam) + || (t = CompilerInternal && f = Internal_fun.to_string FnConstrain) + || (t = CompilerInternal && f = Internal_fun.to_string FnValidateSize) + || (t = CompilerInternal && f = Internal_fun.to_string FnValidateSize) + || (t = CompilerInternal && f = Internal_fun.to_string FnValidateSizeSimplex) + || (t = CompilerInternal && f = Internal_fun.to_string FnValidateSizeUnitVector) || (t = CompilerInternal && f = Internal_fun.to_string FnUnconstrain) | TernaryIf (e1, e2, e3) -> List.exists ~f:can_side_effect_expr [e1; e2; e3] | Indexed (e, is) -> diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index 9fd54b1f51..cd557ede4a 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -175,7 +175,7 @@ let optimization_settings lvl : Optimize.optimization_settings = in match lvl with | 1 -> { max_safe with - expression_propagation = true + expression_propagation = false } | 2 -> { max_safe with From 15116c0587e57eddd303310ba1c97a34d3e1a957 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Sun, 19 Apr 2020 22:40:01 -0400 Subject: [PATCH 13/27] Added to side effect list, fixed expr prop kills, fixed sym collisions, cleaned up output * Added to side effect list _rng functions effectively have side effects - this could more aptly be 'impure expressions' * Fixed expr prop kills Expression propagation was not properly killing off expressions when they were updated by assignments or had side effects * Fixed sym collisions Since the symbol generator is reset in between initial MIR production and optimization application, symbols could sometimes collide. Now optimizations produce prefixed symbols, one for each phase. * Cleaned up output Removed trailing elses, empty blocks produced by loop unrolling and lazy code motion --- src/analysis_and_optimization/Mir_utils.ml | 7 +- .../Monotone_framework.ml | 183 +++++++++++------- src/analysis_and_optimization/Optimize.ml | 140 ++++++++++---- src/common/Gensym.ml | 4 +- src/common/Gensym.mli | 2 +- src/stanc/stanc.ml | 3 - 6 files changed, 222 insertions(+), 117 deletions(-) diff --git a/src/analysis_and_optimization/Mir_utils.ml b/src/analysis_and_optimization/Mir_utils.ml index 27de740fa7..ce9a95f41c 100644 --- a/src/analysis_and_optimization/Mir_utils.ml +++ b/src/analysis_and_optimization/Mir_utils.ml @@ -201,7 +201,12 @@ let stmt_of_block b = let rec fn_subst_expr m e = match m e with - | Some e' -> e' + | Some e' -> + (* let print_expr (e:Expr.Typed.t) = *) + (* [%sexp (e.pattern : Expr.Typed.Meta.t Expr.Fixed.t Expr.Fixed.Pattern.t)] |> Sexp.to_string *) + (* in *) + (* let _ = print_endline ("Replaced expr: " ^ print_expr e ^ " -> " ^ print_expr e') in *) + e' | _ -> Expr.Fixed.{e with pattern= Pattern.map (fn_subst_expr m) e.pattern} let fn_subst_idx m = Index.map (fn_subst_expr m) diff --git a/src/analysis_and_optimization/Monotone_framework.ml b/src/analysis_and_optimization/Monotone_framework.ml index b75d17ae0a..845f720205 100644 --- a/src/analysis_and_optimization/Monotone_framework.ml +++ b/src/analysis_and_optimization/Monotone_framework.ml @@ -18,6 +18,65 @@ let print_mfp to_string (mfp : (int, 'a entry_exit) Map.Poly.t) (flowgraph_to_mi ^ print_stmt (Map.Poly.find_exn flowgraph_to_mir key) ^ ":\n " ^ print_set data.entry ^ " \t-> " ^ print_set data.exit)) +(** Calculate the free (non-bound) variables in an expression *) +let rec free_vars_expr (e : Expr.Typed.t) = + match e.pattern with + | Var x -> Set.Poly.singleton x + | Lit (_, _) -> Set.Poly.empty + | FunApp (_, f, l) -> + Set.Poly.union_list (Set.Poly.singleton f :: List.map ~f:free_vars_expr l) + | TernaryIf (e1, e2, e3) -> + Set.Poly.union_list (List.map ~f:free_vars_expr [e1; e2; e3]) + | Indexed (e, l) -> + Set.Poly.union_list (free_vars_expr e :: List.map ~f:free_vars_idx l) + | EAnd (e1, e2) | EOr (e1, e2) -> + Set.Poly.union_list (List.map ~f:free_vars_expr [e1; e2]) + +(** Calculate the free (non-bound) variables in an index*) +and free_vars_idx (i : Expr.Typed.t Index.t) = + match i with + | All -> Set.Poly.empty + | Single e | Upfrom e | MultiIndex e -> free_vars_expr e + | Between (e1, e2) -> Set.Poly.union (free_vars_expr e1) (free_vars_expr e2) + +(** Calculate the free (non-bound) variables in a statement *) +let rec free_vars_stmt + (s : (Expr.Typed.t, Stmt.Located.t) Stmt.Fixed.Pattern.t) = + match s with + | Assignment ((_, _, []), e) | Return (Some e) | TargetPE e -> + free_vars_expr e + | Assignment ((_, _, l), e) -> + Set.Poly.union_list (free_vars_expr e :: List.map ~f:free_vars_idx l) + | NRFunApp (_, f, l) -> + Set.Poly.union_list (Set.Poly.singleton f :: List.map ~f:free_vars_expr l) + | IfElse (e, b1, Some b2) -> + Set.Poly.union_list + [free_vars_expr e; free_vars_stmt b1.pattern; free_vars_stmt b2.pattern] + | IfElse (e, b, None) | While (e, b) -> + Set.Poly.union (free_vars_expr e) (free_vars_stmt b.pattern) + | For {lower= e1; upper= e2; body= b; _} -> + Set.Poly.union_list + [free_vars_expr e1; free_vars_expr e2; free_vars_stmt b.pattern] + | Block l | SList l -> + Set.Poly.union_list (List.map ~f:(fun s -> free_vars_stmt s.pattern) l) + | Decl _ | Break | Continue | Return None | Skip -> Set.Poly.empty + +(** A variation on free_vars_stmt, where we do not recursively count free + variables in sub statements *) +let top_free_vars_stmt + (flowgraph_to_mir : (int, Stmt.Located.Non_recursive.t) Map.Poly.t) + (s : (Expr.Typed.t, int) Stmt.Fixed.Pattern.t) = + match s with + | Assignment _ | Return _ | TargetPE _ | NRFunApp _ | Decl _ | Break + |Continue | Skip -> + free_vars_stmt + (statement_stmt_loc_of_statement_stmt_loc_num flowgraph_to_mir s) + | While (e, _) | IfElse (e, _, _) -> free_vars_expr e + | For {lower= e1; upper= e2; _} -> + Set.Poly.union_list [free_vars_expr e1; free_vars_expr e2] + | Block _ | SList _ -> Set.Poly.empty + + (** Compute the inverse flowgraph of a Stan statement (for reverse analyses) *) let inverse_flowgraph_of_stmt (stmt : Stmt.Located.t) : (module FLOWGRAPH with type labels = int) @@ -272,7 +331,10 @@ let expression_propagation_transfer (* TODO: we are currently only propagating constants for scalars. We could do the same for matrix and array expressions if we wanted. *) | Middle.Stmt.Fixed.Pattern.Assignment ((s, _, []), e) -> - if can_side_effect_expr e then m + if (can_side_effect_expr e + (* Don't prop expression if this assignment kills it *) + || Set.Poly.mem (free_vars_expr e) s) + then Map.remove m s else Map.set m ~key:s ~data:(subst_expr m e) | Decl {decl_id= s; _} | Assignment ((s, _, _ :: _), _) -> Map.remove m s @@ -305,16 +367,17 @@ let copy_propagation_transfer ( match mir_node with | Assignment ((s, _, []), {pattern= Var t; meta}) when not (Set.Poly.mem globals s) -> - Map.set m ~key:s ~data:Expr.Fixed.{pattern= Var t; meta} - | Decl {decl_id= s; _} | Assignment ((s, _, _ :: _), _) -> - Map.remove m s - | Assignment (_, _) - |TargetPE _ - |NRFunApp (_, _, _) - |Break | Continue | Return _ | Skip - |IfElse (_, _, _) - |While (_, _) - |For _ | Block _ | SList _ -> + (* let _ = print_endline ("Adding " ^ s ^ " -> " ^ t) in *) + Map.set m ~key:s ~data:Expr.Fixed.{pattern= Var t; meta} + | Decl {decl_id= s; _} | Assignment ((s, _, _ :: _), _) -> + Map.remove m s + | Assignment (_, _) + |TargetPE _ + |NRFunApp (_, _, _) + |Break | Continue | Return _ | Skip + |IfElse (_, _, _) + |While (_, _) + |For _ | Block _ | SList _ -> m ) end : TRANSFER_FUNCTION @@ -404,64 +467,6 @@ let initialized_vars_transfer : TRANSFER_FUNCTION with type labels = int and type properties = string Set.Poly.t ) -(** Calculate the free (non-bound) variables in an expression *) -let rec free_vars_expr (e : Expr.Typed.t) = - match e.pattern with - | Var x -> Set.Poly.singleton x - | Lit (_, _) -> Set.Poly.empty - | FunApp (_, f, l) -> - Set.Poly.union_list (Set.Poly.singleton f :: List.map ~f:free_vars_expr l) - | TernaryIf (e1, e2, e3) -> - Set.Poly.union_list (List.map ~f:free_vars_expr [e1; e2; e3]) - | Indexed (e, l) -> - Set.Poly.union_list (free_vars_expr e :: List.map ~f:free_vars_idx l) - | EAnd (e1, e2) | EOr (e1, e2) -> - Set.Poly.union_list (List.map ~f:free_vars_expr [e1; e2]) - -(** Calculate the free (non-bound) variables in an index*) -and free_vars_idx (i : Expr.Typed.t Index.t) = - match i with - | All -> Set.Poly.empty - | Single e | Upfrom e | MultiIndex e -> free_vars_expr e - | Between (e1, e2) -> Set.Poly.union (free_vars_expr e1) (free_vars_expr e2) - -(** Calculate the free (non-bound) variables in a statement *) -let rec free_vars_stmt - (s : (Expr.Typed.t, Stmt.Located.t) Stmt.Fixed.Pattern.t) = - match s with - | Assignment ((_, _, []), e) | Return (Some e) | TargetPE e -> - free_vars_expr e - | Assignment ((_, _, l), e) -> - Set.Poly.union_list (free_vars_expr e :: List.map ~f:free_vars_idx l) - | NRFunApp (_, f, l) -> - Set.Poly.union_list (Set.Poly.singleton f :: List.map ~f:free_vars_expr l) - | IfElse (e, b1, Some b2) -> - Set.Poly.union_list - [free_vars_expr e; free_vars_stmt b1.pattern; free_vars_stmt b2.pattern] - | IfElse (e, b, None) | While (e, b) -> - Set.Poly.union (free_vars_expr e) (free_vars_stmt b.pattern) - | For {lower= e1; upper= e2; body= b; _} -> - Set.Poly.union_list - [free_vars_expr e1; free_vars_expr e2; free_vars_stmt b.pattern] - | Block l | SList l -> - Set.Poly.union_list (List.map ~f:(fun s -> free_vars_stmt s.pattern) l) - | Decl _ | Break | Continue | Return None | Skip -> Set.Poly.empty - -(** A variation on free_vars_stmt, where we do not recursively count free - variables in sub statements *) -let top_free_vars_stmt - (flowgraph_to_mir : (int, Stmt.Located.Non_recursive.t) Map.Poly.t) - (s : (Expr.Typed.t, int) Stmt.Fixed.Pattern.t) = - match s with - | Assignment _ | Return _ | TargetPE _ | NRFunApp _ | Decl _ | Break - |Continue | Skip -> - free_vars_stmt - (statement_stmt_loc_of_statement_stmt_loc_num flowgraph_to_mir s) - | While (e, _) | IfElse (e, _, _) -> free_vars_expr e - | For {lower= e1; upper= e2; _} -> - Set.Poly.union_list [free_vars_expr e1; free_vars_expr e2] - | Block _ | SList _ -> Set.Poly.empty - (** The transfer function for a live variables analysis *) let live_variables_transfer (never_kill : string Set.Poly.t) @@ -1051,6 +1056,46 @@ let lazy_expressions_mfp (module Transfer4) in let used_not_latest_expressions_mfp = Mf4.mfp () in + let _ = + if false then + let print_set s to_string = + [%sexp (Set.Poly.map ~f:to_string s : string Set.Poly.t)] |> Sexp.to_string + in + let print_expr (e:Expr.Typed.t) = + [%sexp (e.pattern : Expr.Typed.Meta.t Expr.Fixed.t Expr.Fixed.Pattern.t)] |> Sexp.to_string + in + let print_expr_set s = + print_set s print_expr + in + let print_stmt s = + [%sexp (s : Stmt.Located.Non_recursive.t)] |> Sexp.to_string_hum + in + Map.iteri flowgraph_to_mir ~f:(fun ~key ~data -> + let used = Map.Poly.find_exn used_expr key in + let ant = Map.Poly.find_exn anticipated_expressions_mfp key in + let avl = Map.Poly.find_exn available_expressions_mfp key in + let earliest = Map.Poly.find_exn earliest_expr key in + let post = Map.Poly.find_exn postponable_expressions_mfp key in + let latest = Map.Poly.find_exn latest_expr key in + let used_not_latest = Map.Poly.find_exn used_not_latest_expressions_mfp key in + List.iter ~f:print_endline + [ string_of_int key ^ ":" + ; "\tStmt: " ^ print_stmt data + ; "\tUsed: " ^ print_expr_set used + ; "\tAnticipated.entry: " ^ print_expr_set ant.entry + ; "\tAnticipated.exit: " ^ print_expr_set ant.exit + ; "\tAvailable.entry: " ^ print_expr_set avl.entry + ; "\tAvailable.exit: " ^ print_expr_set avl.exit + ; "\tEarliest: " ^ print_expr_set earliest + ; "\tPostponable.entry: " ^ print_expr_set post.entry + ; "\tPostponable.exit: " ^ print_expr_set post.exit + ; "\tLatest: " ^ print_expr_set latest + ; "\tUsed_not_latest.entry: " ^ print_expr_set used_not_latest.entry + ; "\tUsed_not_latest.exit: " ^ print_expr_set used_not_latest.exit + ; "" + ] + ) + in (latest_expr, used_not_latest_expressions_mfp) (** Perform the analysis for ad-levels, using both the fwd and reverse pass *) diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml index f14474954b..fd0299bfb4 100644 --- a/src/analysis_and_optimization/Optimize.ml +++ b/src/analysis_and_optimization/Optimize.ml @@ -82,7 +82,7 @@ let replace_fresh_local_vars s' = | Stmt.Fixed.Pattern.Decl {decl_adtype; decl_type; decl_id} -> let new_name = match Map.Poly.find m decl_id with | Some existing -> existing - | None -> Gensym.generate () + | None -> Gensym.generate ~prefix:"inline_" () in ( Stmt.Fixed.Pattern.Decl {decl_adtype; decl_id= new_name; decl_type} , Map.Poly.set m ~key:decl_id ~data:new_name @@ -90,7 +90,7 @@ let replace_fresh_local_vars s' = | Stmt.Fixed.Pattern.For {loopvar; lower; upper; body} -> let new_name = match Map.Poly.find m loopvar with | Some existing -> existing - | None -> Gensym.generate () + | None -> Gensym.generate ~prefix:"inline_" () in ( Stmt.Fixed.Pattern.For { loopvar= new_name @@ -129,7 +129,7 @@ let subst_args_stmt args es = is called from an inner loop, there's a cascade of breaks all the way out of the dummy loop. *) let handle_early_returns opt_triple b = - let returned = Gensym.generate () in + let returned = Gensym.generate ~prefix:"inline_" () in let f = function | Stmt.Fixed.Pattern.Return opt_ret -> ( match (opt_triple, opt_ret) with @@ -185,7 +185,7 @@ let handle_early_returns opt_triple b = ; meta= Location_span.empty } ; Stmt.Fixed. { pattern= Stmt.Fixed.Pattern.For - { loopvar= Gensym.generate () + { loopvar= Gensym.generate ~prefix:"inline_" () ; lower= Expr.Fixed. { pattern= Lit (Int, "1") @@ -217,7 +217,7 @@ let rec inline_function_expression adt fim (Expr.Fixed.({pattern; _}) as e) = match Map.find fim s with | None -> (d_list, s_list, {e with pattern= FunApp (t, s, es)}) | Some (rt, args, b) -> - let x = Gensym.generate () in + let x = Gensym.generate ~prefix:"inline_" () in let handle = handle_early_returns (Some (rt, adt, x)) in let d_list2, s_list2, (e:Expr.Typed.t) = ( [ Stmt.Fixed.Pattern.Decl @@ -519,24 +519,27 @@ let unroll_loop_one_step_statement _ = else IfElse ( Expr.Fixed. - {lower with pattern= FunApp (StanLib, "Leq__", [lower; upper])} + {lower with pattern= FunApp (StanLib, "Geq__", [upper; lower])} , { pattern= - Block - [ subst_args_stmt [loopvar] [lower] - {pattern= body.pattern; meta= Location_span.empty} - ; { body with - pattern= - For - { loopvar - ; lower= - { lower with - pattern= - FunApp - ( StanLib - , "Plus__" - , [lower; Expr.Helpers.loop_bottom] ) } - ; upper - ; body } } ] + (let body_unrolled = + subst_args_stmt [loopvar] [lower] + {pattern= body.pattern; meta= Location_span.empty} + in + let (body' : Stmt.Located.t) = + { pattern= + Stmt.Fixed.Pattern.For { loopvar; upper; body; + lower= + { lower with + pattern= + FunApp + ( StanLib + , "Plus__" + , [lower; Expr.Helpers.loop_bottom] ) } } + ; meta= Location_span.empty } + in + match body_unrolled.pattern with + | Block stmts -> Block (stmts @ [body']) + | _ -> Stmt.Fixed.Pattern.Block [body_unrolled; body']) ; meta= Location_span.empty } , None ) | While (e, body) -> @@ -607,6 +610,7 @@ let rec can_side_effect_expr (e : Expr.Typed.t) = | Var _ | Lit (_, _) -> false | FunApp (t, f, es) -> String.suffix f 3 = "_lp" + || String.suffix f 4 = "_rng" || List.exists ~f:can_side_effect_expr es || (t = CompilerInternal && f = Internal_fun.to_string FnReadParam) || (t = CompilerInternal && f = Internal_fun.to_string FnReadData) @@ -785,9 +789,27 @@ let lazy_code_motion (mir : Program.Typed.t) = ~init:Expr.Typed.Map.empty ~f:(fun accum e -> match e.pattern with | Lit (_, _) -> accum + | Var _ -> accum | _ when can_side_effect_expr e -> accum - | _ -> Map.set accum ~key:e ~data:(Gensym.generate ()) ) + | _ -> Map.set accum ~key:e ~data:(Gensym.generate ~prefix:"lcm_" ()) ) in + (* let print_set s to_string = + * [%sexp (Set.Poly.map ~f:to_string s : string Set.Poly.t)] |> Sexp.to_string + * in *) + (* let print_expr (e:Expr.Typed.t) = + * [%sexp (e.pattern : Expr.Typed.Meta.t Expr.Fixed.t Expr.Fixed.Pattern.t)] |> Sexp.to_string + * in *) + (* let print_expr_set s = + * print_set s print_expr + * in *) + (* let _ = + * print_endline "Expression map:"; + * Map.iteri expression_map ~f:(fun ~key ~data -> + * print_endline ( + * "\t" ^ print_expr key ^ " -> " ^ data + * ) + * ) + * in *) (* TODO: it'd be more efficient to just not accumulate constants in the static analysis *) let declarations_list = Map.fold expression_map ~init:[] ~f:(fun ~key ~data accum -> @@ -807,15 +829,12 @@ let lazy_code_motion (mir : Program.Typed.t) = (Map.find_exn used_not_latest_expressions_mfp i).entry in let to_assign_in_s = - Set.filter - ~f:(fun x -> Map.mem expression_map x) - latest_and_used_after_i - in - let to_assign_in_s = Set.to_list to_assign_in_s in - let to_assign_in_s = - List.sort - ~compare:(fun e e' -> compare_int (expr_depth e) (expr_depth e')) - to_assign_in_s + latest_and_used_after_i + |> Set.filter ~f:(fun x -> + Map.mem expression_map x) + |> Set.to_list + |> List.sort ~compare:(fun e e' -> + compare_int (expr_depth e) (expr_depth e')) in (* TODO: is this sort doing anything or are they already stored in the right order by chance? It appears to not do anything. *) @@ -841,15 +860,26 @@ let lazy_code_motion (mir : Program.Typed.t) = in map_rec_stmt_loc f in + let expr_map = + Map.filter_keys + ~f:(fun key -> + Set.mem latest_and_used_after_i key + || Set.mem (Map.find_exn used_not_latest_expressions_mfp i).exit + key ) + (Map.mapi expression_map ~f:(fun ~key ~data -> + {key with pattern= Var data} )) + in + (* let _ = + * print_endline (string_of_int i ^ ": expression replacement map: {"); + * Map.iteri expr_map ~f:(fun ~key ~data -> + * print_endline ( + * "\t" ^ print_expr key ^ " -> " ^ print_expr data + * ) + * ); + * print_endline "}"; + * in *) let f = - expr_subst_stmt_except_initial_assign - (Map.filter_keys - ~f:(fun key -> - Set.mem latest_and_used_after_i key - || Set.mem (Map.find_exn used_not_latest_expressions_mfp i).exit - key ) - (Map.mapi expression_map ~f:(fun ~key ~data -> - {key with pattern= Var data} ))) + expr_subst_stmt_except_initial_assign expr_map in if List.length assignments_to_add_to_s = 0 then (f Stmt.Fixed.{pattern= stmt; meta= Location_span.empty}).pattern @@ -862,6 +892,7 @@ let lazy_code_motion (mir : Program.Typed.t) = let lazy_code_motion_stmt = map_rec_stmt_loc_num flowgraph_to_mir lazy_code_motion_base in + (* let _ = print_endline ("Done 1") in *) Stmt.Fixed. { pattern= SList @@ -869,7 +900,34 @@ let lazy_code_motion (mir : Program.Typed.t) = @ [lazy_code_motion_stmt (Map.find_exn flowgraph_to_mir 1)] ) ; meta= Location_span.empty } in - transform_program_blockwise mir (fun _ x -> transform (preprocess_flowgraph x)) + let cleanup = + let cleanup_base + (stmt : (Expr.Typed.t, Stmt.Located.t) Stmt.Fixed.Pattern.t) : (Expr.Typed.t, Stmt.Located.t) Stmt.Fixed.Pattern.t = + match stmt with + | Stmt.Fixed.( + Pattern.IfElse + ( e + , { pattern= Block [b1; {pattern= Skip; _}] ; _} + , Some { pattern= Block [b2; {pattern= Skip; _}] ; _} )) + -> IfElse (e, b1, Some b2) + | IfElse ( e + , { pattern= Block [b; {pattern= Skip; _}] ; _} + , Some {pattern= Skip; _} ) + -> IfElse (e, b, None) + | While (e , { pattern= Block [b; {pattern= Skip; _}] ; _}) + -> While (e, b) + | For + { loopvar ; lower ; upper ; body= + { pattern= Block [b; {pattern= Skip; _}] ; _} } + -> For {loopvar; lower; upper; body= b} + | _ -> stmt + in + map_rec_stmt_loc cleanup_base + in + (* let _ = print_endline ("Done 2") in *) + let res = transform_program_blockwise mir (fun _ x -> cleanup (transform (preprocess_flowgraph x))) in + (* let _ = print_endline ("Done 3") in *) + res let block_fixing mir = transform_program_blockwise mir diff --git a/src/common/Gensym.ml b/src/common/Gensym.ml index 81d9ddf250..5d6268762d 100644 --- a/src/common/Gensym.ml +++ b/src/common/Gensym.ml @@ -1,8 +1,8 @@ let _counter = ref 0 -let generate () = +let generate ?prefix:(prefix : string = "") () = _counter := !_counter + 1 ; - Format.sprintf "sym%d__" !_counter + Format.sprintf "%ssym%d__" prefix !_counter let enter () = let old_counter = !_counter in diff --git a/src/common/Gensym.mli b/src/common/Gensym.mli index 8aac141a48..20e58566ba 100644 --- a/src/common/Gensym.mli +++ b/src/common/Gensym.mli @@ -1,3 +1,3 @@ -val generate : unit -> string +val generate : ?prefix:string -> unit -> string val enter : unit -> string * (unit -> unit) val reset_danger_use_cautiously : unit -> unit diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index cd557ede4a..2526cf4565 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -141,9 +141,6 @@ let optimization_settings lvl : Optimize.optimization_settings = } in let _ : Optimize.optimization_settings = - (*Good for all except: - example-models/ARM/Ch.23/electric_1b.stan - *example-models/bugs_examples/vol1/kidney/kidney.stan *) { function_inlining= false ; static_loop_unrolling= true ; one_step_loop_unrolling= true From f6af6a71fe6e719a7e80ecdbc0a6f249ace52c67 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Mon, 20 Apr 2020 10:24:30 -0400 Subject: [PATCH 14/27] Fixed an issue where expression prop didn't kill stale expressions --- .../Monotone_framework.ml | 52 +- .../good/compiler-optimizations/cpp.expected | 823 ++++++++---------- test/unit/Optimize.ml | 779 +++++++---------- 3 files changed, 744 insertions(+), 910 deletions(-) diff --git a/src/analysis_and_optimization/Monotone_framework.ml b/src/analysis_and_optimization/Monotone_framework.ml index 845f720205..fb183a719e 100644 --- a/src/analysis_and_optimization/Monotone_framework.ml +++ b/src/analysis_and_optimization/Monotone_framework.ml @@ -217,6 +217,7 @@ let dual_partial_function_lattice (type dv cv) ( module struct type properties = (Dom.vals, Codom.vals) Map.Poly.t + (* intersection *) let lub s1 s2 = let f ~key ~data = Map.find s2 key = Some data in Map.filteri ~f s1 @@ -311,6 +312,24 @@ let constant_propagation_transfer with type labels = int and type properties = (string, Expr.Typed.t) Map.Poly.t option ) +let label_top_decls + (flowgraph_to_mir : (int, Middle.Stmt.Located.Non_recursive.t) Map.Poly.t) + label : string Set.Poly.t = + let stmt = Map.Poly.find_exn flowgraph_to_mir label in + match stmt.pattern with + | Decl {decl_id= s; _} -> + (* let _ = print_endline + * ( "stmt: " ^ ([%sexp (stmt : Middle.Stmt.Located.Non_recursive.t)] |> Sexp.to_string) + * ^ " decl " ^ s) + * in *) + Set.Poly.singleton s + | _ -> + (* let _ = print_endline + * ("stmt: " ^ ([%sexp (stmt : Middle.Stmt.Located.Non_recursive.t)] |> Sexp.to_string) + * ^ "nodecl" ) + * in *) + Set.Poly.empty + (** The transfer function for an expression propagation analysis, AKA forward substitution (see page 396 of Muchnick) *) let expression_propagation_transfer @@ -326,24 +345,45 @@ let expression_propagation_transfer | None -> None | Some m -> let mir_node = (Map.find_exn flowgraph_to_mir l).pattern in + let kill_var m v = + (* let ms = + * [%sexp (m : (string, Expr.Typed.t) Map.Poly.t)] |> Sexp.to_string + * in + * let _ = if v = "x" then print_endline ( + * "killing var " ^ v ^ " in map " ^ ms + * ) + * in *) + Map.filteri m ~f:(fun ~key ~data -> + not (key = v || Set.Poly.mem (free_vars_expr data) v)) + in Some ( match mir_node with (* TODO: we are currently only propagating constants for scalars. We could do the same for matrix and array expressions if we wanted. *) | Middle.Stmt.Fixed.Pattern.Assignment ((s, _, []), e) -> - if (can_side_effect_expr e - (* Don't prop expression if this assignment kills it *) - || Set.Poly.mem (free_vars_expr e) s) - then Map.remove m s - else Map.set m ~key:s ~data:(subst_expr m e) + let m' = kill_var m s in + if can_side_effect_expr e then + m' + else Map.set m ~key:s ~data:(subst_expr m e) | Decl {decl_id= s; _} | Assignment ((s, _, _ :: _), _) -> Map.remove m s + | Block b -> + let kills = + Set.Poly.union_list (List.map ~f:(label_top_decls flowgraph_to_mir) b) + in + (* let _ = + * let print_set s to_string = + * [%sexp (Set.Poly.map ~f:to_string s : string Set.Poly.t)] |> Sexp.to_string + * in + * print_endline ("Kill set: " ^ print_set kills ident) + * in *) + Set.Poly.fold kills ~init:m ~f:kill_var | TargetPE _ |NRFunApp (_, _, _) |Break | Continue | Return _ | Skip |IfElse (_, _, _) |While (_, _) - |For _ | Block _ | SList _ -> + |For _ | SList _ -> m ) end : TRANSFER_FUNCTION diff --git a/test/integration/good/compiler-optimizations/cpp.expected b/test/integration/good/compiler-optimizations/cpp.expected index bd9c551233..9a24d0eed9 100644 --- a/test/integration/good/compiler-optimizations/cpp.expected +++ b/test/integration/good/compiler-optimizations/cpp.expected @@ -300,6 +300,7 @@ class optimizations_model : public model_base_crtp { try { + pos__ = 1; } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); // Next line prevents compiler griping about no return @@ -377,129 +378,143 @@ class optimizations_model : public model_base_crtp { current_statement__ = 5; x_cov_in__ = in__.vector(3); + current_statement__ = 5; + if (jacobian__) { + current_statement__ = 5; + assign(x_cov, nil_index_list(), + stan::math::cov_matrix_constrain(x_cov_in__, 2, lp__), + "assigning variable x_cov"); + } else { + current_statement__ = 5; + assign(x_cov, nil_index_list(), + stan::math::cov_matrix_constrain(x_cov_in__, 2), + "assigning variable x_cov"); + } { double x; - int sym1__; + int inline_sym1__; - for (size_t sym2__ = 1; sym2__ <= 1; ++sym2__) { + for (size_t inline_sym2__ = 1; inline_sym2__ <= 1; ++inline_sym2__) { current_statement__ = 7; lp_accum__.add(3);} - int sym3__; - int sym4__; + int inline_sym3__; + int inline_sym4__; - for (size_t sym5__ = 1; sym5__ <= 1; ++sym5__) { + for (size_t inline_sym5__ = 1; inline_sym5__ <= 1; ++inline_sym5__) { { - sym3__ = 27; + inline_sym3__ = 27; break; } - sym3__ = 5; + inline_sym3__ = 5; break;} if (pstream__) { - stan_print(pstream__, sym3__); + stan_print(pstream__, inline_sym3__); stan_print(pstream__, "\n"); } - int sym6__; - int sym7__; + int inline_sym6__; + int inline_sym7__; - for (size_t sym8__ = 1; sym8__ <= 1; ++sym8__) { + for (size_t inline_sym8__ = 1; inline_sym8__ <= 1; ++inline_sym8__) { { - sym6__ = 28; + inline_sym6__ = 28; break; } - sym6__ = 6; + inline_sym6__ = 6; break;} - if (sym6__) { + if (inline_sym6__) { current_statement__ = 11; if (pstream__) { stan_print(pstream__, "a"); stan_print(pstream__, "\n"); } } - int sym9__; - int sym12__; - int sym10__; + int inline_sym9__; + int inline_sym12__; + int inline_sym10__; - for (size_t sym11__ = 1; sym11__ <= 1; ++sym11__) { + for (size_t inline_sym11__ = 1; inline_sym11__ <= 1; ++inline_sym11__) { { - sym9__ = 31; + inline_sym9__ = 31; break; } - sym9__ = 9; + inline_sym9__ = 9; break;} - int sym13__; + int inline_sym13__; - for (size_t sym14__ = 1; sym14__ <= 1; ++sym14__) { + for (size_t inline_sym14__ = 1; inline_sym14__ <= 1; ++inline_sym14__) { { - sym12__ = 29; + inline_sym12__ = 29; break; } - sym12__ = 7; + inline_sym12__ = 7; break;} - if (logical_lte(sym9__, sym12__)) { + if (logical_gte(inline_sym12__, inline_sym9__)) { { - { - int sym15__; - int sym16__; - - for (size_t sym17__ = 1; sym17__ <= 1; ++sym17__) { - { - sym15__ = 32; - break; - } - sym15__ = 10; - break;} - lp_accum__.add(sym15__); - int sym18__; - - for (size_t sym19__ = 1; sym19__ <= 1; ++sym19__) { - current_statement__ = 7; - lp_accum__.add(3);} - } - int sym13__; + int inline_sym15__; + int inline_sym16__; - for (size_t sym14__ = 1; sym14__ <= 1; ++sym14__) { + for (size_t inline_sym17__ = 1; inline_sym17__ <= 1; + ++inline_sym17__) { { - sym12__ = 29; + inline_sym15__ = 32; break; } - sym12__ = 7; + inline_sym15__ = 10; break;} + lp_accum__.add(inline_sym15__); + int inline_sym18__; + + for (size_t inline_sym19__ = 1; inline_sym19__ <= 1; + ++inline_sym19__) { + current_statement__ = 7; + lp_accum__.add(3);} } - for (size_t i = (sym9__ + 1); i <= sym12__; ++i) { + int inline_sym13__; + + for (size_t inline_sym14__ = 1; inline_sym14__ <= 1; + ++inline_sym14__) { + { + inline_sym12__ = 29; + break; + } + inline_sym12__ = 7; + break;} + for (size_t i = (inline_sym9__ + 1); i <= inline_sym12__; ++i) { { - int sym15__; - int sym16__; + int inline_sym15__; + int inline_sym16__; - for (size_t sym17__ = 1; sym17__ <= 1; ++sym17__) { + for (size_t inline_sym17__ = 1; inline_sym17__ <= 1; + ++inline_sym17__) { { - sym15__ = 32; + inline_sym15__ = 32; break; } - sym15__ = 10; + inline_sym15__ = 10; break;} - lp_accum__.add(sym15__); - int sym18__; + lp_accum__.add(inline_sym15__); + int inline_sym18__; - for (size_t sym19__ = 1; sym19__ <= 1; ++sym19__) { + for (size_t inline_sym19__ = 1; inline_sym19__ <= 1; + ++inline_sym19__) { current_statement__ = 7; lp_accum__.add(3);} } - int sym13__; + int inline_sym13__; - for (size_t sym14__ = 1; sym14__ <= 1; ++sym14__) { + for (size_t inline_sym14__ = 1; inline_sym14__ <= 1; + ++inline_sym14__) { { - sym12__ = 29; + inline_sym12__ = 29; break; } - sym12__ = 7; + inline_sym12__ = 7; break;}} } { - { - current_statement__ = 13; - lp_accum__.add(53); - } + current_statement__ = 13; + lp_accum__.add(53); { current_statement__ = 13; lp_accum__.add(53); @@ -520,85 +535,69 @@ class optimizations_model : public model_base_crtp { { { { + current_statement__ = 15; + lp_accum__.add(53); { + current_statement__ = 15; + lp_accum__.add(53); + } + } + { + current_statement__ = 16; + if (logical_gte((2 * 2), 2)) { + current_statement__ = 15; + lp_accum__.add(53); { - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } + current_statement__ = 15; + lp_accum__.add(53); } - } - { - current_statement__ = 16; - if (logical_lte(2, (2 * 2))) { - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - } - } - { - current_statement__ = 16; - if (logical_lte(3, (3 * 2))) { - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - } - } + { + current_statement__ = 15; + lp_accum__.add(53); + } + } + } + { + current_statement__ = 16; + if (logical_gte((3 * 2), 3)) { + current_statement__ = 15; + lp_accum__.add(53); + { + current_statement__ = 15; + lp_accum__.add(53); + } + { + current_statement__ = 15; + lp_accum__.add(53); + } + { + current_statement__ = 15; + lp_accum__.add(53); + } + } } } { current_statement__ = 17; - if (logical_lte(2, (2 + 2))) { - { - current_statement__ = 16; - if (logical_lte(2, (2 * 2))) { - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - } - } + if (logical_gte((2 + 2), 2)) { + current_statement__ = 16; + if (logical_gte((2 * 2), 2)) { + current_statement__ = 15; + lp_accum__.add(53); + { + current_statement__ = 15; + lp_accum__.add(53); + } + { + current_statement__ = 15; + lp_accum__.add(53); + } + } { current_statement__ = 16; - if (logical_lte(3, (3 * 2))) { - { - current_statement__ = 15; - lp_accum__.add(53); - } + if (logical_gte((3 * 2), 3)) { + current_statement__ = 15; + lp_accum__.add(53); { current_statement__ = 15; lp_accum__.add(53); @@ -615,11 +614,9 @@ class optimizations_model : public model_base_crtp { } { current_statement__ = 16; - if (logical_lte(4, (4 * 2))) { - { - current_statement__ = 15; - lp_accum__.add(53); - } + if (logical_gte((4 * 2), 4)) { + current_statement__ = 15; + lp_accum__.add(53); { current_statement__ = 15; lp_accum__.add(53); @@ -642,10 +639,29 @@ class optimizations_model : public model_base_crtp { } { current_statement__ = 17; - if (logical_lte(3, (3 + 2))) { + if (logical_gte((3 + 2), 3)) { + current_statement__ = 16; + if (logical_gte((3 * 2), 3)) { + current_statement__ = 15; + lp_accum__.add(53); + { + current_statement__ = 15; + lp_accum__.add(53); + } + { + current_statement__ = 15; + lp_accum__.add(53); + } + { + current_statement__ = 15; + lp_accum__.add(53); + } + } { current_statement__ = 16; - if (logical_lte(3, (3 * 2))) { + if (logical_gte((4 * 2), 4)) { + current_statement__ = 15; + lp_accum__.add(53); { current_statement__ = 15; lp_accum__.add(53); @@ -666,36 +682,9 @@ class optimizations_model : public model_base_crtp { } { current_statement__ = 16; - if (logical_lte(4, (4 * 2))) { - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - } - } - { - current_statement__ = 16; - if (logical_lte(5, (5 * 2))) { - { - current_statement__ = 15; - lp_accum__.add(53); - } + if (logical_gte((5 * 2), 5)) { + current_statement__ = 15; + lp_accum__.add(53); { current_statement__ = 15; lp_accum__.add(53); @@ -722,39 +711,33 @@ class optimizations_model : public model_base_crtp { } { current_statement__ = 17; - if (logical_lte(4, (4 + 2))) { - { - current_statement__ = 16; - if (logical_lte(4, (4 * 2))) { - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - } - } + if (logical_gte((4 + 2), 4)) { + current_statement__ = 16; + if (logical_gte((4 * 2), 4)) { + current_statement__ = 15; + lp_accum__.add(53); + { + current_statement__ = 15; + lp_accum__.add(53); + } + { + current_statement__ = 15; + lp_accum__.add(53); + } + { + current_statement__ = 15; + lp_accum__.add(53); + } + { + current_statement__ = 15; + lp_accum__.add(53); + } + } { current_statement__ = 16; - if (logical_lte(5, (5 * 2))) { - { - current_statement__ = 15; - lp_accum__.add(53); - } + if (logical_gte((5 * 2), 5)) { + current_statement__ = 15; + lp_accum__.add(53); { current_statement__ = 15; lp_accum__.add(53); @@ -779,11 +762,9 @@ class optimizations_model : public model_base_crtp { } { current_statement__ = 16; - if (logical_lte(6, (6 * 2))) { - { - current_statement__ = 15; - lp_accum__.add(53); - } + if (logical_gte((6 * 2), 6)) { + current_statement__ = 15; + lp_accum__.add(53); { current_statement__ = 15; lp_accum__.add(53); @@ -814,43 +795,37 @@ class optimizations_model : public model_base_crtp { } { current_statement__ = 17; - if (logical_lte(5, (5 + 2))) { - { - current_statement__ = 16; - if (logical_lte(5, (5 * 2))) { - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - } - } + if (logical_gte((5 + 2), 5)) { + current_statement__ = 16; + if (logical_gte((5 * 2), 5)) { + current_statement__ = 15; + lp_accum__.add(53); + { + current_statement__ = 15; + lp_accum__.add(53); + } + { + current_statement__ = 15; + lp_accum__.add(53); + } + { + current_statement__ = 15; + lp_accum__.add(53); + } + { + current_statement__ = 15; + lp_accum__.add(53); + } + { + current_statement__ = 15; + lp_accum__.add(53); + } + } { current_statement__ = 16; - if (logical_lte(6, (6 * 2))) { - { - current_statement__ = 15; - lp_accum__.add(53); - } + if (logical_gte((6 * 2), 6)) { + current_statement__ = 15; + lp_accum__.add(53); { current_statement__ = 15; lp_accum__.add(53); @@ -879,11 +854,9 @@ class optimizations_model : public model_base_crtp { } { current_statement__ = 16; - if (logical_lte(7, (7 * 2))) { - { - current_statement__ = 15; - lp_accum__.add(53); - } + if (logical_gte((7 * 2), 7)) { + current_statement__ = 15; + lp_accum__.add(53); { current_statement__ = 15; lp_accum__.add(53); @@ -996,10 +969,10 @@ class optimizations_model : public model_base_crtp { current_statement__ = 58; lp_accum__.add(2); } - int sym20__; - int sym21__; + int inline_sym20__; + int inline_sym21__; - for (size_t sym22__ = 1; sym22__ <= 1; ++sym22__) { + for (size_t inline_sym22__ = 1; inline_sym22__ <= 1; ++inline_sym22__) { current_statement__ = 60; lp_accum__.add(2); break;} @@ -1007,52 +980,53 @@ class optimizations_model : public model_base_crtp { while (576) { break; } - int sym23__; - int sym24__; + int inline_sym23__; + int inline_sym24__; - for (size_t sym25__ = 1; sym25__ <= 1; ++sym25__) { + for (size_t inline_sym25__ = 1; inline_sym25__ <= 1; ++inline_sym25__) { current_statement__ = 60; lp_accum__.add(2); - sym23__ = 24; + inline_sym23__ = 24; break;} - while (sym23__) { + while (inline_sym23__) { { break; } - int sym24__; + int inline_sym24__; - for (size_t sym25__ = 1; sym25__ <= 1; ++sym25__) { + for (size_t inline_sym25__ = 1; inline_sym25__ <= 1; + ++inline_sym25__) { current_statement__ = 60; lp_accum__.add(2); - sym23__ = 24; + inline_sym23__ = 24; break;} } current_statement__ = 66; for (size_t i = 31; i <= 225; ++i) { continue;} current_statement__ = 68; for (size_t i = 31; i <= 225; ++i) { break;} - int sym26__; - int sym27__; + int inline_sym26__; + int inline_sym27__; - for (size_t sym28__ = 1; sym28__ <= 1; ++sym28__) { + for (size_t inline_sym28__ = 1; inline_sym28__ <= 1; ++inline_sym28__) { current_statement__ = 60; lp_accum__.add(2); - sym26__ = 24; + inline_sym26__ = 24; break;} - for (size_t i = sym26__; i <= 225; ++i) { continue;} - int sym29__; - int sym30__; + for (size_t i = inline_sym26__; i <= 225; ++i) { continue;} + int inline_sym29__; + int inline_sym30__; - for (size_t sym31__ = 1; sym31__ <= 1; ++sym31__) { + for (size_t inline_sym31__ = 1; inline_sym31__ <= 1; ++inline_sym31__) { current_statement__ = 60; lp_accum__.add(2); - sym29__ = 24; + inline_sym29__ = 24; break;} - for (size_t i = sym29__; i <= 225; ++i) { break;} - int sym32__; - int sym33__; + for (size_t i = inline_sym29__; i <= 225; ++i) { break;} + int inline_sym32__; + int inline_sym33__; - for (size_t sym34__ = 1; sym34__ <= 1; ++sym34__) { + for (size_t inline_sym34__ = 1; inline_sym34__ <= 1; ++inline_sym34__) { current_statement__ = 60; lp_accum__.add(2); break;} @@ -1080,12 +1054,10 @@ class optimizations_model : public model_base_crtp { double temp2; { - { - current_statement__ = 81; - lp_accum__.add(4); - current_statement__ = 82; - lp_accum__.add(6); - } + current_statement__ = 81; + lp_accum__.add(4); + current_statement__ = 82; + lp_accum__.add(6); { current_statement__ = 81; lp_accum__.add(4); @@ -1180,88 +1152,74 @@ class optimizations_model : public model_base_crtp { vars__.push_back(phi); { { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(1), - cons_list(index_uni(0), nil_index_list())), "x_matrix")); - } - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(2), - cons_list(index_uni(0), nil_index_list())), "x_matrix")); - } - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(3), - cons_list(index_uni(0), nil_index_list())), "x_matrix")); - } + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(2), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); + } + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(3), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); } } { { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(1), - cons_list(index_uni(0), nil_index_list())), "x_matrix")); - } + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), "x_matrix")); { vars__.push_back( rvalue(x_matrix, cons_list(index_uni(2), - cons_list(index_uni(0), nil_index_list())), "x_matrix")); + cons_list(index_uni(2), nil_index_list())), "x_matrix")); } { vars__.push_back( rvalue(x_matrix, cons_list(index_uni(3), - cons_list(index_uni(0), nil_index_list())), "x_matrix")); + cons_list(index_uni(2), nil_index_list())), "x_matrix")); } } } } { + vars__.push_back(x_vector[(1 - 1)]); { - vars__.push_back(x_vector[(0 - 1)]); - } - { - vars__.push_back(x_vector[(0 - 1)]); + vars__.push_back(x_vector[(2 - 1)]); } } { { + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "x_cov")); { - { - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(1), - cons_list(index_uni(0), nil_index_list())), "x_cov")); - } - { - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(2), - cons_list(index_uni(0), nil_index_list())), "x_cov")); - } + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(2), + cons_list(index_uni(1), nil_index_list())), "x_cov")); } } { { - { - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(1), - cons_list(index_uni(0), nil_index_list())), "x_cov")); - } + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), "x_cov")); { vars__.push_back( rvalue(x_cov, cons_list(index_uni(2), - cons_list(index_uni(0), nil_index_list())), "x_cov")); + cons_list(index_uni(2), nil_index_list())), "x_cov")); } } } @@ -1290,6 +1248,7 @@ class optimizations_model : public model_base_crtp { try { int pos__; + pos__ = 1; double theta; current_statement__ = 1; @@ -1310,49 +1269,45 @@ class optimizations_model : public model_base_crtp { current_statement__ = 3; assign(x_matrix_flat__, nil_index_list(), context__.vals_r("x_matrix"), "assigning variable x_matrix_flat__"); + current_statement__ = 3; + pos__ = 1; { { + current_statement__ = 3; + assign(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + x_matrix_flat__[(1 - 1)], "assigning variable x_matrix"); + current_statement__ = 3; + pos__ = 2; { - { - current_statement__ = 3; - assign(x_matrix, - cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), - x_matrix_flat__[(1 - 1)], "assigning variable x_matrix"); - current_statement__ = 3; - pos__ = (1 + 1); - } - { - current_statement__ = 3; - assign(x_matrix, - cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), - x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); - current_statement__ = 3; - pos__ = (pos__ + 1); - } - { - current_statement__ = 3; - assign(x_matrix, - cons_list(index_uni(3), - cons_list(index_uni(1), nil_index_list())), - x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); - current_statement__ = 3; - pos__ = (pos__ + 1); - } + current_statement__ = 3; + assign(x_matrix, + cons_list(index_uni(2), + cons_list(index_uni(1), nil_index_list())), + x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); + current_statement__ = 3; + pos__ = (pos__ + 1); + } + { + current_statement__ = 3; + assign(x_matrix, + cons_list(index_uni(3), + cons_list(index_uni(1), nil_index_list())), + x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); + current_statement__ = 3; + pos__ = (pos__ + 1); } } { { - { - current_statement__ = 3; - assign(x_matrix, - cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), - x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); - current_statement__ = 3; - pos__ = (pos__ + 1); - } + current_statement__ = 3; + assign(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), + x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); + current_statement__ = 3; + pos__ = (pos__ + 1); { current_statement__ = 3; assign(x_matrix, @@ -1368,6 +1323,8 @@ class optimizations_model : public model_base_crtp { cons_list(index_uni(3), cons_list(index_uni(2), nil_index_list())), x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); + current_statement__ = 3; + pos__ = (pos__ + 1); } } } @@ -1383,18 +1340,20 @@ class optimizations_model : public model_base_crtp { current_statement__ = 4; assign(x_vector_flat__, nil_index_list(), context__.vals_r("x_vector"), "assigning variable x_vector_flat__"); + current_statement__ = 4; + pos__ = 1; { - { - current_statement__ = 4; - assign(x_vector, cons_list(index_uni(1), nil_index_list()), - x_vector_flat__[(1 - 1)], "assigning variable x_vector"); - current_statement__ = 4; - pos__ = (1 + 1); - } + current_statement__ = 4; + assign(x_vector, cons_list(index_uni(1), nil_index_list()), + x_vector_flat__[(1 - 1)], "assigning variable x_vector"); + current_statement__ = 4; + pos__ = 2; { current_statement__ = 4; assign(x_vector, cons_list(index_uni(2), nil_index_list()), x_vector_flat__[(pos__ - 1)], "assigning variable x_vector"); + current_statement__ = 4; + pos__ = (pos__ + 1); } } } @@ -1410,40 +1369,36 @@ class optimizations_model : public model_base_crtp { current_statement__ = 5; assign(x_cov_flat__, nil_index_list(), context__.vals_r("x_cov"), "assigning variable x_cov_flat__"); + current_statement__ = 5; + pos__ = 1; { { + current_statement__ = 5; + assign(x_cov, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + x_cov_flat__[(1 - 1)], "assigning variable x_cov"); + current_statement__ = 5; + pos__ = 2; { - { - current_statement__ = 5; - assign(x_cov, - cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), - x_cov_flat__[(1 - 1)], "assigning variable x_cov"); - current_statement__ = 5; - pos__ = (1 + 1); - } - { - current_statement__ = 5; - assign(x_cov, - cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), - x_cov_flat__[(pos__ - 1)], "assigning variable x_cov"); - current_statement__ = 5; - pos__ = (pos__ + 1); - } + current_statement__ = 5; + assign(x_cov, + cons_list(index_uni(2), + cons_list(index_uni(1), nil_index_list())), + x_cov_flat__[(pos__ - 1)], "assigning variable x_cov"); + current_statement__ = 5; + pos__ = (pos__ + 1); } } { { - { - current_statement__ = 5; - assign(x_cov, - cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), - x_cov_flat__[(pos__ - 1)], "assigning variable x_cov"); - current_statement__ = 5; - pos__ = (pos__ + 1); - } + current_statement__ = 5; + assign(x_cov, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), + x_cov_flat__[(pos__ - 1)], "assigning variable x_cov"); + current_statement__ = 5; + pos__ = (pos__ + 1); { current_statement__ = 5; assign(x_cov, @@ -1464,35 +1419,29 @@ class optimizations_model : public model_base_crtp { vars__.push_back(phi); { { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), "x_matrix")); - } - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), "x_matrix")); - } - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(3), - cons_list(index_uni(1), nil_index_list())), "x_matrix")); - } + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(2), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); + } + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(3), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); } } { { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), "x_matrix")); - } + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), "x_matrix")); { vars__.push_back( rvalue(x_matrix, @@ -1509,38 +1458,30 @@ class optimizations_model : public model_base_crtp { } } { - { - vars__.push_back(x_vector[(1 - 1)]); - } + vars__.push_back(x_vector[(1 - 1)]); { vars__.push_back(x_vector[(2 - 1)]); } } { { + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "x_cov")); { - { - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), "x_cov")); - } - { - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), "x_cov")); - } + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(2), + cons_list(index_uni(1), nil_index_list())), "x_cov")); } } { { - { - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), "x_cov")); - } + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), "x_cov")); { vars__.push_back( rvalue(x_cov, diff --git a/test/unit/Optimize.ml b/test/unit/Optimize.ml index 57e478aae0..d9bd39b741 100644 --- a/test/unit/Optimize.ml +++ b/test/unit/Optimize.ml @@ -153,21 +153,21 @@ let%expect_test "inline functions" = log_prob { { - data int sym1__; - sym1__ = 0; - for(sym2__ in 1:1) { + data int inline_sym1__; + inline_sym1__ = 0; + for(inline_sym2__ in 1:1) { FnPrint__(3); FnPrint__(FnMakeRowVec__(FnMakeRowVec__(3, 2), FnMakeRowVec__(4, 6))); } - real sym3__; - data int sym4__; - sym4__ = 0; - for(sym5__ in 1:1) { - sym4__ = 1; - sym3__ = (53 ^ 2); + real inline_sym3__; + data int inline_sym4__; + inline_sym4__ = 0; + for(inline_sym5__ in 1:1) { + inline_sym4__ = 1; + inline_sym3__ = (53 ^ 2); break; } - FnReject__(sym3__); + FnReject__(inline_sym3__); } } @@ -224,15 +224,15 @@ let%expect_test "inline functions 2" = } if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return; if(PNot__(emit_generated_quantities__)) return; - data int sym7__; - sym7__ = 0; - for(sym8__ in 1:1) { - data int sym5__; - sym5__ = 0; - for(sym6__ in 1:1) { + data int inline_sym7__; + inline_sym7__ = 0; + for(inline_sym8__ in 1:1) { + data int inline_sym5__; + inline_sym5__ = 0; + for(inline_sym6__ in 1:1) { } - if(sym7__) break; + if(inline_sym7__) break; } } |}] @@ -302,16 +302,16 @@ let%expect_test "list collapsing" = (((pattern (Block (((pattern - (Decl (decl_adtype DataOnly) (decl_id sym1__) + (Decl (decl_adtype DataOnly) (decl_id inline_sym1__) (decl_type (Sized SInt)))) (meta )) ((pattern - (Assignment (sym1__ UInt ()) + (Assignment (inline_sym1__ UInt ()) ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc ) (adlevel DataOnly)))))) (meta )) ((pattern - (For (loopvar sym2__) + (For (loopvar inline_sym2__) (lower ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc ) (adlevel DataOnly))))) @@ -358,20 +358,20 @@ let%expect_test "list collapsing" = (meta ))))) (meta )) ((pattern - (Decl (decl_adtype AutoDiffable) (decl_id sym3__) + (Decl (decl_adtype AutoDiffable) (decl_id inline_sym3__) (decl_type (Unsized UReal)))) (meta )) ((pattern - (Decl (decl_adtype DataOnly) (decl_id sym4__) + (Decl (decl_adtype DataOnly) (decl_id inline_sym4__) (decl_type (Sized SInt)))) (meta )) ((pattern - (Assignment (sym4__ UInt ()) + (Assignment (inline_sym4__ UInt ()) ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc ) (adlevel DataOnly)))))) (meta )) ((pattern - (For (loopvar sym5__) + (For (loopvar inline_sym5__) (lower ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc ) (adlevel DataOnly))))) @@ -382,12 +382,12 @@ let%expect_test "list collapsing" = ((pattern (Block (((pattern - (Assignment (sym4__ UInt ()) + (Assignment (inline_sym4__ UInt ()) ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc ) (adlevel DataOnly)))))) (meta )) ((pattern - (Assignment (sym3__ UReal ()) + (Assignment (inline_sym3__ UReal ()) ((pattern (FunApp StanLib Pow__ (((pattern (Lit Int 53)) @@ -403,7 +403,7 @@ let%expect_test "list collapsing" = (meta )) ((pattern (NRFunApp CompilerInternal FnReject__ - (((pattern (Var sym3__)) + (((pattern (Var inline_sym3__)) (meta ((type_ UReal) (loc ) (adlevel AutoDiffable))))))) (meta ))))) (meta )))) @@ -535,34 +535,34 @@ let%expect_test "inline function in for loop" = log_prob { { - int sym1__; - int sym4__; - data int sym2__; - sym2__ = 0; - for(sym3__ in 1:1) { + int inline_sym1__; + int inline_sym4__; + data int inline_sym2__; + inline_sym2__ = 0; + for(inline_sym3__ in 1:1) { FnPrint__("f"); - sym2__ = 1; - sym1__ = 42; + inline_sym2__ = 1; + inline_sym1__ = 42; break; } - data int sym5__; - sym5__ = 0; - for(sym6__ in 1:1) { + data int inline_sym5__; + inline_sym5__ = 0; + for(inline_sym6__ in 1:1) { FnPrint__("g"); - sym5__ = 1; - sym4__ = (3 + 24); + inline_sym5__ = 1; + inline_sym4__ = (3 + 24); break; } - for(i in sym1__:sym4__) { + for(i in inline_sym1__:inline_sym4__) { { FnPrint__("body"); } - data int sym5__; - sym5__ = 0; - for(sym6__ in 1:1) { + data int inline_sym5__; + inline_sym5__ = 0; + for(inline_sym6__ in 1:1) { FnPrint__("g"); - sym5__ = 1; - sym4__ = (3 + 24); + inline_sym5__ = 1; + inline_sym4__ = (3 + 24); break; } } @@ -624,54 +624,54 @@ let%expect_test "inline function in for loop 2" = log_prob { { - int sym7__; - int sym10__; - data int sym8__; - sym8__ = 0; - for(sym9__ in 1:1) { + int inline_sym7__; + int inline_sym10__; + data int inline_sym8__; + inline_sym8__ = 0; + for(inline_sym9__ in 1:1) { FnPrint__("f"); - sym8__ = 1; - sym7__ = 42; + inline_sym8__ = 1; + inline_sym7__ = 42; break; } - data int sym14__; - sym14__ = 0; - for(sym15__ in 1:1) { + data int inline_sym14__; + inline_sym14__ = 0; + for(inline_sym15__ in 1:1) { FnPrint__("g"); - int sym11__; - data int sym12__; - sym12__ = 0; - for(sym13__ in 1:1) { + int inline_sym11__; + data int inline_sym12__; + inline_sym12__ = 0; + for(inline_sym13__ in 1:1) { FnPrint__("f"); - sym12__ = 1; - sym11__ = 42; + inline_sym12__ = 1; + inline_sym11__ = 42; break; } - if(sym14__) break; - sym14__ = 1; - sym10__ = (sym11__ + 24); + if(inline_sym14__) break; + inline_sym14__ = 1; + inline_sym10__ = (inline_sym11__ + 24); break; } - for(i in sym7__:sym10__) { + for(i in inline_sym7__:inline_sym10__) { { FnPrint__("body"); } - data int sym14__; - sym14__ = 0; - for(sym15__ in 1:1) { + data int inline_sym14__; + inline_sym14__ = 0; + for(inline_sym15__ in 1:1) { FnPrint__("g"); - int sym11__; - data int sym12__; - sym12__ = 0; - for(sym13__ in 1:1) { + int inline_sym11__; + data int inline_sym12__; + inline_sym12__ = 0; + for(inline_sym13__ in 1:1) { FnPrint__("f"); - sym12__ = 1; - sym11__ = 42; + inline_sym12__ = 1; + inline_sym11__ = 42; break; } - if(sym14__) break; - sym14__ = 1; - sym10__ = (sym11__ + 24); + if(inline_sym14__) break; + inline_sym14__ = 1; + inline_sym10__ = (inline_sym11__ + 24); break; } } @@ -731,23 +731,23 @@ let%expect_test "inline function in while loop" = log_prob { { - int sym1__; - data int sym2__; - sym2__ = 0; - for(sym3__ in 1:1) { + int inline_sym1__; + data int inline_sym2__; + inline_sym2__ = 0; + for(inline_sym3__ in 1:1) { FnPrint__("g"); - sym2__ = 1; - sym1__ = (3 + 24); + inline_sym2__ = 1; + inline_sym1__ = (3 + 24); break; } - while(sym1__) { + while(inline_sym1__) { FnPrint__("body"); - data int sym2__; - sym2__ = 0; - for(sym3__ in 1:1) { + data int inline_sym2__; + inline_sym2__ = 0; + for(inline_sym3__ in 1:1) { FnPrint__("g"); - sym2__ = 1; - sym1__ = (3 + 24); + inline_sym2__ = 1; + inline_sym1__ = (3 + 24); break; } } @@ -807,16 +807,16 @@ let%expect_test "inline function in if then else" = log_prob { { - int sym1__; - data int sym2__; - sym2__ = 0; - for(sym3__ in 1:1) { + int inline_sym1__; + data int inline_sym2__; + inline_sym2__ = 0; + for(inline_sym3__ in 1:1) { FnPrint__("g"); - sym2__ = 1; - sym1__ = (3 + 24); + inline_sym2__ = 1; + inline_sym1__ = (3 + 24); break; } - if(sym1__) FnPrint__("body"); + if(inline_sym1__) FnPrint__("body"); } } @@ -885,37 +885,37 @@ let%expect_test "inline function in ternary if " = log_prob { { - int sym1__; - int sym4__; - int sym7__; - data int sym2__; - sym2__ = 0; - for(sym3__ in 1:1) { + int inline_sym1__; + int inline_sym4__; + int inline_sym7__; + data int inline_sym2__; + inline_sym2__ = 0; + for(inline_sym3__ in 1:1) { FnPrint__("f"); - sym2__ = 1; - sym1__ = 42; + inline_sym2__ = 1; + inline_sym1__ = 42; break; } - if(sym1__) { - data int sym5__; - sym5__ = 0; - for(sym6__ in 1:1) { + if(inline_sym1__) { + data int inline_sym5__; + inline_sym5__ = 0; + for(inline_sym6__ in 1:1) { FnPrint__("g"); - sym5__ = 1; - sym4__ = (3 + 24); + inline_sym5__ = 1; + inline_sym4__ = (3 + 24); break; } } else { - data int sym8__; - sym8__ = 0; - for(sym9__ in 1:1) { + data int inline_sym8__; + inline_sym8__ = 0; + for(inline_sym9__ in 1:1) { FnPrint__("h"); - sym8__ = 1; - sym7__ = (4 + 4); + inline_sym8__ = 1; + inline_sym7__ = (4 + 4); break; } } - FnPrint__(sym1__ ?sym4__: sym7__); + FnPrint__(inline_sym1__ ?inline_sym4__: inline_sym7__); } } @@ -968,21 +968,21 @@ let%expect_test "inline function multiple returns " = log_prob { { - int sym1__; - data int sym2__; - sym2__ = 0; - for(sym3__ in 1:1) { + int inline_sym1__; + data int inline_sym2__; + inline_sym2__ = 0; + for(inline_sym3__ in 1:1) { if(2) { FnPrint__("f"); - sym2__ = 1; - sym1__ = 42; + inline_sym2__ = 1; + inline_sym1__ = 42; break; } - sym2__ = 1; - sym1__ = 6; + inline_sym2__ = 1; + inline_sym1__ = 6; break; } - FnPrint__(sym1__); + FnPrint__(inline_sym1__); } } @@ -1031,25 +1031,25 @@ let%expect_test "inline function indices " = log_prob { { array[array[int, 2], 2] a; - int sym4__; - int sym1__; - data int sym5__; - sym5__ = 0; - for(sym6__ in 1:1) { + int inline_sym4__; + int inline_sym1__; + data int inline_sym5__; + inline_sym5__ = 0; + for(inline_sym6__ in 1:1) { FnPrint__(2); - sym5__ = 1; - sym4__ = 42; + inline_sym5__ = 1; + inline_sym4__ = 42; break; } - data int sym2__; - sym2__ = 0; - for(sym3__ in 1:1) { + data int inline_sym2__; + inline_sym2__ = 0; + for(inline_sym3__ in 1:1) { FnPrint__(1); - sym2__ = 1; - sym1__ = 42; + inline_sym2__ = 1; + inline_sym1__ = 42; break; } - FnPrint__(a[sym1__, sym4__]); + FnPrint__(a[inline_sym1__, inline_sym4__]); } } @@ -1097,27 +1097,27 @@ let%expect_test "inline function and " = log_prob { { - int sym1__; - int sym4__; - data int sym2__; - sym2__ = 0; - for(sym3__ in 1:1) { + int inline_sym1__; + int inline_sym4__; + data int inline_sym2__; + inline_sym2__ = 0; + for(inline_sym3__ in 1:1) { FnPrint__(1); - sym2__ = 1; - sym1__ = 42; + inline_sym2__ = 1; + inline_sym1__ = 42; break; } - if(sym1__) { - data int sym5__; - sym5__ = 0; - for(sym6__ in 1:1) { + if(inline_sym1__) { + data int inline_sym5__; + inline_sym5__ = 0; + for(inline_sym6__ in 1:1) { FnPrint__(2); - sym5__ = 1; - sym4__ = 42; + inline_sym5__ = 1; + inline_sym4__ = 42; break; } } - FnPrint__(sym1__ && sym4__); + FnPrint__(inline_sym1__ && inline_sym4__); } } @@ -1164,27 +1164,27 @@ let%expect_test "inline function or " = log_prob { { - int sym1__; - int sym4__; - data int sym2__; - sym2__ = 0; - for(sym3__ in 1:1) { + int inline_sym1__; + int inline_sym4__; + data int inline_sym2__; + inline_sym2__ = 0; + for(inline_sym3__ in 1:1) { FnPrint__(1); - sym2__ = 1; - sym1__ = 42; + inline_sym2__ = 1; + inline_sym1__ = 42; break; } - if(sym1__) ; else { - data int sym5__; - sym5__ = 0; - for(sym6__ in 1:1) { + if(inline_sym1__) ; else { + data int inline_sym5__; + inline_sym5__ = 0; + for(inline_sym6__ in 1:1) { FnPrint__(2); - sym5__ = 1; - sym4__ = 42; + inline_sym5__ = 1; + inline_sym4__ = 42; break; } } - FnPrint__(sym1__ || sym4__); + FnPrint__(inline_sym1__ || inline_sym4__); } } @@ -1831,6 +1831,7 @@ let%expect_test "dead code elimination" = {| prepare_data { data array[int, 2] i; + i[1] = 2; i = FnMakeArray__(3, 2); data array[int, 2] j; j = FnMakeArray__(3, 2); @@ -2483,26 +2484,20 @@ let%expect_test "lazy code motion" = [%expect {| log_prob { - data real[] sym3__; + data real[] lcm_sym3__; { - sym3__ = FnMakeArray__(3.0); - FnPrint__(sym3__); - FnPrint__(sym3__); - FnPrint__(sym3__); + lcm_sym3__ = FnMakeArray__(3.0); + FnPrint__(lcm_sym3__); + FnPrint__(lcm_sym3__); + FnPrint__(lcm_sym3__); } } generate_quantities { - data int sym2__; - data int sym1__; - if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) { - return; - ; - } else ; - if(PNot__(emit_generated_quantities__)) { - return; - ; - } else ; + data int lcm_sym2__; + data int lcm_sym1__; + if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return; + if(PNot__(emit_generated_quantities__)) return; } |}] let%expect_test "lazy code motion, 2" = @@ -2524,29 +2519,19 @@ let%expect_test "lazy code motion, 2" = [%expect {| log_prob { - data int sym4__; - data int sym3__; + data int lcm_sym3__; { for(i in 1:2) { - { - FnPrint__((3 + 4)); - } - ; + FnPrint__((3 + 4)); } } } generate_quantities { - data int sym2__; - data int sym1__; - if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) { - return; - ; - } else ; - if(PNot__(emit_generated_quantities__)) { - return; - ; - } else ; + data int lcm_sym2__; + data int lcm_sym1__; + if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return; + if(PNot__(emit_generated_quantities__)) return; } |}] let%expect_test "lazy code motion, 3" = @@ -2569,27 +2554,21 @@ let%expect_test "lazy code motion, 3" = [%expect {| log_prob { - data int sym4__; - data int sym3__; + data int lcm_sym4__; + data int lcm_sym3__; { FnPrint__(3); - sym3__ = (3 + 5); - FnPrint__(sym3__); - FnPrint__((sym3__ + 7)); + lcm_sym3__ = (3 + 5); + FnPrint__(lcm_sym3__); + FnPrint__((lcm_sym3__ + 7)); } } generate_quantities { - data int sym2__; - data int sym1__; - if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) { - return; - ; - } else ; - if(PNot__(emit_generated_quantities__)) { - return; - ; - } else ; + data int lcm_sym2__; + data int lcm_sym1__; + if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return; + if(PNot__(emit_generated_quantities__)) return; } |}] let%expect_test "lazy code motion, 4" = @@ -2625,7 +2604,7 @@ let%expect_test "lazy code motion, 4" = [%expect {| log_prob { - data int sym3__; + data int lcm_sym3__; { int b; int c; @@ -2638,31 +2617,25 @@ let%expect_test "lazy code motion, 4" = ; ; } - sym3__ = (b + c); + lcm_sym3__ = (b + c); ; } else { { - sym3__ = (b + c); - x = sym3__; + lcm_sym3__ = (b + c); + x = lcm_sym3__; ; } ; } - y = sym3__; + y = lcm_sym3__; } } generate_quantities { - data int sym2__; - data int sym1__; - if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) { - return; - ; - } else ; - if(PNot__(emit_generated_quantities__)) { - return; - ; - } else ; + data int lcm_sym2__; + data int lcm_sym1__; + if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return; + if(PNot__(emit_generated_quantities__)) return; } |}] let%expect_test "lazy code motion, 5" = @@ -2696,7 +2669,7 @@ let%expect_test "lazy code motion, 5" = [%expect {| log_prob { - data int sym3__; + data int lcm_sym3__; { int b; int c; @@ -2709,35 +2682,29 @@ let%expect_test "lazy code motion, 5" = ; ; } - sym3__ = (b + c); + lcm_sym3__ = (b + c); ; } else { { if(2) { - sym3__ = (b + c); - x = sym3__; + lcm_sym3__ = (b + c); + x = lcm_sym3__; ; - } else sym3__ = (b + c); + } else lcm_sym3__ = (b + c); ; ; } ; } - y = sym3__; + y = lcm_sym3__; } } generate_quantities { - data int sym2__; - data int sym1__; - if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) { - return; - ; - } else ; - if(PNot__(emit_generated_quantities__)) { - return; - ; - } else ; + data int lcm_sym2__; + data int lcm_sym1__; + if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return; + if(PNot__(emit_generated_quantities__)) return; } |}] let%expect_test "lazy code motion, 6" = @@ -2762,30 +2729,21 @@ let%expect_test "lazy code motion, 6" = [%expect {| log_prob { - data int sym4__; - data int sym3__; + data int lcm_sym4__; + data int lcm_sym3__; { int x; int y; - if(2) { - x = (1 + 2); - ; - } else ; + if(2) x = (1 + 2); y = (4 + 3); } } generate_quantities { - data int sym2__; - data int sym1__; - if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) { - return; - ; - } else ; - if(PNot__(emit_generated_quantities__)) { - return; - ; - } else ; + data int lcm_sym2__; + data int lcm_sym1__; + if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return; + if(PNot__(emit_generated_quantities__)) return; } |}] let%expect_test "lazy code motion, 7" = @@ -2828,8 +2786,7 @@ let%expect_test "lazy code motion, 7" = [%expect {| log_prob { - data int sym4__; - data int sym3__; + data int lcm_sym3__; { int a; int b; @@ -2838,62 +2795,32 @@ let%expect_test "lazy code motion, 7" = int y; int z; if(1) { - { - a = c; - x = (a + b); - } - ; - } else { - ; - ; - } + a = c; + x = (a + b); + } else ; if(2) { - { - if(3) { - { - sym4__ = (a + b); - ; - while(4) { - y = sym4__; - ; - } - ; - } - ; - } else { - { - ; - while(5) { - ; - ; - } - sym4__ = (a + b); - y = sym4__; - } - ; - } - z = sym4__; + if(3) { + lcm_sym3__ = (a + b); + ; + while(4) y = lcm_sym3__; + ; + } else { + ; + while(5) ; + lcm_sym3__ = (a + b); + y = lcm_sym3__; } - ; - } else { - ; - ; - } + z = lcm_sym3__; + } else ; ; } } generate_quantities { - data int sym2__; - data int sym1__; - if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) { - return; - ; - } else ; - if(PNot__(emit_generated_quantities__)) { - return; - ; - } else ; + data int lcm_sym2__; + data int lcm_sym1__; + if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return; + if(PNot__(emit_generated_quantities__)) return; } |}] let%expect_test "lazy code motion, 8, _lp functions not optimized" = @@ -2937,27 +2864,21 @@ let%expect_test "lazy code motion, 8, _lp functions not optimized" = log_prob { - data int sym3__; + data int lcm_sym3__; { FnPrint__(foo(foo_lp(1))); FnPrint__(foo(foo_lp(1))); - sym3__ = foo(foo(1)); - FnPrint__(sym3__); - FnPrint__(sym3__); + lcm_sym3__ = foo(foo(1)); + FnPrint__(lcm_sym3__); + FnPrint__(lcm_sym3__); } } generate_quantities { - data int sym2__; - data int sym1__; - if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) { - return; - ; - } else ; - if(PNot__(emit_generated_quantities__)) { - return; - ; - } else ; + data int lcm_sym2__; + data int lcm_sym1__; + if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return; + if(PNot__(emit_generated_quantities__)) return; } |}] let%expect_test "lazy code motion, 9" = @@ -2979,27 +2900,18 @@ let%expect_test "lazy code motion, 9" = [%expect {| log_prob { - data int sym3__; + data int lcm_sym3__; { int x; - while((x * 2)) { - FnPrint__("hello"); - ; - } + while((x * 2)) FnPrint__("hello"); } } generate_quantities { - data int sym2__; - data int sym1__; - if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) { - return; - ; - } else ; - if(PNot__(emit_generated_quantities__)) { - return; - ; - } else ; + data int lcm_sym2__; + data int lcm_sym1__; + if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return; + if(PNot__(emit_generated_quantities__)) return; } |}] let%expect_test "lazy code motion, 10" = @@ -3024,7 +2936,7 @@ let%expect_test "lazy code motion, 10" = [%expect {| log_prob { - data int sym3__; + data int lcm_sym3__; { int x; x = 3; @@ -3035,16 +2947,10 @@ let%expect_test "lazy code motion, 10" = } generate_quantities { - data int sym2__; - data int sym1__; - if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) { - return; - ; - } else ; - if(PNot__(emit_generated_quantities__)) { - return; - ; - } else ; + data int lcm_sym2__; + data int lcm_sym1__; + if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return; + if(PNot__(emit_generated_quantities__)) return; } |}] let%expect_test "lazy code motion, 11" = @@ -3072,7 +2978,7 @@ let%expect_test "lazy code motion, 11" = [%expect {| log_prob { - data int sym3__; + data int lcm_sym3__; { { int x; @@ -3086,16 +2992,10 @@ let%expect_test "lazy code motion, 11" = } generate_quantities { - data int sym2__; - data int sym1__; - if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) { - return; - ; - } else ; - if(PNot__(emit_generated_quantities__)) { - return; - ; - } else ; + data int lcm_sym2__; + data int lcm_sym1__; + if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return; + if(PNot__(emit_generated_quantities__)) return; } |}] let%expect_test "lazy code motion, 12" = @@ -3120,31 +3020,21 @@ let%expect_test "lazy code motion, 12" = [%expect {| log_prob { - data int sym4__; - data int sym3__; + data int lcm_sym3__; { int x; for(i in 1:6) { - { - FnPrint__((x + 42)); - x = 3; - } - ; + FnPrint__((x + 42)); + x = 3; } } } generate_quantities { - data int sym2__; - data int sym1__; - if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) { - return; - ; - } else ; - if(PNot__(emit_generated_quantities__)) { - return; - ; - } else ; + data int lcm_sym2__; + data int lcm_sym1__; + if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return; + if(PNot__(emit_generated_quantities__)) return; } |}] let%expect_test "lazy code motion, 13" = @@ -3177,62 +3067,44 @@ let%expect_test "lazy code motion, 13" = [%expect {| log_prob { - data int sym10__; - data int sym9__; - data int sym8__; - data int sym7__; - data int sym6__; - real sym5__; - real sym4__; - data int sym3__; + data int lcm_sym7__; + data int lcm_sym6__; + data int lcm_sym5__; + data int lcm_sym4__; + data int lcm_sym3__; { real temp; if((2 > 3)) { - sym9__ = (2 * 2); - temp = sym9__; + lcm_sym6__ = (2 * 2); + temp = lcm_sym6__; ; } else { FnPrint__("hello"); - sym9__ = (2 * 2); + lcm_sym6__ = (2 * 2); ; } - temp = sym9__; + temp = lcm_sym6__; real temp2; - if((2 <= 3)) { - { - { - sym10__ = (2 * 3); - temp2 = sym10__; - sym4__ = temp; - target += sym4__; - sym8__ = (2 + 1); - target += temp2; - } - for(i in sym8__:3) { - { - temp2 = sym10__; - target += sym4__; - target += temp2; - } - ; - } + if((3 >= 2)) { + lcm_sym7__ = (2 * 3); + temp2 = lcm_sym7__; + target += temp; + lcm_sym5__ = (2 + 1); + target += temp2; + for(i in lcm_sym5__:3) { + temp2 = lcm_sym7__; + target += temp; + target += temp2; } - ; - } else ; + } } } generate_quantities { - data int sym2__; - data int sym1__; - if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) { - return; - ; - } else ; - if(PNot__(emit_generated_quantities__)) { - return; - ; - } else ; + data int lcm_sym2__; + data int lcm_sym1__; + if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return; + if(PNot__(emit_generated_quantities__)) return; } |}] let%expect_test "cool example: expression propagation + partial evaluation + \ @@ -3264,41 +3136,30 @@ let%expect_test "cool example: expression propagation + partial evaluation + \ [%expect {| log_prob { - real sym7__; - real sym6__; - data int sym5__; - data int sym4__; - data int sym3__; + real lcm_sym6__; + real lcm_sym5__; + data int lcm_sym4__; + data int lcm_sym3__; { real x; int y; real theta; - if((1 <= 100000)) { - { - { - sym5__ = (1 + 1); - sym6__ = bernoulli_logit_lpmf(y, x); - target += sym6__; - } - for(i in sym5__:100000) { - { - target += sym6__; - } - } + if((100000 >= 1)) { + lcm_sym4__ = (1 + 1); + lcm_sym5__ = bernoulli_logit_lpmf(y, x); + target += lcm_sym5__; + for(i in lcm_sym4__:100000) { + target += lcm_sym5__; } - } else ; + } } } generate_quantities { - data int sym2__; - data int sym1__; - if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) { - return; - } else ; - if(PNot__(emit_generated_quantities__)) { - return; - } else ; + data int lcm_sym2__; + data int lcm_sym1__; + if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return; + if(PNot__(emit_generated_quantities__)) return; } |}] let%expect_test "block fixing" = @@ -3392,10 +3253,8 @@ let%expect_test "one-step loop unrolling" = {| prepare_data { data int x; - if((x <= 6)) { - { - FnPrint__("hello"); - } + if((6 >= x)) { + FnPrint__("hello"); for(i in (x + 1):6) { FnPrint__("hello"); } @@ -3404,22 +3263,16 @@ let%expect_test "one-step loop unrolling" = FnPrint__("goodbye"); while((1 < 2)) FnPrint__("goodbye"); } - if((1 <= 1)) { - { - if((2 <= 2)) { - { - FnPrint__("nested"); - } - for(j in (2 + 1):2) { - FnPrint__("nested"); - } + if((1 >= 1)) { + if((2 >= 2)) { + FnPrint__("nested"); + for(j in (2 + 1):2) { + FnPrint__("nested"); } } for(i in (1 + 1):1) { - if((2 <= 2)) { - { - FnPrint__("nested"); - } + if((2 >= 2)) { + FnPrint__("nested"); for(j in (2 + 1):2) { FnPrint__("nested"); } From 0a05520105f2a3e956a27b0e47e37f997886a695 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Mon, 20 Apr 2020 13:19:10 -0400 Subject: [PATCH 15/27] Reworked how the Block works in the flowgraph to fix multiple scope issues, now proping subexprs of impure exprs * Subexpressions of impure expressions can now be propagated by LCM e.g. in the expression normal_rng(sqrt(123)+2, 1), the whole expression cannot move because it's impure, but sqrt(123)+2 can be pulled out for reuse * Reworked block in the flowgraph Take expression propagation in this example: 1 transformed data { 2 real z = 1; 3 real y; 4 { 5 real x = normal_rng(123, 1); 6 z = x * 2; 7 y = normal_rng(z, 1); 8 } 9 y = normal_rng(z, 1); 10 } x * 2 is an expression that we want to propagate forward to lines 7 and 9. We can propagate safely to 7, but if we go to 9, we'll reference x, which is out of scope outside of the block. So we need to kill the expression x * 2 in the transfer function at the end of the block. This is actually not an issue for loops and if-else statements, since they generate a 'meet' in the flowgraph, expressions like x * 2 will be killed by the lattice LUB. This is likely not only an issue for expression propagation. It's probably also an issue for e.g. copy propagation and reaching definitions (I haven't tested this) My current solution is to change how blocks behave in the flowgraph. Blocks are now successors to their bodies, rather than predecessors. That means that the 'Block' node will be visited after the block body in the MFP. This lets transfer functions (like expr propagation) explicitly kill off variables that were declared in the block. This change shouldn't mess too much up, since optimizations tend not to rely on the order that they visit Blocks. The only exception seems to be lazy code motion. To support the original prefix-Block flowgraph, I added an optional flag to the flowgraph function that builds the flowgraph as before. --- .../Dataflow_utils.ml | 28 +- .../Dataflow_utils.mli | 10 +- .../Monotone_framework.ml | 13 +- src/analysis_and_optimization/Optimize.ml | 28 +- src/stanc/stanc.ml | 6 +- .../good/compiler-optimizations/cpp.expected | 567 ++++++------------ test/unit/Dataflow_utils.ml | 22 +- test/unit/Dependence_analysis.ml | 13 +- 8 files changed, 270 insertions(+), 417 deletions(-) diff --git a/src/analysis_and_optimization/Dataflow_utils.ml b/src/analysis_and_optimization/Dataflow_utils.ml index e591be1c14..bf7892b103 100644 --- a/src/analysis_and_optimization/Dataflow_utils.ml +++ b/src/analysis_and_optimization/Dataflow_utils.ml @@ -109,7 +109,7 @@ let is_ctrl_flow pattern = set of a statement. It's advantageous to build them together because they both rely on some of the same Break, Continue and Return bookkeeping. *) -let build_cf_graphs statement_map = +let build_cf_graphs ?blocks_after_body:(blocks_after_body=true) statement_map = let rec build_cf_graph_rec (cf_parent : label option) ((in_state, in_map) : cf_state * (label, cf_edges) Map.Poly.t) (label : label) : cf_state * (label, cf_edges) Map.Poly.t = @@ -119,16 +119,24 @@ let build_cf_graphs statement_map = let join (state1, map1) (state2, map2) = (join_cf_states state1 state2, union_maps_left map1 map2) in + (* This node is the parent of substatements, unless this is a Block, which + is visited after substatements *) + let substmt_preds = + match stmt with + | Block _ when blocks_after_body -> in_state.exits + | _ -> Set.Poly.singleton label + in (* The accumulated state after traversing substatements *) let substmt_state_unlooped, substmt_map = branching_fold_statement stmt ~join - ~init:({in_state with exits= Set.Poly.singleton label}, in_map) + ~init:({in_state with exits= substmt_preds}, in_map) ~f:(build_cf_graph_rec child_cf) in (* If the statement is a loop, we need to include the loop body exits as predecessors of the loop *) let substmt_state, predecessors = - let looped_state = + match stmt with + | For _ | While _ -> (* Loop statements are preceded by: 1. The statements that come before the loop 2. The natural exit points of the loop body @@ -155,9 +163,13 @@ let build_cf_graphs statement_map = ] in ({substmt_state_unlooped with exits= loop_exits}, loop_predecessors) - in - match stmt with - | For _ | While _ -> looped_state + | Block _ when blocks_after_body -> + (* Block statements are preceded by the natural exit points of the block + body *) + let block_predecessors = substmt_state_unlooped.exits in + (* Block exits are just the block node *) + let block_exits = Set.Poly.singleton label in + ({substmt_state_unlooped with exits= block_exits}, block_predecessors) | _ -> (substmt_state_unlooped, in_state.exits) in (* Some statements interact with the break/return/continue states @@ -223,6 +235,6 @@ let build_cf_graph statement_map = cf_graph (** See interface file *) -let build_predecessor_graph statement_map = - let exits, pred_graph, _ = build_cf_graphs statement_map in +let build_predecessor_graph ?blocks_after_body:(blocks_after_body=true) statement_map = + let exits, pred_graph, _ = build_cf_graphs ~blocks_after_body statement_map in (exits, pred_graph) diff --git a/src/analysis_and_optimization/Dataflow_utils.mli b/src/analysis_and_optimization/Dataflow_utils.mli index 566e436a36..11d5547b15 100644 --- a/src/analysis_and_optimization/Dataflow_utils.mli +++ b/src/analysis_and_optimization/Dataflow_utils.mli @@ -6,8 +6,9 @@ val union_maps_left : ('a, 'b) Map.Poly.t -> ('a, 'b) Map.Poly.t -> ('a, 'b) Map.Poly.t (** Union maps, preserving the left element in a collision *) -val build_cf_graphs : - (label, (Expr.Typed.t, label) Stmt.Fixed.Pattern.t * 'm) Map.Poly.t +val build_cf_graphs + : ?blocks_after_body:bool + -> (label, (Expr.Typed.t, label) Stmt.Fixed.Pattern.t * 'm) Map.Poly.t -> label Set.Poly.t * (label, label Set.Poly.t) Map.Poly.t * (label, label Set.Poly.t) Map.Poly.t @@ -33,8 +34,9 @@ val build_cf_graph : and return statements shouldn't affect other branches of execution. *) -val build_predecessor_graph : - (label, (Expr.Typed.t, label) Stmt.Fixed.Pattern.t * 'm) Map.Poly.t +val build_predecessor_graph + : ?blocks_after_body:bool + -> (label, (Expr.Typed.t, label) Stmt.Fixed.Pattern.t * 'm) Map.Poly.t -> label Set.Poly.t * (label, label Set.Poly.t) Map.Poly.t (** Building the predecessor graph requires a traversal with state that includes the diff --git a/src/analysis_and_optimization/Monotone_framework.ml b/src/analysis_and_optimization/Monotone_framework.ml index fb183a719e..213ee80d88 100644 --- a/src/analysis_and_optimization/Monotone_framework.ml +++ b/src/analysis_and_optimization/Monotone_framework.ml @@ -78,7 +78,9 @@ let top_free_vars_stmt (** Compute the inverse flowgraph of a Stan statement (for reverse analyses) *) -let inverse_flowgraph_of_stmt (stmt : Stmt.Located.t) : +let inverse_flowgraph_of_stmt + ?blocks_after_body:(blocks_after_body=true) + (stmt : Stmt.Located.t) : (module FLOWGRAPH with type labels = int) * (int, Stmt.Located.Non_recursive.t) Map.Poly.t = let flowgraph_to_mir = @@ -88,7 +90,7 @@ let inverse_flowgraph_of_stmt (stmt : Stmt.Located.t) : stmt in let initials, successors = - Dataflow_utils.build_predecessor_graph flowgraph_to_mir + Dataflow_utils.build_predecessor_graph ~blocks_after_body flowgraph_to_mir in ( ( module struct type labels = int @@ -130,8 +132,10 @@ let reverse (type l) (module F : FLOWGRAPH with type labels = l) = with type labels = l ) (** Compute the forward flowgraph of a Stan statement (for forward analyses) *) -let forward_flowgraph_of_stmt stmt = - let inv_flowgraph = inverse_flowgraph_of_stmt stmt in +let forward_flowgraph_of_stmt + ?blocks_after_body:(blocks_after_body=true) + stmt = + let inv_flowgraph = inverse_flowgraph_of_stmt ~blocks_after_body stmt in (reverse (fst inv_flowgraph), snd inv_flowgraph) (** The lattice of sets of some values, with the inclusion order, set union @@ -345,6 +349,7 @@ let expression_propagation_transfer | None -> None | Some m -> let mir_node = (Map.find_exn flowgraph_to_mir l).pattern in + (* TODO: Could probably use killed_expressions_stmt *) let kill_var m v = (* let ms = * [%sexp (m : (string, Expr.Typed.t) Map.Poly.t)] |> Sexp.to_string diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml index fd0299bfb4..ee73454091 100644 --- a/src/analysis_and_optimization/Optimize.ml +++ b/src/analysis_and_optimization/Optimize.ml @@ -777,7 +777,7 @@ let lazy_code_motion (mir : Program.Typed.t) = in let transform s = let rev_flowgraph, flowgraph_to_mir = - Monotone_framework.inverse_flowgraph_of_stmt s + Monotone_framework.inverse_flowgraph_of_stmt ~blocks_after_body:false s in let fwd_flowgraph = Monotone_framework.reverse rev_flowgraph in let latest_expr, used_not_latest_expressions_mfp = @@ -785,24 +785,22 @@ let lazy_code_motion (mir : Program.Typed.t) = flowgraph_to_mir in let expression_map = + let rec collect_expressions accum (e : Expr.Typed.t) = + match e.pattern with + | Lit (_, _) -> accum + | Var _ -> accum + | _ when can_side_effect_expr e -> + (* Immovable expressions might have movable subexpressions *) + Expr.Fixed.Pattern.fold collect_expressions accum e.pattern + | _ -> Map.set accum ~key:e ~data:(Gensym.generate ~prefix:"lcm_" ()) + in Set.fold (Monotone_framework.used_expressions_stmt s.pattern) - ~init:Expr.Typed.Map.empty ~f:(fun accum e -> - match e.pattern with - | Lit (_, _) -> accum - | Var _ -> accum - | _ when can_side_effect_expr e -> accum - | _ -> Map.set accum ~key:e ~data:(Gensym.generate ~prefix:"lcm_" ()) ) + ~init:Expr.Typed.Map.empty ~f:collect_expressions in - (* let print_set s to_string = - * [%sexp (Set.Poly.map ~f:to_string s : string Set.Poly.t)] |> Sexp.to_string - * in *) (* let print_expr (e:Expr.Typed.t) = * [%sexp (e.pattern : Expr.Typed.Meta.t Expr.Fixed.t Expr.Fixed.Pattern.t)] |> Sexp.to_string - * in *) - (* let print_expr_set s = - * print_set s print_expr - * in *) - (* let _ = + * in + * let _ = * print_endline "Expression map:"; * Map.iteri expression_map ~f:(fun ~key ~data -> * print_endline ( diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index 2526cf4565..3ec969879a 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -166,17 +166,19 @@ let optimization_settings lvl : Optimize.optimization_settings = ; copy_propagation= true ; dead_code_elimination= true ; partial_evaluation= true - ; lazy_code_motion= false + ; lazy_code_motion= true ; optimize_ad_levels= true } in match lvl with | 1 -> { max_safe with - expression_propagation = false + expression_propagation = true + ; lazy_code_motion= true } | 2 -> { max_safe with expression_propagation = true + ; lazy_code_motion= true } | _ -> raise (Failure ("Unsupported optimization level " ^ string_of_int lvl)) diff --git a/test/integration/good/compiler-optimizations/cpp.expected b/test/integration/good/compiler-optimizations/cpp.expected index 9a24d0eed9..7d992fbf92 100644 --- a/test/integration/good/compiler-optimizations/cpp.expected +++ b/test/integration/good/compiler-optimizations/cpp.expected @@ -133,7 +133,6 @@ static const std::vector locations_array__ = {" (found before start of p " (in 'optimizations.stan', line 65, column 4 to column 16)", " (in 'optimizations.stan', line 66, column 4 to column 16)", " (in 'optimizations.stan', line 68, column 6 to column 19)", - " (in 'optimizations.stan', line 67, column 4 to line 68, column 19)", " (in 'optimizations.stan', line 69, column 4 to column 16)", " (in 'optimizations.stan', line 70, column 4 to column 11)", " (in 'optimizations.stan', line 71, column 4 to column 10)", @@ -195,13 +194,16 @@ nrfun_lp(const T0__& x, const int& y, T_lp__& lp__, T_lp_accum__& lp_accum__, using local_scalar_t__ = typename boost::math::tools::promote_args::type; try { - current_statement__ = 91; - if (logical_gt(x, 342)) { + int lcm_sym35__; + { current_statement__ = 90; - return ; - } - current_statement__ = 7; - lp_accum__.add(y); + if (logical_gt(x, 342)) { + current_statement__ = 89; + return ; + } + current_statement__ = 7; + lp_accum__.add(y); + } } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); // Next line prevents compiler griping about no return @@ -228,13 +230,18 @@ rfun(const int& y, std::ostream* pstream__) { (void) propto__; try { - current_statement__ = 9; - if (logical_gt(y, 2)) { + int lcm_sym38__; + int lcm_sym37__; + int lcm_sym36__; + { + current_statement__ = 9; + if (logical_gt(y, 2)) { + current_statement__ = 91; + return (y + 24); + } current_statement__ = 92; - return (y + 24); - } - current_statement__ = 93; - return (y + 2); + return (y + 2); + } } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); // Next line prevents compiler griping about no return @@ -257,10 +264,12 @@ rfun_lp(T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__) { using local_scalar_t__ = double; try { - current_statement__ = 60; - lp_accum__.add(2); - current_statement__ = 94; - return 24; + { + current_statement__ = 59; + lp_accum__.add(2); + current_statement__ = 93; + return 24; + } } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); // Next line prevents compiler griping about no return @@ -342,6 +351,20 @@ class optimizations_model : public model_base_crtp { stan::io::reader in__(params_r__, params_i__); try { + double lcm_sym81__; + int lcm_sym80__; + int lcm_sym79__; + int lcm_sym78__; + int lcm_sym77__; + int lcm_sym76__; + int lcm_sym75__; + int lcm_sym74__; + int lcm_sym73__; + int lcm_sym72__; + int lcm_sym71__; + int lcm_sym70__; + int lcm_sym69__; + int lcm_sym68__; local_scalar_t__ theta; current_statement__ = 1; @@ -472,15 +495,18 @@ class optimizations_model : public model_base_crtp { } int inline_sym13__; + lcm_sym77__ = (inline_sym9__ + 1); for (size_t inline_sym14__ = 1; inline_sym14__ <= 1; ++inline_sym14__) { { inline_sym12__ = 29; + lcm_sym77__ = (inline_sym9__ + 1); break; } inline_sym12__ = 7; + lcm_sym77__ = (inline_sym9__ + 1); break;} - for (size_t i = (inline_sym9__ + 1); i <= inline_sym12__; ++i) { + for (size_t i = lcm_sym77__; i <= inline_sym12__; ++i) { { int inline_sym15__; int inline_sym16__; @@ -543,350 +569,128 @@ class optimizations_model : public model_base_crtp { } } { - current_statement__ = 16; - if (logical_gte((2 * 2), 2)) { - current_statement__ = 15; + lcm_sym80__ = (2 * 2); + if (logical_gte(lcm_sym80__, 2)) { + lcm_sym78__ = (2 + 1); lp_accum__.add(53); - { + for (size_t k = lcm_sym78__; k <= lcm_sym80__; ++k) { current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } + lp_accum__.add(53);} } } { - current_statement__ = 16; - if (logical_gte((3 * 2), 3)) { - current_statement__ = 15; + lcm_sym80__ = (3 * 2); + if (logical_gte(lcm_sym80__, 3)) { + lcm_sym78__ = (3 + 1); lp_accum__.add(53); - { - current_statement__ = 15; - lp_accum__.add(53); - } - { + for (size_t k = lcm_sym78__; k <= lcm_sym80__; ++k) { current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } + lp_accum__.add(53);} } } } { - current_statement__ = 17; - if (logical_gte((2 + 2), 2)) { - current_statement__ = 16; - if (logical_gte((2 * 2), 2)) { - current_statement__ = 15; - lp_accum__.add(53); - { - current_statement__ = 15; - lp_accum__.add(53); - } + lcm_sym76__ = (2 + 2); + if (logical_gte(lcm_sym76__, 2)) { + lcm_sym79__ = (2 * 2); + if (logical_gte(lcm_sym79__, 2)) { { - current_statement__ = 15; - lp_accum__.add(53); - } - } - { - current_statement__ = 16; - if (logical_gte((3 * 2), 3)) { - current_statement__ = 15; + lcm_sym75__ = (2 + 1); lp_accum__.add(53); - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { + for (size_t k = lcm_sym75__; k <= lcm_sym79__; ++k) { current_statement__ = 15; - lp_accum__.add(53); - } - } + lp_accum__.add(53);} + } + } else { + lcm_sym75__ = (2 + 1); } - { - current_statement__ = 16; - if (logical_gte((4 * 2), 4)) { - current_statement__ = 15; + for (size_t j = lcm_sym75__; j <= lcm_sym76__; ++j) { + lcm_sym80__ = (j * 2); + if (logical_gte(lcm_sym80__, j)) { + lcm_sym78__ = (j + 1); lp_accum__.add(53); - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { + for (size_t k = lcm_sym78__; k <= lcm_sym80__; ++k) { current_statement__ = 15; - lp_accum__.add(53); - } - } - } + lp_accum__.add(53);} + } } } } { - current_statement__ = 17; - if (logical_gte((3 + 2), 3)) { - current_statement__ = 16; - if (logical_gte((3 * 2), 3)) { - current_statement__ = 15; - lp_accum__.add(53); + lcm_sym76__ = (3 + 2); + if (logical_gte(lcm_sym76__, 3)) { + lcm_sym79__ = (3 * 2); + if (logical_gte(lcm_sym79__, 3)) { { - current_statement__ = 15; + lcm_sym75__ = (3 + 1); lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - } - { - current_statement__ = 16; - if (logical_gte((4 * 2), 4)) { - current_statement__ = 15; - lp_accum__.add(53); - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { + for (size_t k = lcm_sym75__; k <= lcm_sym79__; ++k) { current_statement__ = 15; - lp_accum__.add(53); - } - } + lp_accum__.add(53);} + } + } else { + lcm_sym75__ = (3 + 1); } - { - current_statement__ = 16; - if (logical_gte((5 * 2), 5)) { - current_statement__ = 15; + for (size_t j = lcm_sym75__; j <= lcm_sym76__; ++j) { + lcm_sym80__ = (j * 2); + if (logical_gte(lcm_sym80__, j)) { + lcm_sym78__ = (j + 1); lp_accum__.add(53); - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { + for (size_t k = lcm_sym78__; k <= lcm_sym80__; ++k) { current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - } - } + lp_accum__.add(53);} + } } } } { - current_statement__ = 17; - if (logical_gte((4 + 2), 4)) { - current_statement__ = 16; - if (logical_gte((4 * 2), 4)) { - current_statement__ = 15; - lp_accum__.add(53); - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } + lcm_sym76__ = (4 + 2); + if (logical_gte(lcm_sym76__, 4)) { + lcm_sym79__ = (4 * 2); + if (logical_gte(lcm_sym79__, 4)) { { - current_statement__ = 15; + lcm_sym75__ = (4 + 1); lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - } - { - current_statement__ = 16; - if (logical_gte((5 * 2), 5)) { - current_statement__ = 15; - lp_accum__.add(53); - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { + for (size_t k = lcm_sym75__; k <= lcm_sym79__; ++k) { current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - } + lp_accum__.add(53);} + } + } else { + lcm_sym75__ = (4 + 1); } - { - current_statement__ = 16; - if (logical_gte((6 * 2), 6)) { - current_statement__ = 15; + for (size_t j = lcm_sym75__; j <= lcm_sym76__; ++j) { + lcm_sym80__ = (j * 2); + if (logical_gte(lcm_sym80__, j)) { + lcm_sym78__ = (j + 1); lp_accum__.add(53); - { - current_statement__ = 15; - lp_accum__.add(53); - } - { + for (size_t k = lcm_sym78__; k <= lcm_sym80__; ++k) { current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - } - } + lp_accum__.add(53);} + } } } } { - current_statement__ = 17; - if (logical_gte((5 + 2), 5)) { - current_statement__ = 16; - if (logical_gte((5 * 2), 5)) { - current_statement__ = 15; - lp_accum__.add(53); - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } + lcm_sym76__ = (5 + 2); + if (logical_gte(lcm_sym76__, 5)) { + lcm_sym79__ = (5 * 2); + if (logical_gte(lcm_sym79__, 5)) { { - current_statement__ = 15; + lcm_sym75__ = (5 + 1); lp_accum__.add(53); - } - } - { - current_statement__ = 16; - if (logical_gte((6 * 2), 6)) { - current_statement__ = 15; - lp_accum__.add(53); - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { + for (size_t k = lcm_sym75__; k <= lcm_sym79__; ++k) { current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - } + lp_accum__.add(53);} + } + } else { + lcm_sym75__ = (5 + 1); } - { - current_statement__ = 16; - if (logical_gte((7 * 2), 7)) { - current_statement__ = 15; + for (size_t j = lcm_sym75__; j <= lcm_sym76__; ++j) { + lcm_sym80__ = (j * 2); + if (logical_gte(lcm_sym80__, j)) { + lcm_sym78__ = (j + 1); lp_accum__.add(53); - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { + for (size_t k = lcm_sym78__; k <= lcm_sym80__; ++k) { current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - { - current_statement__ = 15; - lp_accum__.add(53); - } - } - } + lp_accum__.add(53);} + } } } } } @@ -931,52 +735,52 @@ class optimizations_model : public model_base_crtp { x = 576; current_statement__ = 41; lp_accum__.add(576); - current_statement__ = 43; - if (logical_gt(theta, 46)) { + lcm_sym74__ = logical_gt(theta, 46); + if (lcm_sym74__) { current_statement__ = 42; x = 5880; } - current_statement__ = 44; + current_statement__ = 43; lp_accum__.add(x); double z; - current_statement__ = 46; + current_statement__ = 45; z = x; - current_statement__ = 47; + current_statement__ = 46; lp_accum__.add(x); - current_statement__ = 49; - if (logical_gt(theta, 46)) { - current_statement__ = 48; + current_statement__ = 48; + if (lcm_sym74__) { + current_statement__ = 47; z = x; } - current_statement__ = 50; + current_statement__ = 49; lp_accum__.add(z); - current_statement__ = 51; + current_statement__ = 50; lp_accum__.add(2); { double y; - current_statement__ = 53; + current_statement__ = 52; lp_accum__.add(24); } { double y; - current_statement__ = 56; + current_statement__ = 55; lp_accum__.add(245); } { - current_statement__ = 58; + current_statement__ = 57; lp_accum__.add(2); } int inline_sym20__; int inline_sym21__; for (size_t inline_sym22__ = 1; inline_sym22__ <= 1; ++inline_sym22__) { - current_statement__ = 60; + current_statement__ = 59; lp_accum__.add(2); break;} - current_statement__ = 63; + current_statement__ = 62; while (576) { break; } @@ -984,7 +788,7 @@ class optimizations_model : public model_base_crtp { int inline_sym24__; for (size_t inline_sym25__ = 1; inline_sym25__ <= 1; ++inline_sym25__) { - current_statement__ = 60; + current_statement__ = 59; lp_accum__.add(2); inline_sym23__ = 24; break;} @@ -996,20 +800,20 @@ class optimizations_model : public model_base_crtp { for (size_t inline_sym25__ = 1; inline_sym25__ <= 1; ++inline_sym25__) { - current_statement__ = 60; + current_statement__ = 59; lp_accum__.add(2); inline_sym23__ = 24; break;} } - current_statement__ = 66; + current_statement__ = 65; for (size_t i = 31; i <= 225; ++i) { continue;} - current_statement__ = 68; + current_statement__ = 67; for (size_t i = 31; i <= 225; ++i) { break;} int inline_sym26__; int inline_sym27__; for (size_t inline_sym28__ = 1; inline_sym28__ <= 1; ++inline_sym28__) { - current_statement__ = 60; + current_statement__ = 59; lp_accum__.add(2); inline_sym26__ = 24; break;} @@ -1018,7 +822,7 @@ class optimizations_model : public model_base_crtp { int inline_sym30__; for (size_t inline_sym31__ = 1; inline_sym31__ <= 1; ++inline_sym31__) { - current_statement__ = 60; + current_statement__ = 59; lp_accum__.add(2); inline_sym29__ = 24; break;} @@ -1027,25 +831,25 @@ class optimizations_model : public model_base_crtp { int inline_sym33__; for (size_t inline_sym34__ = 1; inline_sym34__ <= 1; ++inline_sym34__) { - current_statement__ = 60; + current_statement__ = 59; lp_accum__.add(2); break;} { - current_statement__ = 71; + current_statement__ = 70; lp_accum__.add(1); - current_statement__ = 72; + current_statement__ = 71; lp_accum__.add(24); } { { - current_statement__ = 74; + current_statement__ = 73; lp_accum__.add(1); } } double temp; { - current_statement__ = 78; + current_statement__ = 77; if (pstream__) { stan_print(pstream__, "hello"); stan_print(pstream__, "\n"); @@ -1054,30 +858,30 @@ class optimizations_model : public model_base_crtp { double temp2; { - current_statement__ = 81; + current_statement__ = 80; lp_accum__.add(4); - current_statement__ = 82; + current_statement__ = 81; lp_accum__.add(6); { - current_statement__ = 81; + current_statement__ = 80; lp_accum__.add(4); - current_statement__ = 82; + current_statement__ = 81; lp_accum__.add(6); } } double dataonlyvar; - current_statement__ = 84; + current_statement__ = 83; dataonlyvar = 3; - current_statement__ = 85; + current_statement__ = 84; lp_accum__.add(dataonlyvar); local_scalar_t__ paramvar; { - current_statement__ = 87; + current_statement__ = 86; paramvar = (theta * 34); } - current_statement__ = 89; + current_statement__ = 88; lp_accum__.add(paramvar); } } catch (const std::exception& e) { @@ -1108,6 +912,18 @@ class optimizations_model : public model_base_crtp { stan::math::accumulator lp_accum__; try { + double lcm_sym67__; + double lcm_sym66__; + double lcm_sym65__; + double lcm_sym64__; + double lcm_sym63__; + double lcm_sym62__; + double lcm_sym61__; + double lcm_sym60__; + double lcm_sym59__; + double lcm_sym58__; + int lcm_sym57__; + int lcm_sym56__; double theta; current_statement__ = 1; @@ -1246,6 +1062,23 @@ class optimizations_model : public model_base_crtp { vars__.reserve(num_params_r__); try { + double lcm_sym55__; + double lcm_sym54__; + double lcm_sym53__; + double lcm_sym52__; + double lcm_sym51__; + double lcm_sym50__; + double lcm_sym49__; + double lcm_sym48__; + double lcm_sym47__; + double lcm_sym46__; + double lcm_sym45__; + double lcm_sym44__; + double lcm_sym43__; + double lcm_sym42__; + double lcm_sym41__; + double lcm_sym40__; + int lcm_sym39__; int pos__; pos__ = 1; @@ -1537,22 +1370,22 @@ class optimizations_model : public model_base_crtp { param_names__.push_back(std::string() + "theta"); param_names__.push_back(std::string() + "phi"); - for (size_t sym35__ = 1; sym35__ <= 2; ++sym35__) { + for (size_t sym82__ = 1; sym82__ <= 2; ++sym82__) { { - for (size_t sym36__ = 1; sym36__ <= 3; ++sym36__) { + for (size_t sym83__ = 1; sym83__ <= 3; ++sym83__) { { - param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym36__) + '.' + std::to_string(sym35__)); + param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym83__) + '.' + std::to_string(sym82__)); }} }} - for (size_t sym35__ = 1; sym35__ <= 2; ++sym35__) { + for (size_t sym82__ = 1; sym82__ <= 2; ++sym82__) { { - param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym35__)); + param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym82__)); }} - for (size_t sym35__ = 1; sym35__ <= 2; ++sym35__) { + for (size_t sym82__ = 1; sym82__ <= 2; ++sym82__) { { - for (size_t sym36__ = 1; sym36__ <= 2; ++sym36__) { + for (size_t sym83__ = 1; sym83__ <= 2; ++sym83__) { { - param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym36__) + '.' + std::to_string(sym35__)); + param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym83__) + '.' + std::to_string(sym82__)); }} }} if (emit_transformed_parameters__) { @@ -1571,20 +1404,20 @@ class optimizations_model : public model_base_crtp { param_names__.push_back(std::string() + "theta"); param_names__.push_back(std::string() + "phi"); - for (size_t sym35__ = 1; sym35__ <= 2; ++sym35__) { + for (size_t sym82__ = 1; sym82__ <= 2; ++sym82__) { { - for (size_t sym36__ = 1; sym36__ <= 3; ++sym36__) { + for (size_t sym83__ = 1; sym83__ <= 3; ++sym83__) { { - param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym36__) + '.' + std::to_string(sym35__)); + param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym83__) + '.' + std::to_string(sym82__)); }} }} - for (size_t sym35__ = 1; sym35__ <= 2; ++sym35__) { + for (size_t sym82__ = 1; sym82__ <= 2; ++sym82__) { { - param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym35__)); + param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym82__)); }} - for (size_t sym35__ = 1; sym35__ <= 3; ++sym35__) { + for (size_t sym82__ = 1; sym82__ <= 3; ++sym82__) { { - param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym35__)); + param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym82__)); }} if (emit_transformed_parameters__) { diff --git a/test/unit/Dataflow_utils.ml b/test/unit/Dataflow_utils.ml index b8e598deaa..e124d18fd8 100644 --- a/test/unit/Dataflow_utils.ml +++ b/test/unit/Dataflow_utils.ml @@ -86,8 +86,8 @@ let%expect_test "Loop test" = ((filename string) (line_num 4) (col_num 10) (included_from ()))) (end_loc ((filename string) (line_num 4) (col_num 23) (included_from ()))))))) - (3) - ((1 ()) (2 (1)) (3 (2 5)) (4 (3)) (5 (4))) + (1) + ((1 (2)) (2 (3)) (3 (4)) (4 (5)) (5 (3))) |}] let%expect_test "Loop passthrough" = @@ -131,7 +131,7 @@ let%expect_test "Loop passthrough" = let exits, _ = build_predecessor_graph statement_map in print_s [%sexp (exits : label Set.Poly.t)] ; [%expect {| - (7 11 17 21) + (1) |}] let example1_program = @@ -290,11 +290,11 @@ let%expect_test "Predecessor graph example" = ((exits, preds) : label Set.Poly.t * (label, label Set.Poly.t) Map.Poly.t)] ; [%expect {| - ((7 9 13) - ((1 ()) (2 (1)) (3 (2)) (4 (3)) (5 (4)) (6 (5)) (7 (6)) (8 (5)) - (9 (8 16 19 22)) (10 (9)) (11 (10)) (12 (11)) (13 (12)) (14 (11 13)) - (15 (14)) (16 (15)) (17 (14 16)) (18 (17)) (19 (18)) (20 (17)) (21 (20)) - (22 (19 21)))) + ((1) + ((1 (2)) (2 (6 8)) (3 ()) (4 (3)) (5 (4)) (6 (7)) (7 (5)) (8 (9 13)) + (9 (5 10 16 19)) (10 (22)) (11 (9)) (12 (13)) (13 (11)) (14 (11 12)) + (15 (16)) (16 (14)) (17 (14 15)) (18 (19)) (19 (17)) (20 (21)) (21 (17)) + (22 (18 20)))) |}] let%expect_test "Controlflow graph example" = @@ -406,7 +406,7 @@ let%expect_test "Predecessor graph example 3" = ((exits, preds) : label Set.Poly.t * (label, label Set.Poly.t) Map.Poly.t)] ; [%expect {| - ((6) ((1 ()) (2 (1)) (3 (2)) (4 (3 5)) (5 (4)) (6 (4)))) + ((2) ((1 ()) (2 (3)) (3 (6)) (4 (1 5)) (5 (4)) (6 (4)))) |}] let example4_program = @@ -508,7 +508,7 @@ let%expect_test "Predecessor graph example 4" = ((exits, preds) : label Set.Poly.t * (label, label Set.Poly.t) Map.Poly.t)] ; [%expect {| - ((4) ((1 ()) (2 (1)) (3 (2)) (4 (3 6 7)) (5 (4)) (6 (5)) (7 (6)))) + ((2) ((1 ()) (2 (3)) (3 (4)) (4 (1 5 6)) (5 (7)) (6 (4)) (7 (6)))) |}] let example5_program = @@ -615,5 +615,5 @@ let%expect_test "Predecessor graph example 5" = ((exits, preds) : label Set.Poly.t * (label, label Set.Poly.t) Map.Poly.t)] ; [%expect {| - ((8) ((1 ()) (2 (1)) (3 (2)) (4 (3 7)) (5 (4)) (6 (5)) (7 (6)) (8 (4 6)))) + ((2) ((1 ()) (2 (3)) (3 (8)) (4 (1 5)) (5 (7)) (6 (4)) (7 (6)) (8 (4 6)))) |}] diff --git a/test/unit/Dependence_analysis.ml b/test/unit/Dependence_analysis.ml index a13438120e..8787ceac52 100644 --- a/test/unit/Dependence_analysis.ml +++ b/test/unit/Dependence_analysis.ml @@ -74,8 +74,8 @@ let%expect_test "Reaching defns example" = [%sexp (deps : (label, label Set.Poly.t * label Set.Poly.t) Map.Poly.t)] ; [%expect {| - ((1 (() ())) (2 (() ())) (3 (() ())) (4 (() ())) (5 (() ())) (6 (() ())) - (7 (() ())) (8 (() ())) (9 ((9) (9))) (10 ((9) (9))) (11 ((9) (9))) + ((1 (() ())) (2 ((9) (9))) (3 (() ())) (4 (() ())) (5 (() ())) (6 (() ())) + (7 (() ())) (8 ((9) (9))) (9 ((9) (9))) (10 ((9) (9))) (11 ((9) (9))) (12 ((9) (9))) (13 ((9) (9))) (14 ((9) (9))) (15 ((9) (9))) (16 ((9) (9))) (17 ((9) (9))) (18 ((9) (9))) (19 ((9) (9))) (20 ((9) (9))) (21 ((9) (9))) (22 ((9) (9)))) @@ -95,10 +95,11 @@ let%expect_test "Reaching defns example" = Map.Poly.t )] ; [%expect {| - ((1 (() ())) (2 (() ())) (3 (() (((VVar i) 3)))) - (4 ((((VVar i) 3)) (((VVar i) 4)))) (5 ((((VVar i) 4)) (((VVar i) 4)))) - (6 ((((VVar i) 4)) (((VVar i) 4)))) (7 ((((VVar i) 4)) (((VVar i) 4)))) - (8 ((((VVar i) 4)) (((VVar i) 4)))) + ((1 (() ())) (2 ((((VVar i) 4) ((VVar j) 9)) (((VVar i) 4) ((VVar j) 9)))) + (3 (() (((VVar i) 3)))) (4 ((((VVar i) 3)) (((VVar i) 4)))) + (5 ((((VVar i) 4)) (((VVar i) 4)))) (6 ((((VVar i) 4)) (((VVar i) 4)))) + (7 ((((VVar i) 4)) (((VVar i) 4)))) + (8 ((((VVar i) 4) ((VVar j) 9)) (((VVar i) 4) ((VVar j) 9)))) (9 ((((VVar i) 4) ((VVar j) 9)) (((VVar i) 4) ((VVar j) 9)))) (10 ((((VVar i) 4) ((VVar j) 9)) (((VVar i) 4) ((VVar j) 9)))) (11 ((((VVar i) 4) ((VVar j) 9)) (((VVar i) 4) ((VVar j) 9)))) From 31b6b9b67b7d186b69950d629414ce295eea0e47 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Mon, 20 Apr 2020 18:46:54 -0400 Subject: [PATCH 16/27] Fixed an issue where copy prop didn't kill assigned vars --- .../Monotone_framework.ml | 42 +++++-- src/analysis_and_optimization/Optimize.ml | 107 +++++++++++++----- src/stanc/stanc.ml | 9 +- 3 files changed, 119 insertions(+), 39 deletions(-) diff --git a/src/analysis_and_optimization/Monotone_framework.ml b/src/analysis_and_optimization/Monotone_framework.ml index 213ee80d88..4aa1f8fc4e 100644 --- a/src/analysis_and_optimization/Monotone_framework.ml +++ b/src/analysis_and_optimization/Monotone_framework.ml @@ -334,6 +334,8 @@ let label_top_decls * in *) Set.Poly.empty +let exprop_debug = false + (** The transfer function for an expression propagation analysis, AKA forward substitution (see page 396 of Muchnick) *) let expression_propagation_transfer @@ -371,7 +373,7 @@ let expression_propagation_transfer m' else Map.set m ~key:s ~data:(subst_expr m e) | Decl {decl_id= s; _} | Assignment ((s, _, _ :: _), _) -> - Map.remove m s + kill_var m s | Block b -> let kills = Set.Poly.union_list (List.map ~f:(label_top_decls flowgraph_to_mir) b) @@ -408,15 +410,35 @@ let copy_propagation_transfer | None -> None | Some m -> let mir_node = (Map.find_exn flowgraph_to_mir l).pattern in + let kill_var m v = + Map.filteri m ~f:(fun ~key ~(data : Expr.Typed.t) -> + not (key = v || data.pattern = Var v)) + in Some ( match mir_node with - | Assignment ((s, _, []), {pattern= Var t; meta}) - when not (Set.Poly.mem globals s) -> - (* let _ = print_endline ("Adding " ^ s ^ " -> " ^ t) in *) - Map.set m ~key:s ~data:Expr.Fixed.{pattern= Var t; meta} - | Decl {decl_id= s; _} | Assignment ((s, _, _ :: _), _) -> - Map.remove m s - | Assignment (_, _) + | Assignment ((s, _, []), {pattern= Var t; meta}) -> + let m' = kill_var m s in + (* let _ = print_endline ("killing " ^ s) in *) + if (Set.Poly.mem globals s) then + m' + else + let m'' = + Map.set m' ~key:s ~data:Expr.Fixed.{pattern= Var t; meta} + in + let _ = + if false then + print_endline ( + "Updating map on assignment " ^ s ^ ":=" ^ t ^ " :" + ^ ([%sexp (m : (string, Expr.Typed.t) Map.Poly.t)] |> Sexp.to_string_hum) + ^ " -> " + ^ ([%sexp (m' : (string, Expr.Typed.t) Map.Poly.t)] |> Sexp.to_string_hum) + ^ " -> " + ^ ([%sexp (m'' : (string, Expr.Typed.t) Map.Poly.t)] |> Sexp.to_string_hum) + ) + in + m'' + | Decl {decl_id= s; _} | Assignment ((s, _, _), _) -> + kill_var m s |TargetPE _ |NRFunApp (_, _, _) |Break | Continue | Return _ | Skip @@ -1040,6 +1062,8 @@ let live_variables_mfp (prog : Program.Typed.t) * let _ = print_endline "} ENDING BLOCK" in *) mfp +let lcm_debug = false + (** Instantiate all four instances of the monotone framework for lazy code motion, reusing code between them *) let lazy_expressions_mfp @@ -1102,7 +1126,7 @@ let lazy_expressions_mfp in let used_not_latest_expressions_mfp = Mf4.mfp () in let _ = - if false then + if lcm_debug then let print_set s to_string = [%sexp (Set.Poly.map ~f:to_string s : string Set.Poly.t)] |> Sexp.to_string in diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml index ee73454091..9fc470c373 100644 --- a/src/analysis_and_optimization/Optimize.ml +++ b/src/analysis_and_optimization/Optimize.ml @@ -592,6 +592,20 @@ let propagation (module Flowgraph) flowgraph_to_mir propagation_transfer in + let _ = + if false then ( + let print_stmt s = + [%sexp (s : Stmt.Located.Non_recursive.t)] |> Sexp.to_string_hum + in + Map.iteri values ~f:(fun ~key ~data -> + print_endline (string_of_int key ^ ":\n " + ^ print_stmt (Map.Poly.find_exn flowgraph_to_mir key) ^ ":\n " + ^ ([%sexp (data.entry : (string, Expr.Typed.t) Map.Poly.t option)] |> Sexp.to_string_hum) + ^ " \t-> " + ^ ([%sexp (data.exit : (string, Expr.Typed.t) Map.Poly.t option)] |> Sexp.to_string_hum)) + ) + ) + in let propagate_stmt = map_rec_stmt_loc_num flowgraph_to_mir (fun i -> subst_stmt_base @@ -632,13 +646,38 @@ and can_side_effect_idx (i : Expr.Typed.t Index.t) = | Single e | Upfrom e | MultiIndex e -> can_side_effect_expr e | Between (e1, e2) -> can_side_effect_expr e1 || can_side_effect_expr e2 -let expression_propagation = - propagation - (Monotone_framework.expression_propagation_transfer can_side_effect_expr) +let expression_propagation mir = + let res = + propagation + (Monotone_framework.expression_propagation_transfer can_side_effect_expr) + mir + in + let _ = if Monotone_framework.exprop_debug then ( + print_endline "Input program: {!"; + Program.Typed.pp Fmt.stdout mir; + print_endline "}!"; + print_endline "Output program: {!"; + Program.Typed.pp Fmt.stdout res; + print_endline "}!"; + ) + in + res -let copy_propagation prog = - let globals = Monotone_framework.globals prog in - propagation (Monotone_framework.copy_propagation_transfer globals) prog +let copy_propagation mir = + let globals = Monotone_framework.globals mir in + let res = + propagation (Monotone_framework.copy_propagation_transfer globals) mir + in + let _ = if false then ( + print_endline "Input program: {!"; + Program.Typed.pp Fmt.stdout mir; + print_endline "}!"; + print_endline "Output program: {!"; + Program.Typed.pp Fmt.stdout res; + print_endline "}!"; + ) + in + res let is_skip_break_continue s = match s with @@ -737,6 +776,13 @@ let lazy_code_motion (mir : Program.Typed.t) = (* TODO: clean up this code. It is not very pretty. *) (* TODO: make lazy code motion operate on transformed parameters and models blocks simultaneously *) + let _ = + if Monotone_framework.lcm_debug then ( + print_endline "Input program: {!"; + Program.Typed.pp Fmt.stdout mir; + print_endline "}!"; + ) + in let preprocess_flowgraph = let preprocess_flowgraph_base (stmt : (Expr.Typed.t, Stmt.Located.t) Stmt.Fixed.Pattern.t) = @@ -797,17 +843,18 @@ let lazy_code_motion (mir : Program.Typed.t) = Set.fold (Monotone_framework.used_expressions_stmt s.pattern) ~init:Expr.Typed.Map.empty ~f:collect_expressions in - (* let print_expr (e:Expr.Typed.t) = - * [%sexp (e.pattern : Expr.Typed.Meta.t Expr.Fixed.t Expr.Fixed.Pattern.t)] |> Sexp.to_string - * in - * let _ = - * print_endline "Expression map:"; - * Map.iteri expression_map ~f:(fun ~key ~data -> - * print_endline ( - * "\t" ^ print_expr key ^ " -> " ^ data - * ) - * ) - * in *) + let print_expr (e:Expr.Typed.t) = + [%sexp (e.pattern : Expr.Typed.Meta.t Expr.Fixed.t Expr.Fixed.Pattern.t)] |> Sexp.to_string + in + let _ = + if Monotone_framework.lcm_debug then + (print_endline "Expression map:"; + Map.iteri expression_map ~f:(fun ~key ~data -> + print_endline ( + "\t" ^ print_expr key ^ " -> " ^ data + ) + )) + in (* TODO: it'd be more efficient to just not accumulate constants in the static analysis *) let declarations_list = Map.fold expression_map ~init:[] ~f:(fun ~key ~data accum -> @@ -867,15 +914,16 @@ let lazy_code_motion (mir : Program.Typed.t) = (Map.mapi expression_map ~f:(fun ~key ~data -> {key with pattern= Var data} )) in - (* let _ = - * print_endline (string_of_int i ^ ": expression replacement map: {"); - * Map.iteri expr_map ~f:(fun ~key ~data -> - * print_endline ( - * "\t" ^ print_expr key ^ " -> " ^ print_expr data - * ) - * ); - * print_endline "}"; - * in *) + let _ = + if Monotone_framework.lcm_debug then + (print_endline (string_of_int i ^ ": expression replacement map: {"); + Map.iteri expr_map ~f:(fun ~key ~data -> + print_endline ( + "\t" ^ print_expr key ^ " -> " ^ print_expr data + ) + ); + print_endline "}";) + in let f = expr_subst_stmt_except_initial_assign expr_map in @@ -925,6 +973,13 @@ let lazy_code_motion (mir : Program.Typed.t) = (* let _ = print_endline ("Done 2") in *) let res = transform_program_blockwise mir (fun _ x -> cleanup (transform (preprocess_flowgraph x))) in (* let _ = print_endline ("Done 3") in *) + let _ = + if Monotone_framework.lcm_debug then ( + print_endline "Output program: {!"; + Program.Typed.pp Fmt.stdout res; + print_endline "}!"; + ) + in res let block_fixing mir = diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index 3ec969879a..87b0e4dafd 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -172,13 +172,14 @@ let optimization_settings lvl : Optimize.optimization_settings = in match lvl with | 1 -> { max_safe with - expression_propagation = true - ; lazy_code_motion= true + lazy_code_motion = true + ; expression_propagation = true + ; copy_propagation = false } | 2 -> { max_safe with - expression_propagation = true - ; lazy_code_motion= true + lazy_code_motion = true + ; expression_propagation = true } | _ -> raise (Failure ("Unsupported optimization level " ^ string_of_int lvl)) From 9056c42307888049c8ec667471a02193712d72f6 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Mon, 20 Apr 2020 19:03:56 -0400 Subject: [PATCH 17/27] Copy prop now kills local decls when exiting block - possibly unnecessary --- src/analysis_and_optimization/Monotone_framework.ml | 7 ++++++- src/stanc/stanc.ml | 8 +++----- 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/src/analysis_and_optimization/Monotone_framework.ml b/src/analysis_and_optimization/Monotone_framework.ml index 4aa1f8fc4e..2791c0eedb 100644 --- a/src/analysis_and_optimization/Monotone_framework.ml +++ b/src/analysis_and_optimization/Monotone_framework.ml @@ -439,12 +439,17 @@ let copy_propagation_transfer m'' | Decl {decl_id= s; _} | Assignment ((s, _, _), _) -> kill_var m s + | Block b -> + let kills = + Set.Poly.union_list (List.map ~f:(label_top_decls flowgraph_to_mir) b) + in + Set.Poly.fold kills ~init:m ~f:kill_var |TargetPE _ |NRFunApp (_, _, _) |Break | Continue | Return _ | Skip |IfElse (_, _, _) |While (_, _) - |For _ | Block _ | SList _ -> + |For _ | SList _ -> m ) end : TRANSFER_FUNCTION diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index 87b0e4dafd..c562fc3293 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -125,7 +125,7 @@ let options = (* Whether or not to run each optimization. Currently it's all or nothing depending on the --O flag.*) let optimization_settings lvl : Optimize.optimization_settings = - let _ : Optimize.optimization_settings = + let empty : Optimize.optimization_settings = { function_inlining= false ; static_loop_unrolling= false ; one_step_loop_unrolling= false @@ -171,10 +171,8 @@ let optimization_settings lvl : Optimize.optimization_settings = } in match lvl with | 1 -> - { max_safe with - lazy_code_motion = true - ; expression_propagation = true - ; copy_propagation = false + { empty with + copy_propagation = true } | 2 -> { max_safe with From 84a54ebdae4e6b83fd297fcd571a342d3b7a779f Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Mon, 20 Apr 2020 20:01:21 -0400 Subject: [PATCH 18/27] dune promote --- .../good/compiler-optimizations/cpp.expected | 695 +++--------------- 1 file changed, 90 insertions(+), 605 deletions(-) diff --git a/test/integration/good/compiler-optimizations/cpp.expected b/test/integration/good/compiler-optimizations/cpp.expected index ca7b99356a..2f95bb3d8a 100644 --- a/test/integration/good/compiler-optimizations/cpp.expected +++ b/test/integration/good/compiler-optimizations/cpp.expected @@ -351,10 +351,7 @@ class optimizations_model : public model_base_crtp { stan::io::reader in__(params_r__, params_i__); try { -<<<<<<< HEAD - double lcm_sym81__; - int lcm_sym80__; - int lcm_sym79__; + double lcm_sym79__; int lcm_sym78__; int lcm_sym77__; int lcm_sym76__; @@ -366,42 +363,8 @@ class optimizations_model : public model_base_crtp { int lcm_sym70__; int lcm_sym69__; int lcm_sym68__; -======= - local_scalar_t__ sym110__; - int sym109__; - int sym108__; - int sym107__; - int sym106__; - int sym105__; - int sym104__; - int sym103__; - int sym102__; - int sym101__; - int sym100__; - int sym99__; - int sym98__; - int sym97__; - int sym96__; - int sym95__; - int sym94__; - int sym93__; - int sym92__; - int sym91__; - int sym90__; - int sym89__; - int sym88__; - int sym87__; - int sym86__; - int sym85__; - int sym84__; - int sym83__; - int sym82__; - int sym81__; - int sym80__; - int sym79__; - int sym78__; - int sym77__; ->>>>>>> master + int lcm_sym67__; + int lcm_sym66__; local_scalar_t__ theta; current_statement__ = 1; @@ -532,20 +495,19 @@ class optimizations_model : public model_base_crtp { } int inline_sym13__; - lcm_sym77__ = (inline_sym9__ + 1); + lcm_sym75__ = (inline_sym9__ + 1); for (size_t inline_sym14__ = 1; inline_sym14__ <= 1; ++inline_sym14__) { { inline_sym12__ = 29; - lcm_sym77__ = (inline_sym9__ + 1); + lcm_sym75__ = (inline_sym9__ + 1); break; } inline_sym12__ = 7; - lcm_sym77__ = (inline_sym9__ + 1); + lcm_sym75__ = (inline_sym9__ + 1); break;} - for (size_t i = lcm_sym77__; i <= inline_sym12__; ++i) { + for (size_t i = lcm_sym75__; i <= inline_sym12__; ++i) { { -<<<<<<< HEAD int inline_sym15__; int inline_sym16__; @@ -553,41 +515,6 @@ class optimizations_model : public model_base_crtp { ++inline_sym17__) { { inline_sym15__ = 32; -======= - { - int sym16__; - for (size_t sym15__ = 1; sym15__ <= 1; ++sym15__) { - { - { - { - sym16__ = 32; - break; - } - } - sym16__ = 10; - break; - }} - lp_accum__.add(sym16__); - current_statement__ = 14; - for (size_t sym17__ = 1; sym17__ <= 1; ++sym17__) { - { - current_statement__ = 7; - lp_accum__.add(3); - }} - } - sym107__ = (sym10__ + 1); - for (size_t sym12__ = 1; sym12__ <= 1; ++sym12__) { - { - { - { - sym13__ = 29; - sym107__ = (sym10__ + 1); - break; - } - } - sym13__ = 7; - sym107__ = (sym10__ + 1); ->>>>>>> master break; } inline_sym15__ = 10; @@ -600,14 +527,10 @@ class optimizations_model : public model_base_crtp { current_statement__ = 7; lp_accum__.add(3);} } -<<<<<<< HEAD int inline_sym13__; for (size_t inline_sym14__ = 1; inline_sym14__ <= 1; ++inline_sym14__) { -======= - for (size_t i = sym107__; i <= sym13__; ++i) { ->>>>>>> master { inline_sym12__ = 29; break; @@ -646,372 +569,125 @@ class optimizations_model : public model_base_crtp { } } { - lcm_sym80__ = (2 * 2); - if (logical_gte(lcm_sym80__, 2)) { - lcm_sym78__ = (2 + 1); + lcm_sym78__ = (2 * 2); + if (logical_gte(lcm_sym78__, 2)) { + lcm_sym76__ = (2 + 1); lp_accum__.add(53); - for (size_t k = lcm_sym78__; k <= lcm_sym80__; ++k) { + for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { current_statement__ = 15; lp_accum__.add(53);} } } { - lcm_sym80__ = (3 * 2); - if (logical_gte(lcm_sym80__, 3)) { - lcm_sym78__ = (3 + 1); + lcm_sym78__ = (3 * 2); + if (logical_gte(lcm_sym78__, 3)) { + lcm_sym76__ = (3 + 1); lp_accum__.add(53); - for (size_t k = lcm_sym78__; k <= lcm_sym80__; ++k) { + for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { current_statement__ = 15; lp_accum__.add(53);} } } } { - lcm_sym76__ = (2 + 2); - if (logical_gte(lcm_sym76__, 2)) { - lcm_sym79__ = (2 * 2); - if (logical_gte(lcm_sym79__, 2)) { + lcm_sym74__ = (2 + 2); + if (logical_gte(lcm_sym74__, 2)) { + lcm_sym77__ = (2 * 2); + if (logical_gte(lcm_sym77__, 2)) { { -<<<<<<< HEAD - lcm_sym75__ = (2 + 1); + lcm_sym73__ = (2 + 1); lp_accum__.add(53); - for (size_t k = lcm_sym75__; k <= lcm_sym79__; ++k) { + for (size_t k = lcm_sym73__; k <= lcm_sym77__; ++k) { current_statement__ = 15; lp_accum__.add(53);} -======= - { - { - { - { - current_statement__ = 19; - lp_accum__.add(53); - } - { - { - current_statement__ = 19; - lp_accum__.add(53); - } - } - } - } - } - { - { - sym109__ = (2 * 2); - if (logical_lte(2, sym109__)) { - { - { - sym106__ = (2 + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym106__; k <= sym109__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else ; - } - } - { - { - sym109__ = (3 * 2); - if (logical_lte(3, sym109__)) { - { - { - sym106__ = (3 + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym106__; k <= sym109__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else ; - } - } ->>>>>>> master } } else { - lcm_sym75__ = (2 + 1); + lcm_sym73__ = (2 + 1); } -<<<<<<< HEAD - for (size_t j = lcm_sym75__; j <= lcm_sym76__; ++j) { - lcm_sym80__ = (j * 2); - if (logical_gte(lcm_sym80__, j)) { - lcm_sym78__ = (j + 1); + for (size_t j = lcm_sym73__; j <= lcm_sym74__; ++j) { + lcm_sym78__ = (j * 2); + if (logical_gte(lcm_sym78__, j)) { + lcm_sym76__ = (j + 1); lp_accum__.add(53); - for (size_t k = lcm_sym78__; k <= lcm_sym80__; ++k) { + for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { current_statement__ = 15; lp_accum__.add(53);} } } } } { - lcm_sym76__ = (3 + 2); - if (logical_gte(lcm_sym76__, 3)) { - lcm_sym79__ = (3 * 2); - if (logical_gte(lcm_sym79__, 3)) { + lcm_sym74__ = (3 + 2); + if (logical_gte(lcm_sym74__, 3)) { + lcm_sym77__ = (3 * 2); + if (logical_gte(lcm_sym77__, 3)) { { - lcm_sym75__ = (3 + 1); + lcm_sym73__ = (3 + 1); lp_accum__.add(53); - for (size_t k = lcm_sym75__; k <= lcm_sym79__; ++k) { + for (size_t k = lcm_sym73__; k <= lcm_sym77__; ++k) { current_statement__ = 15; lp_accum__.add(53);} } } else { - lcm_sym75__ = (3 + 1); + lcm_sym73__ = (3 + 1); } - for (size_t j = lcm_sym75__; j <= lcm_sym76__; ++j) { - lcm_sym80__ = (j * 2); - if (logical_gte(lcm_sym80__, j)) { - lcm_sym78__ = (j + 1); + for (size_t j = lcm_sym73__; j <= lcm_sym74__; ++j) { + lcm_sym78__ = (j * 2); + if (logical_gte(lcm_sym78__, j)) { + lcm_sym76__ = (j + 1); lp_accum__.add(53); - for (size_t k = lcm_sym78__; k <= lcm_sym80__; ++k) { + for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { current_statement__ = 15; lp_accum__.add(53);} } } } } { - lcm_sym76__ = (4 + 2); - if (logical_gte(lcm_sym76__, 4)) { - lcm_sym79__ = (4 * 2); - if (logical_gte(lcm_sym79__, 4)) { + lcm_sym74__ = (4 + 2); + if (logical_gte(lcm_sym74__, 4)) { + lcm_sym77__ = (4 * 2); + if (logical_gte(lcm_sym77__, 4)) { { - lcm_sym75__ = (4 + 1); + lcm_sym73__ = (4 + 1); lp_accum__.add(53); - for (size_t k = lcm_sym75__; k <= lcm_sym79__; ++k) { + for (size_t k = lcm_sym73__; k <= lcm_sym77__; ++k) { current_statement__ = 15; lp_accum__.add(53);} } } else { - lcm_sym75__ = (4 + 1); + lcm_sym73__ = (4 + 1); } - for (size_t j = lcm_sym75__; j <= lcm_sym76__; ++j) { - lcm_sym80__ = (j * 2); - if (logical_gte(lcm_sym80__, j)) { - lcm_sym78__ = (j + 1); + for (size_t j = lcm_sym73__; j <= lcm_sym74__; ++j) { + lcm_sym78__ = (j * 2); + if (logical_gte(lcm_sym78__, j)) { + lcm_sym76__ = (j + 1); lp_accum__.add(53); - for (size_t k = lcm_sym78__; k <= lcm_sym80__; ++k) { + for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { current_statement__ = 15; lp_accum__.add(53);} } } } } { - lcm_sym76__ = (5 + 2); - if (logical_gte(lcm_sym76__, 5)) { - lcm_sym79__ = (5 * 2); - if (logical_gte(lcm_sym79__, 5)) { + lcm_sym74__ = (5 + 2); + if (logical_gte(lcm_sym74__, 5)) { + lcm_sym77__ = (5 * 2); + if (logical_gte(lcm_sym77__, 5)) { { - lcm_sym75__ = (5 + 1); + lcm_sym73__ = (5 + 1); lp_accum__.add(53); - for (size_t k = lcm_sym75__; k <= lcm_sym79__; ++k) { + for (size_t k = lcm_sym73__; k <= lcm_sym77__; ++k) { current_statement__ = 15; lp_accum__.add(53);} } } else { - lcm_sym75__ = (5 + 1); -======= - } - { - { - sym105__ = (2 + 2); - if (logical_lte(2, sym105__)) { - { - { - sym108__ = (2 * 2); - if (logical_lte(2, sym108__)) { - { - { - sym104__ = (2 + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym104__; k <= sym108__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else { - sym104__ = (2 + 1); - } - } - current_statement__ = 20; - for (size_t j = sym104__; j <= sym105__; ++j) { - { - sym109__ = (j * 2); - if (logical_lte(j, sym109__)) { - { - { - sym106__ = (j + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym106__; k <= sym109__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else ; - }} - } - } else ; + lcm_sym73__ = (5 + 1); } - } - { - { - sym105__ = (3 + 2); - if (logical_lte(3, sym105__)) { - { - { - sym108__ = (3 * 2); - if (logical_lte(3, sym108__)) { - { - { - sym104__ = (3 + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym104__; k <= sym108__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else { - sym104__ = (3 + 1); - } - } - current_statement__ = 20; - for (size_t j = sym104__; j <= sym105__; ++j) { - { - sym109__ = (j * 2); - if (logical_lte(j, sym109__)) { - { - { - sym106__ = (j + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym106__; k <= sym109__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else ; - }} - } - } else ; - } - } - { - { - sym105__ = (4 + 2); - if (logical_lte(4, sym105__)) { - { - { - sym108__ = (4 * 2); - if (logical_lte(4, sym108__)) { - { - { - sym104__ = (4 + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym104__; k <= sym108__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else { - sym104__ = (4 + 1); - } - } - current_statement__ = 20; - for (size_t j = sym104__; j <= sym105__; ++j) { - { - sym109__ = (j * 2); - if (logical_lte(j, sym109__)) { - { - { - sym106__ = (j + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym106__; k <= sym109__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else ; - }} - } - } else ; - } - } - { - { - sym105__ = (5 + 2); - if (logical_lte(5, sym105__)) { - { - { - sym108__ = (5 * 2); - if (logical_lte(5, sym108__)) { - { - { - sym104__ = (5 + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym104__; k <= sym108__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else { - sym104__ = (5 + 1); - } - } - current_statement__ = 20; - for (size_t j = sym104__; j <= sym105__; ++j) { - { - sym109__ = (j * 2); - if (logical_lte(j, sym109__)) { - { - { - sym106__ = (j + 1); - lp_accum__.add(53); - } - current_statement__ = 19; - for (size_t k = sym106__; k <= sym109__; ++k) { - { - current_statement__ = 19; - lp_accum__.add(53); - }} - } - } else ; - }} - } - } else ; ->>>>>>> master - } - for (size_t j = lcm_sym75__; j <= lcm_sym76__; ++j) { - lcm_sym80__ = (j * 2); - if (logical_gte(lcm_sym80__, j)) { - lcm_sym78__ = (j + 1); + for (size_t j = lcm_sym73__; j <= lcm_sym74__; ++j) { + lcm_sym78__ = (j * 2); + if (logical_gte(lcm_sym78__, j)) { + lcm_sym76__ = (j + 1); lp_accum__.add(53); - for (size_t k = lcm_sym78__; k <= lcm_sym80__; ++k) { + for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { current_statement__ = 15; lp_accum__.add(53);} } } @@ -1059,8 +735,8 @@ class optimizations_model : public model_base_crtp { x = 576; current_statement__ = 41; lp_accum__.add(576); - lcm_sym74__ = logical_gt(theta, 46); - if (lcm_sym74__) { + lcm_sym72__ = logical_gt(theta, 46); + if (lcm_sym72__) { current_statement__ = 42; x = 5880; } @@ -1073,7 +749,7 @@ class optimizations_model : public model_base_crtp { current_statement__ = 46; lp_accum__.add(x); current_statement__ = 48; - if (lcm_sym74__) { + if (lcm_sym72__) { current_statement__ = 47; z = x; } @@ -1202,20 +878,11 @@ class optimizations_model : public model_base_crtp { local_scalar_t__ paramvar; { -<<<<<<< HEAD current_statement__ = 86; paramvar = (theta * 34); } current_statement__ = 88; lp_accum__.add(paramvar); -======= - { - sym110__ = (theta * 34); - } - } - current_statement__ = 85; - lp_accum__.add(sym110__); ->>>>>>> master } } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); @@ -1245,9 +912,6 @@ class optimizations_model : public model_base_crtp { stan::math::accumulator lp_accum__; try { -<<<<<<< HEAD - double lcm_sym67__; - double lcm_sym66__; double lcm_sym65__; double lcm_sym64__; double lcm_sym63__; @@ -1256,27 +920,10 @@ class optimizations_model : public model_base_crtp { double lcm_sym60__; double lcm_sym59__; double lcm_sym58__; - int lcm_sym57__; - int lcm_sym56__; -======= - double sym76__; - double sym75__; - double sym74__; - double sym73__; - double sym72__; - double sym71__; - double sym70__; - double sym69__; - double sym68__; - double sym67__; - Eigen::Matrix sym66__; - int sym65__; - int sym64__; - double sym63__; - int sym62__; - int sym61__; - double sym60__; ->>>>>>> master + double lcm_sym57__; + double lcm_sym56__; + int lcm_sym55__; + int lcm_sym54__; double theta; current_statement__ = 1; @@ -1313,17 +960,10 @@ class optimizations_model : public model_base_crtp { current_statement__ = 5; x_cov_in__ = in__.vector(3); -<<<<<<< HEAD current_statement__ = 5; assign(x_cov, nil_index_list(), stan::math::cov_matrix_constrain(x_cov_in__, 2), "assigning variable x_cov"); -======= - assign(sym66__, nil_index_list(), - stan::math::cov_matrix_constrain(x_cov_in__, 2), - "assigning variable sym66__"); - assign(x_cov, nil_index_list(), sym66__, "assigning variable x_cov"); ->>>>>>> master vars__.push_back(theta); vars__.push_back(phi); { @@ -1379,33 +1019,10 @@ class optimizations_model : public model_base_crtp { cons_list(index_uni(1), cons_list(index_uni(1), nil_index_list())), "x_cov")); { -<<<<<<< HEAD vars__.push_back( rvalue(x_cov, cons_list(index_uni(2), cons_list(index_uni(1), nil_index_list())), "x_cov")); -======= - { - { - { - vars__.push_back( - rvalue(sym66__, - cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), - "sym66__")); - } - { - { - vars__.push_back( - rvalue(sym66__, - cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), - "sym66__")); - } - } - } - } ->>>>>>> master } } { @@ -1415,33 +1032,10 @@ class optimizations_model : public model_base_crtp { cons_list(index_uni(1), cons_list(index_uni(2), nil_index_list())), "x_cov")); { -<<<<<<< HEAD vars__.push_back( rvalue(x_cov, cons_list(index_uni(2), cons_list(index_uni(2), nil_index_list())), "x_cov")); -======= - { - { - { - vars__.push_back( - rvalue(sym66__, - cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), - "sym66__")); - } - { - { - vars__.push_back( - rvalue(sym66__, - cons_list(index_uni(2), - cons_list(index_uni(2), nil_index_list())), - "sym66__")); - } - } - } - } ->>>>>>> master } } } @@ -1468,9 +1062,6 @@ class optimizations_model : public model_base_crtp { vars__.reserve(num_params_r__); try { -<<<<<<< HEAD - double lcm_sym55__; - double lcm_sym54__; double lcm_sym53__; double lcm_sym52__; double lcm_sym51__; @@ -1486,48 +1077,17 @@ class optimizations_model : public model_base_crtp { double lcm_sym41__; double lcm_sym40__; int lcm_sym39__; -======= - double sym59__; - double sym58__; - double sym57__; - double sym56__; - double sym55__; - double sym54__; - double sym53__; - double sym52__; - double sym51__; - double sym50__; - double sym49__; - double sym48__; - double sym47__; - double sym46__; - double sym45__; - double sym44__; - std::vector sym43__; - std::vector sym42__; - std::vector sym41__; - int sym40__; - int sym39__; - int sym38__; ->>>>>>> master int pos__; pos__ = 1; double theta; -<<<<<<< HEAD current_statement__ = 1; theta = context__.vals_r("theta")[(1 - 1)]; double phi; current_statement__ = 2; phi = context__.vals_r("phi")[(1 - 1)]; -======= - sym53__ = context__.vals_r("theta")[(1 - 1)]; - double phi; - - sym52__ = context__.vals_r("phi")[(1 - 1)]; ->>>>>>> master current_statement__ = 3; validate_non_negative_index("x_matrix", "3", 3); current_statement__ = 3; @@ -1684,12 +1244,6 @@ class optimizations_model : public model_base_crtp { } } current_statement__ = 5; -<<<<<<< HEAD - assign(x_cov, nil_index_list(), stan::math::cov_matrix_free(x_cov), - "assigning variable x_cov"); - vars__.push_back(theta); - vars__.push_back(phi); -======= validate_non_negative_index("x_cov_free__", "(2 + ((2 * (2 - 1)) / 2))", 3); Eigen::Matrix x_cov_free__; @@ -1698,9 +1252,8 @@ class optimizations_model : public model_base_crtp { current_statement__ = 5; assign(x_cov_free__, nil_index_list(), stan::math::cov_matrix_free(x_cov), "assigning variable x_cov_free__"); - vars__.push_back(sym53__); - vars__.push_back(sym52__); ->>>>>>> master + vars__.push_back(theta); + vars__.push_back(phi); { { vars__.push_back( @@ -1748,44 +1301,12 @@ class optimizations_model : public model_base_crtp { } } { + vars__.push_back(x_cov_free__[(1 - 1)]); { - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), "x_cov")); - { -<<<<<<< HEAD - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), "x_cov")); -======= - vars__.push_back(x_cov_free__[(1 - 1)]); - } - { - { - vars__.push_back(x_cov_free__[(2 - 1)]); - } ->>>>>>> master - } + vars__.push_back(x_cov_free__[(2 - 1)]); } { - { - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), "x_cov")); - { -<<<<<<< HEAD - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(2), - cons_list(index_uni(2), nil_index_list())), "x_cov")); -======= - vars__.push_back(x_cov_free__[(3 - 1)]); ->>>>>>> master - } - } + vars__.push_back(x_cov_free__[(3 - 1)]); } } } catch (const std::exception& e) { @@ -1834,41 +1355,22 @@ class optimizations_model : public model_base_crtp { param_names__.push_back(std::string() + "theta"); param_names__.push_back(std::string() + "phi"); -<<<<<<< HEAD - for (size_t sym82__ = 1; sym82__ <= 2; ++sym82__) { - { - for (size_t sym83__ = 1; sym83__ <= 3; ++sym83__) { - { - param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym83__) + '.' + std::to_string(sym82__)); - }} - }} - for (size_t sym82__ = 1; sym82__ <= 2; ++sym82__) { - { - param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym82__)); - }} - for (size_t sym82__ = 1; sym82__ <= 2; ++sym82__) { - { - for (size_t sym83__ = 1; sym83__ <= 2; ++sym83__) { - { - param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym83__) + '.' + std::to_string(sym82__)); -======= - for (size_t sym111__ = 1; sym111__ <= 2; ++sym111__) { + for (size_t sym80__ = 1; sym80__ <= 2; ++sym80__) { { - for (size_t sym112__ = 1; sym112__ <= 3; ++sym112__) { + for (size_t sym81__ = 1; sym81__ <= 3; ++sym81__) { { - param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym112__) + '.' + std::to_string(sym111__)); + param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym81__) + '.' + std::to_string(sym80__)); }} }} - for (size_t sym111__ = 1; sym111__ <= 2; ++sym111__) { + for (size_t sym80__ = 1; sym80__ <= 2; ++sym80__) { { - param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym111__)); + param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym80__)); }} - for (size_t sym111__ = 1; sym111__ <= 2; ++sym111__) { + for (size_t sym80__ = 1; sym80__ <= 2; ++sym80__) { { - for (size_t sym112__ = 1; sym112__ <= 2; ++sym112__) { + for (size_t sym81__ = 1; sym81__ <= 2; ++sym81__) { { - param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym112__) + '.' + std::to_string(sym111__)); ->>>>>>> master + param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym81__) + '.' + std::to_string(sym80__)); }} }} if (emit_transformed_parameters__) { @@ -1887,37 +1389,20 @@ class optimizations_model : public model_base_crtp { param_names__.push_back(std::string() + "theta"); param_names__.push_back(std::string() + "phi"); -<<<<<<< HEAD - for (size_t sym82__ = 1; sym82__ <= 2; ++sym82__) { - { - for (size_t sym83__ = 1; sym83__ <= 3; ++sym83__) { - { - param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym83__) + '.' + std::to_string(sym82__)); - }} - }} - for (size_t sym82__ = 1; sym82__ <= 2; ++sym82__) { - { - param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym82__)); - }} - for (size_t sym82__ = 1; sym82__ <= 3; ++sym82__) { - { - param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym82__)); -======= - for (size_t sym111__ = 1; sym111__ <= 2; ++sym111__) { + for (size_t sym80__ = 1; sym80__ <= 2; ++sym80__) { { - for (size_t sym112__ = 1; sym112__ <= 3; ++sym112__) { + for (size_t sym81__ = 1; sym81__ <= 3; ++sym81__) { { - param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym112__) + '.' + std::to_string(sym111__)); + param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym81__) + '.' + std::to_string(sym80__)); }} }} - for (size_t sym111__ = 1; sym111__ <= 2; ++sym111__) { + for (size_t sym80__ = 1; sym80__ <= 2; ++sym80__) { { - param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym111__)); + param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym80__)); }} - for (size_t sym111__ = 1; sym111__ <= 3; ++sym111__) { + for (size_t sym80__ = 1; sym80__ <= 3; ++sym80__) { { - param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym111__)); ->>>>>>> master + param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym80__)); }} if (emit_transformed_parameters__) { From 0ccd903e339d5a643a0d03ecc406e63e50b9d9d6 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Mon, 20 Apr 2020 23:39:08 -0400 Subject: [PATCH 19/27] Fixed when expr prop didn't kill expressions due to shadowing In assignments like `x = f(x)`, expr prop would kill replacements involving x and then add x -> f(x). Instead it should add x -> f(x) and then kill, or equivalently see that x is in f(x) and not add the replacement. All examples are compiling and correct, horray! --- src/analysis_and_optimization/Monotone_framework.ml | 2 +- src/stanc/stanc.ml | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/analysis_and_optimization/Monotone_framework.ml b/src/analysis_and_optimization/Monotone_framework.ml index 2791c0eedb..b5c7845447 100644 --- a/src/analysis_and_optimization/Monotone_framework.ml +++ b/src/analysis_and_optimization/Monotone_framework.ml @@ -369,7 +369,7 @@ let expression_propagation_transfer We could do the same for matrix and array expressions if we wanted. *) | Middle.Stmt.Fixed.Pattern.Assignment ((s, _, []), e) -> let m' = kill_var m s in - if can_side_effect_expr e then + if can_side_effect_expr e || Set.Poly.mem (free_vars_expr e) s then m' else Map.set m ~key:s ~data:(subst_expr m e) | Decl {decl_id= s; _} | Assignment ((s, _, _ :: _), _) -> diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index c562fc3293..0417d524de 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -125,7 +125,7 @@ let options = (* Whether or not to run each optimization. Currently it's all or nothing depending on the --O flag.*) let optimization_settings lvl : Optimize.optimization_settings = - let empty : Optimize.optimization_settings = + let _ : Optimize.optimization_settings = { function_inlining= false ; static_loop_unrolling= false ; one_step_loop_unrolling= false @@ -171,8 +171,9 @@ let optimization_settings lvl : Optimize.optimization_settings = } in match lvl with | 1 -> - { empty with + { max_safe with copy_propagation = true + ; expression_propagation = false } | 2 -> { max_safe with From 1e3a18cf5d6f4764c0c8488a0481f7fbb140d803 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Tue, 21 Apr 2020 00:07:34 -0400 Subject: [PATCH 20/27] removed most optimization debug code, restored the fma partial evaluation --- .../Monotone_framework.ml | 51 ++----------------- src/analysis_and_optimization/Optimize.ml | 47 +++-------------- .../Partial_evaluator.ml | 9 ++-- src/stanc/stanc.ml | 15 ------ 4 files changed, 16 insertions(+), 106 deletions(-) diff --git a/src/analysis_and_optimization/Monotone_framework.ml b/src/analysis_and_optimization/Monotone_framework.ml index b5c7845447..99d8267688 100644 --- a/src/analysis_and_optimization/Monotone_framework.ml +++ b/src/analysis_and_optimization/Monotone_framework.ml @@ -321,18 +321,8 @@ let label_top_decls label : string Set.Poly.t = let stmt = Map.Poly.find_exn flowgraph_to_mir label in match stmt.pattern with - | Decl {decl_id= s; _} -> - (* let _ = print_endline - * ( "stmt: " ^ ([%sexp (stmt : Middle.Stmt.Located.Non_recursive.t)] |> Sexp.to_string) - * ^ " decl " ^ s) - * in *) - Set.Poly.singleton s - | _ -> - (* let _ = print_endline - * ("stmt: " ^ ([%sexp (stmt : Middle.Stmt.Located.Non_recursive.t)] |> Sexp.to_string) - * ^ "nodecl" ) - * in *) - Set.Poly.empty + | Decl {decl_id= s; _} -> Set.Poly.singleton s + | _ -> Set.Poly.empty let exprop_debug = false @@ -351,15 +341,7 @@ let expression_propagation_transfer | None -> None | Some m -> let mir_node = (Map.find_exn flowgraph_to_mir l).pattern in - (* TODO: Could probably use killed_expressions_stmt *) let kill_var m v = - (* let ms = - * [%sexp (m : (string, Expr.Typed.t) Map.Poly.t)] |> Sexp.to_string - * in - * let _ = if v = "x" then print_endline ( - * "killing var " ^ v ^ " in map " ^ ms - * ) - * in *) Map.filteri m ~f:(fun ~key ~data -> not (key = v || Set.Poly.mem (free_vars_expr data) v)) in @@ -378,12 +360,6 @@ let expression_propagation_transfer let kills = Set.Poly.union_list (List.map ~f:(label_top_decls flowgraph_to_mir) b) in - (* let _ = - * let print_set s to_string = - * [%sexp (Set.Poly.map ~f:to_string s : string Set.Poly.t)] |> Sexp.to_string - * in - * print_endline ("Kill set: " ^ print_set kills ident) - * in *) Set.Poly.fold kills ~init:m ~f:kill_var | TargetPE _ |NRFunApp (_, _, _) @@ -418,25 +394,10 @@ let copy_propagation_transfer ( match mir_node with | Assignment ((s, _, []), {pattern= Var t; meta}) -> let m' = kill_var m s in - (* let _ = print_endline ("killing " ^ s) in *) if (Set.Poly.mem globals s) then m' else - let m'' = - Map.set m' ~key:s ~data:Expr.Fixed.{pattern= Var t; meta} - in - let _ = - if false then - print_endline ( - "Updating map on assignment " ^ s ^ ":=" ^ t ^ " :" - ^ ([%sexp (m : (string, Expr.Typed.t) Map.Poly.t)] |> Sexp.to_string_hum) - ^ " -> " - ^ ([%sexp (m' : (string, Expr.Typed.t) Map.Poly.t)] |> Sexp.to_string_hum) - ^ " -> " - ^ ([%sexp (m'' : (string, Expr.Typed.t) Map.Poly.t)] |> Sexp.to_string_hum) - ) - in - m'' + Map.set m' ~key:s ~data:Expr.Fixed.{pattern= Var t; meta} | Decl {decl_id= s; _} | Assignment ((s, _, _), _) -> kill_var m s | Block b -> @@ -1061,11 +1022,7 @@ let live_variables_mfp (prog : Program.Typed.t) let (module Mf) = monotone_framework (module Rev_Flowgraph) (module Lattice) (module Transfer) in - let mfp = Mf.mfp () in - (* let _ = print_endline "STARTING BLOCK {" in - * let _ = print_mfp ident mfp flowgraph_to_mir in - * let _ = print_endline "} ENDING BLOCK" in *) - mfp + Mf.mfp () let lcm_debug = false diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml index 9fc470c373..28b1a8a46a 100644 --- a/src/analysis_and_optimization/Optimize.ml +++ b/src/analysis_and_optimization/Optimize.ml @@ -108,12 +108,6 @@ let replace_fresh_local_vars s' = | x -> (x, m) in let s, m = map_rec_state_stmt_loc f Map.Poly.empty s' in - (* let _ = Map.Poly.iteri m ~f:(fun ~key ~data -> - * print_endline ( - * key ^ " -> " ^ data - * ) - * ) - * in *) name_subst_stmt m s let subst_args_stmt args es = @@ -592,20 +586,6 @@ let propagation (module Flowgraph) flowgraph_to_mir propagation_transfer in - let _ = - if false then ( - let print_stmt s = - [%sexp (s : Stmt.Located.Non_recursive.t)] |> Sexp.to_string_hum - in - Map.iteri values ~f:(fun ~key ~data -> - print_endline (string_of_int key ^ ":\n " - ^ print_stmt (Map.Poly.find_exn flowgraph_to_mir key) ^ ":\n " - ^ ([%sexp (data.entry : (string, Expr.Typed.t) Map.Poly.t option)] |> Sexp.to_string_hum) - ^ " \t-> " - ^ ([%sexp (data.exit : (string, Expr.Typed.t) Map.Poly.t option)] |> Sexp.to_string_hum)) - ) - ) - in let propagate_stmt = map_rec_stmt_loc_num flowgraph_to_mir (fun i -> subst_stmt_base @@ -665,19 +645,7 @@ let expression_propagation mir = let copy_propagation mir = let globals = Monotone_framework.globals mir in - let res = - propagation (Monotone_framework.copy_propagation_transfer globals) mir - in - let _ = if false then ( - print_endline "Input program: {!"; - Program.Typed.pp Fmt.stdout mir; - print_endline "}!"; - print_endline "Output program: {!"; - Program.Typed.pp Fmt.stdout res; - print_endline "}!"; - ) - in - res + propagation (Monotone_framework.copy_propagation_transfer globals) mir let is_skip_break_continue s = match s with @@ -843,11 +811,11 @@ let lazy_code_motion (mir : Program.Typed.t) = Set.fold (Monotone_framework.used_expressions_stmt s.pattern) ~init:Expr.Typed.Map.empty ~f:collect_expressions in - let print_expr (e:Expr.Typed.t) = - [%sexp (e.pattern : Expr.Typed.Meta.t Expr.Fixed.t Expr.Fixed.Pattern.t)] |> Sexp.to_string - in let _ = if Monotone_framework.lcm_debug then + let print_expr (e:Expr.Typed.t) = + [%sexp (e.pattern : Expr.Typed.Meta.t Expr.Fixed.t Expr.Fixed.Pattern.t)] |> Sexp.to_string + in (print_endline "Expression map:"; Map.iteri expression_map ~f:(fun ~key ~data -> print_endline ( @@ -916,6 +884,10 @@ let lazy_code_motion (mir : Program.Typed.t) = in let _ = if Monotone_framework.lcm_debug then + let print_expr (e:Expr.Typed.t) = + [%sexp (e.pattern : Expr.Typed.Meta.t Expr.Fixed.t Expr.Fixed.Pattern.t)] + |> Sexp.to_string + in (print_endline (string_of_int i ^ ": expression replacement map: {"); Map.iteri expr_map ~f:(fun ~key ~data -> print_endline ( @@ -938,7 +910,6 @@ let lazy_code_motion (mir : Program.Typed.t) = let lazy_code_motion_stmt = map_rec_stmt_loc_num flowgraph_to_mir lazy_code_motion_base in - (* let _ = print_endline ("Done 1") in *) Stmt.Fixed. { pattern= SList @@ -970,9 +941,7 @@ let lazy_code_motion (mir : Program.Typed.t) = in map_rec_stmt_loc cleanup_base in - (* let _ = print_endline ("Done 2") in *) let res = transform_program_blockwise mir (fun _ x -> cleanup (transform (preprocess_flowgraph x))) in - (* let _ = print_endline ("Done 3") in *) let _ = if Monotone_framework.lcm_debug then ( print_endline "Output program: {!"; diff --git a/src/analysis_and_optimization/Partial_evaluator.ml b/src/analysis_and_optimization/Partial_evaluator.ml index 11c16281ee..db85f9640f 100644 --- a/src/analysis_and_optimization/Partial_evaluator.ml +++ b/src/analysis_and_optimization/Partial_evaluator.ml @@ -554,11 +554,10 @@ let rec eval_expr (e : Expr.Typed.t) = | "Minus__", [{pattern= FunApp (StanLib, "exp", l'); _}; x] when is_int 1 x -> FunApp (StanLib, "expm1", l') - (* DO NOT MERGE THIS TO MASTER, JUST FOR TESTING *) - (* | "Plus__", [{pattern= FunApp (StanLib, "Times__", [x; y]); _}; z] - * |"Plus__", [z; {pattern= FunApp (StanLib, "Times__", [x; y]); _}] - * -> - * FunApp (StanLib, "fma", [x; y; z]) *) + | "Plus__", [{pattern= FunApp (StanLib, "Times__", [x; y]); _}; z] + |"Plus__", [z; {pattern= FunApp (StanLib, "Times__", [x; y]); _}] + -> + FunApp (StanLib, "fma", [x; y; z]) | "Minus__", [x; {pattern= FunApp (StanLib, "gamma_p", l); _}] when is_int 1 x -> FunApp (StanLib, "gamma_q", l) diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index 0417d524de..0bbb30fba2 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -140,21 +140,6 @@ let optimization_settings lvl : Optimize.optimization_settings = ; optimize_ad_levels= false } in - let _ : Optimize.optimization_settings = - { function_inlining= false - ; static_loop_unrolling= true - ; one_step_loop_unrolling= true - ; list_collapsing= true - ; block_fixing= true - ; constant_propagation= true - ; expression_propagation= false - ; copy_propagation= false - ; dead_code_elimination= false - ; partial_evaluation= true - ; lazy_code_motion= false - ; optimize_ad_levels= false - } - in let max_safe : Optimize.optimization_settings = { function_inlining= true ; static_loop_unrolling= true From 12b2036d9fe7c67de07855ca5475d3a5a9e23d4e Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Thu, 23 Apr 2020 10:59:20 -0400 Subject: [PATCH 21/27] Added integration tests for optimizations. Should setup better. --- .../good/compiler-optimizations/cpp.expected | 33702 +++++++++++++++- .../good/compiler-optimizations/dune | 26 +- 2 files changed, 32637 insertions(+), 1091 deletions(-) diff --git a/test/integration/good/compiler-optimizations/cpp.expected b/test/integration/good/compiler-optimizations/cpp.expected index 2f95bb3d8a..f633682827 100644 --- a/test/integration/good/compiler-optimizations/cpp.expected +++ b/test/integration/good/compiler-optimizations/cpp.expected @@ -1,8 +1,8 @@ - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp optimizations.stan + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp ad-level-failing.stan // Code generated by %%NAME%% %%VERSION%% #include -namespace optimizations_model_namespace { +namespace ad_level_failing_model_namespace { template std::vector resize_to_match__(std::vector& dst, const std::vector& src) { @@ -91,184 +91,79 @@ using namespace stan::math; static int current_statement__ = 0; static const std::vector locations_array__ = {" (found before start of program)", - " (in 'optimizations.stan', line 20, column 4 to column 15)", - " (in 'optimizations.stan', line 21, column 4 to column 13)", - " (in 'optimizations.stan', line 22, column 4 to column 26)", - " (in 'optimizations.stan', line 23, column 4 to column 23)", - " (in 'optimizations.stan', line 24, column 4 to column 24)", - " (in 'optimizations.stan', line 27, column 4 to column 11)", - " (in 'optimizations.stan', line 5, column 8 to column 20)", - " (in 'optimizations.stan', line 2, column 33 to line 6, column 5)", - " (in 'optimizations.stan', line 9, column 8 to line 10, column 26)", - " (in 'optimizations.stan', line 8, column 20 to line 12, column 5)", - " (in 'optimizations.stan', line 30, column 17 to column 28)", - " (in 'optimizations.stan', line 31, column 33 to line 34, column 5)", - " (in 'optimizations.stan', line 36, column 8 to column 21)", - " (in 'optimizations.stan', line 35, column 4 to line 37, column 5)", - " (in 'optimizations.stan', line 41, column 16 to column 29)", - " (in 'optimizations.stan', line 40, column 12 to line 41, column 29)", - " (in 'optimizations.stan', line 39, column 8 to line 41, column 29)", - " (in 'optimizations.stan', line 38, column 4 to line 41, column 29)", - " (in 'optimizations.stan', line 44, column 10 to column 16)", - " (in 'optimizations.stan', line 43, column 8 to line 44, column 16)", - " (in 'optimizations.stan', line 45, column 8 to column 20)", - " (in 'optimizations.stan', line 42, column 21 to line 46, column 5)", - " (in 'optimizations.stan', line 42, column 4 to line 46, column 5)", - " (in 'optimizations.stan', line 49, column 10 to column 19)", - " (in 'optimizations.stan', line 48, column 8 to line 49, column 19)", - " (in 'optimizations.stan', line 50, column 8 to column 20)", - " (in 'optimizations.stan', line 47, column 21 to line 51, column 5)", - " (in 'optimizations.stan', line 47, column 4 to line 51, column 5)", - " (in 'optimizations.stan', line 54, column 10 to column 19)", - " (in 'optimizations.stan', line 53, column 8 to line 54, column 19)", - " (in 'optimizations.stan', line 55, column 8 to column 20)", - " (in 'optimizations.stan', line 52, column 21 to line 56, column 5)", - " (in 'optimizations.stan', line 52, column 4 to line 56, column 5)", - " (in 'optimizations.stan', line 57, column 4 to column 10)", - " (in 'optimizations.stan', line 58, column 4 to column 16)", - " (in 'optimizations.stan', line 60, column 6 to column 12)", - " (in 'optimizations.stan', line 59, column 4 to line 60, column 12)", - " (in 'optimizations.stan', line 61, column 4 to column 16)", - " (in 'optimizations.stan', line 64, column 4 to column 16)", - " (in 'optimizations.stan', line 65, column 4 to column 16)", - " (in 'optimizations.stan', line 66, column 4 to column 16)", - " (in 'optimizations.stan', line 68, column 6 to column 19)", - " (in 'optimizations.stan', line 69, column 4 to column 16)", - " (in 'optimizations.stan', line 70, column 4 to column 11)", - " (in 'optimizations.stan', line 71, column 4 to column 10)", - " (in 'optimizations.stan', line 72, column 4 to column 16)", - " (in 'optimizations.stan', line 74, column 6 to column 12)", - " (in 'optimizations.stan', line 73, column 4 to line 74, column 12)", - " (in 'optimizations.stan', line 75, column 4 to column 16)", - " (in 'optimizations.stan', line 78, column 4 to column 16)", - " (in 'optimizations.stan', line 80, column 8 to column 19)", - " (in 'optimizations.stan', line 82, column 8 to column 20)", - " (in 'optimizations.stan', line 79, column 4 to line 83, column 5)", - " (in 'optimizations.stan', line 85, column 8 to column 20)", - " (in 'optimizations.stan', line 87, column 8 to column 20)", - " (in 'optimizations.stan', line 84, column 4 to line 88, column 5)", - " (in 'optimizations.stan', line 90, column 11 to column 23)", - " (in 'optimizations.stan', line 90, column 4 to column 23)", - " (in 'optimizations.stan', line 15, column 8 to column 20)", - " (in 'optimizations.stan', line 14, column 18 to line 17, column 5)", - " (in 'optimizations.stan', line 97, column 20 to column 26)", - " (in 'optimizations.stan', line 97, column 4 to column 26)", - " (in 'optimizations.stan', line 98, column 22 to column 28)", - " (in 'optimizations.stan', line 100, column 6 to column 15)", - " (in 'optimizations.stan', line 99, column 4 to line 100, column 15)", - " (in 'optimizations.stan', line 102, column 6 to column 12)", - " (in 'optimizations.stan', line 101, column 4 to line 102, column 12)", - " (in 'optimizations.stan', line 106, column 6 to column 15)", - " (in 'optimizations.stan', line 108, column 6 to column 12)", - " (in 'optimizations.stan', line 112, column 8 to column 20)", - " (in 'optimizations.stan', line 115, column 8 to column 21)", - " (in 'optimizations.stan', line 111, column 4 to line 116, column 5)", - " (in 'optimizations.stan', line 119, column 12 to column 24)", - " (in 'optimizations.stan', line 118, column 8 to line 121, column 9)", - " (in 'optimizations.stan', line 117, column 4 to line 127, column 5)", - " (in 'optimizations.stan', line 128, column 4 to column 14)", - " (in 'optimizations.stan', line 132, column 6 to column 21)", - " (in 'optimizations.stan', line 129, column 4 to line 132, column 21)", - " (in 'optimizations.stan', line 134, column 4 to column 15)", - " (in 'optimizations.stan', line 137, column 8 to column 23)", - " (in 'optimizations.stan', line 138, column 8 to column 24)", - " (in 'optimizations.stan', line 135, column 4 to line 139, column 5)", - " (in 'optimizations.stan', line 140, column 4 to column 25)", - " (in 'optimizations.stan', line 143, column 4 to column 26)", - " (in 'optimizations.stan', line 144, column 4 to column 22)", - " (in 'optimizations.stan', line 146, column 6 to column 28)", - " (in 'optimizations.stan', line 145, column 4 to line 146, column 28)", - " (in 'optimizations.stan', line 147, column 4 to column 23)", - " (in 'optimizations.stan', line 4, column 10 to column 17)", - " (in 'optimizations.stan', line 3, column 8 to line 4, column 17)", - " (in 'optimizations.stan', line 10, column 12 to column 26)", - " (in 'optimizations.stan', line 11, column 8 to column 21)", - " (in 'optimizations.stan', line 16, column 8 to column 18)"}; - + " (in 'ad-level-failing.stan', line 45, column 2 to column 21)", + " (in 'ad-level-failing.stan', line 46, column 2 to column 22)", + " (in 'ad-level-failing.stan', line 47, column 2 to column 19)", + " (in 'ad-level-failing.stan', line 48, column 2 to column 22)", + " (in 'ad-level-failing.stan', line 52, column 2 to column 26)", + " (in 'ad-level-failing.stan', line 54, column 4 to column 52)", + " (in 'ad-level-failing.stan', line 53, column 2 to line 56, column 3)", + " (in 'ad-level-failing.stan', line 60, column 2 to column 24)", + " (in 'ad-level-failing.stan', line 61, column 2 to column 23)", + " (in 'ad-level-failing.stan', line 62, column 2 to column 21)", + " (in 'ad-level-failing.stan', line 63, column 2 to column 23)", + " (in 'ad-level-failing.stan', line 65, column 2 to column 41)", + " (in 'ad-level-failing.stan', line 67, column 4 to column 49)", + " (in 'ad-level-failing.stan', line 66, column 2 to line 67, column 49)", + " (in 'ad-level-failing.stan', line 69, column 2 to column 53)", + " (in 'ad-level-failing.stan', line 29, column 2 to column 19)", + " (in 'ad-level-failing.stan', line 30, column 2 to column 14)", + " (in 'ad-level-failing.stan', line 31, column 2 to column 13)", + " (in 'ad-level-failing.stan', line 32, column 2 to column 20)", + " (in 'ad-level-failing.stan', line 33, column 2 to column 18)", + " (in 'ad-level-failing.stan', line 37, column 2 to column 14)", + " (in 'ad-level-failing.stan', line 38, column 2 to column 32)", + " (in 'ad-level-failing.stan', line 40, column 2 to column 14)", + " (in 'ad-level-failing.stan', line 41, column 2 to column 13)", + " (in 'ad-level-failing.stan', line 17, column 4 to column 17)", + " (in 'ad-level-failing.stan', line 19, column 4 to column 59)", + " (in 'ad-level-failing.stan', line 21, column 4 to column 30)", + " (in 'ad-level-failing.stan', line 22, column 4 to column 48)", + " (in 'ad-level-failing.stan', line 24, column 4 to column 16)", + " (in 'ad-level-failing.stan', line 15, column 31 to line 25, column 3)"}; -template -void -nrfun_lp(const T0__& x, const int& y, T_lp__& lp__, T_lp_accum__& lp_accum__, - std::ostream* pstream__) { - using local_scalar_t__ = typename boost::math::tools::promote_args::type; - - try { - int lcm_sym35__; - { - current_statement__ = 90; - if (logical_gt(x, 342)) { - current_statement__ = 89; - return ; - } - current_statement__ = 7; - lp_accum__.add(y); - } - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, locations_array__[current_statement__]); - // Next line prevents compiler griping about no return - throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); - } - -} - -struct nrfun_lp_functor__ { -template -void -operator()(const T0__& x, const int& y, T_lp__& lp__, - T_lp_accum__& lp_accum__, std::ostream* pstream__) const -{ -return nrfun_lp(x, y, lp__, lp_accum__, pstream__); -} -}; -int -rfun(const int& y, std::ostream* pstream__) { - using local_scalar_t__ = double; +template +std::vector::type> +simple_SIR(const T0__& t, const std::vector& y, + const std::vector& theta, const std::vector& x_r, + const std::vector& x_i, std::ostream* pstream__) { + using local_scalar_t__ = typename boost::math::tools::promote_args::type; const static bool propto__ = true; (void) propto__; try { - int lcm_sym38__; - int lcm_sym37__; - int lcm_sym36__; - { - current_statement__ = 9; - if (logical_gt(y, 2)) { - current_statement__ = 91; - return (y + 24); - } - current_statement__ = 92; - return (y + 2); - } - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, locations_array__[current_statement__]); - // Next line prevents compiler griping about no return - throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); - } - -} - -struct rfun_functor__ { -int -operator()(const int& y, std::ostream* pstream__) const -{ -return rfun(y, pstream__); -} -}; - -template -int -rfun_lp(T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__) { - using local_scalar_t__ = double; - - try { + local_scalar_t__ lcm_sym4__; + double lcm_sym3__; + double lcm_sym2__; + double lcm_sym1__; { - current_statement__ = 59; - lp_accum__.add(2); - current_statement__ = 93; - return 24; + current_statement__ = 25; + validate_non_negative_index("dydt", "4", 4); + std::vector dydt; + dydt = std::vector(4, 0); + + current_statement__ = 26; + assign(dydt, cons_list(index_uni(1), nil_index_list()), + (((-theta[(1 - 1)] * y[(4 - 1)]) / (y[(4 - 1)] + theta[(2 - 1)])) * + y[(1 - 1)]), "assigning variable dydt"); + lcm_sym4__ = (theta[(3 - 1)] * y[(2 - 1)]); + assign(dydt, cons_list(index_uni(2), nil_index_list()), + ((((theta[(1 - 1)] * y[(4 - 1)]) / (y[(4 - 1)] + theta[(2 - 1)])) * + y[(1 - 1)]) - lcm_sym4__), "assigning variable dydt"); + current_statement__ = 27; + assign(dydt, cons_list(index_uni(3), nil_index_list()), lcm_sym4__, + "assigning variable dydt"); + current_statement__ = 28; + assign(dydt, cons_list(index_uni(4), nil_index_list()), + ((theta[(4 - 1)] * y[(2 - 1)]) - (theta[(5 - 1)] * y[(4 - 1)])), + "assigning variable dydt"); + current_statement__ = 29; + return dydt; } } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); @@ -278,38 +173,117 @@ rfun_lp(T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__) { } -struct rfun_lp_functor__ { -template -int -operator()(T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__) const +struct simple_SIR_functor__ { +template +std::vector::type> +operator()(const T0__& t, const std::vector& y, + const std::vector& theta, const std::vector& x_r, + const std::vector& x_i, std::ostream* pstream__) const { -return rfun_lp(lp__, lp_accum__, pstream__); +return simple_SIR(t, y, theta, x_r, x_i, pstream__); } }; -class optimizations_model : public model_base_crtp { +class ad_level_failing_model : public model_base_crtp { private: + double lcm_sym30__; int pos__; + int N_t; + std::vector t; + std::vector y0; + std::vector stoi_hat; + std::vector B_hat; + double t0; + double kappa; + std::vector x_r; + std::vector x_i; public: - ~optimizations_model() { } + ~ad_level_failing_model() { } - std::string model_name() const { return "optimizations_model"; } + std::string model_name() const { return "ad_level_failing_model"; } - optimizations_model(stan::io::var_context& context__, - unsigned int random_seed__ = 0, - std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + ad_level_failing_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { typedef double local_scalar_t__; boost::ecuyer1988 base_rng__ = stan::services::util::create_rng(random_seed__, 0); (void) base_rng__; // suppress unused var warning - static const char* function__ = "optimizations_model_namespace::optimizations_model"; + static const char* function__ = "ad_level_failing_model_namespace::ad_level_failing_model"; (void) function__; // suppress unused var warning try { + pos__ = 1; + context__.validate_dims("data initialization","N_t","int", + context__.to_vec()); + + current_statement__ = 16; + N_t = context__.vals_i("N_t")[(1 - 1)]; + current_statement__ = 17; + validate_non_negative_index("t", "N_t", N_t); + context__.validate_dims("data initialization","t","double", + context__.to_vec(N_t)); + t = std::vector(N_t, 0); + + current_statement__ = 17; + assign(t, nil_index_list(), context__.vals_r("t"), + "assigning variable t"); + current_statement__ = 18; + validate_non_negative_index("y0", "4", 4); + context__.validate_dims("data initialization","y0","double", + context__.to_vec(4)); + y0 = std::vector(4, 0); + + current_statement__ = 18; + assign(y0, nil_index_list(), context__.vals_r("y0"), + "assigning variable y0"); + current_statement__ = 19; + validate_non_negative_index("stoi_hat", "N_t", N_t); + context__.validate_dims("data initialization","stoi_hat","int", + context__.to_vec(N_t)); + stoi_hat = std::vector(N_t, 0); + + current_statement__ = 19; + assign(stoi_hat, nil_index_list(), context__.vals_i("stoi_hat"), + "assigning variable stoi_hat"); + current_statement__ = 20; + validate_non_negative_index("B_hat", "N_t", N_t); + context__.validate_dims("data initialization","B_hat","double", + context__.to_vec(N_t)); + B_hat = std::vector(N_t, 0); + + current_statement__ = 20; + assign(B_hat, nil_index_list(), context__.vals_r("B_hat"), + "assigning variable B_hat"); + + lcm_sym30__ = std::numeric_limits::quiet_NaN(); + t0 = lcm_sym30__; + current_statement__ = 21; + t0 = 0; + + current_statement__ = 22; + kappa = lcm_sym30__; + current_statement__ = 22; + kappa = 1000000; + current_statement__ = 23; + validate_non_negative_index("x_r", "0", 0); + x_r = std::vector(0, 0); + + current_statement__ = 24; + validate_non_negative_index("x_i", "0", 0); + x_i = std::vector(0, 0); + + current_statement__ = 16; + current_statement__ = 16; + check_greater_or_equal(function__, "N_t", N_t, 0); + current_statement__ = 22; + current_statement__ = 22; + check_greater_or_equal(function__, "kappa", 1000000, 0); } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); // Next line prevents compiler griping about no return @@ -320,19 +294,8 @@ class optimizations_model : public model_base_crtp { try { num_params_r__ += 1; num_params_r__ += 1; - current_statement__ = 3; - validate_non_negative_index("x_matrix", "3", 3); - current_statement__ = 3; - validate_non_negative_index("x_matrix", "2", 2); - num_params_r__ += 3 * 2; - current_statement__ = 4; - validate_non_negative_index("x_vector", "2", 2); - num_params_r__ += 2; - current_statement__ = 5; - validate_non_negative_index("x_cov", "2", 2); - current_statement__ = 5; - validate_non_negative_index("x_cov", "2", 2); - num_params_r__ += 3; + num_params_r__ += 1; + num_params_r__ += 1; } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); // Next line prevents compiler griping about no return @@ -345,968 +308,32372 @@ class optimizations_model : public model_base_crtp { typedef T__ local_scalar_t__; T__ lp__(0.0); stan::math::accumulator lp_accum__; - static const char* function__ = "optimizations_model_namespace::log_prob"; + static const char* function__ = "ad_level_failing_model_namespace::log_prob"; (void) function__; // suppress unused var warning stan::io::reader in__(params_r__, params_i__); try { - double lcm_sym79__; - int lcm_sym78__; - int lcm_sym77__; - int lcm_sym76__; - int lcm_sym75__; - int lcm_sym74__; - int lcm_sym73__; - int lcm_sym72__; - int lcm_sym71__; - int lcm_sym70__; - int lcm_sym69__; - int lcm_sym68__; - int lcm_sym67__; - int lcm_sym66__; - local_scalar_t__ theta; + local_scalar_t__ lcm_sym29__; + double lcm_sym28__; + double lcm_sym27__; + double lcm_sym26__; + std::vector lcm_sym25__; + double lcm_sym24__; + double lcm_sym23__; + double lcm_sym22__; + double lcm_sym21__; + std::vector> lcm_sym20__; + double lcm_sym19__; + double lcm_sym18__; + double lcm_sym17__; + double lcm_sym16__; + int lcm_sym15__; + int lcm_sym14__; + local_scalar_t__ beta; current_statement__ = 1; - theta = in__.scalar(); - local_scalar_t__ phi; + beta = in__.scalar(); + current_statement__ = 1; + if (jacobian__) { + current_statement__ = 1; + beta = stan::math::lb_constrain(beta, 0, lp__); + } else { + current_statement__ = 1; + beta = stan::math::lb_constrain(beta, 0); + } + local_scalar_t__ gamma; current_statement__ = 2; - phi = in__.scalar(); + gamma = in__.scalar(); + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + gamma = stan::math::lb_constrain(gamma, 0, lp__); + } else { + current_statement__ = 2; + gamma = stan::math::lb_constrain(gamma, 0); + } + local_scalar_t__ xi; + current_statement__ = 3; - validate_non_negative_index("x_matrix", "3", 3); + xi = in__.scalar(); current_statement__ = 3; - validate_non_negative_index("x_matrix", "2", 2); - Eigen::Matrix x_matrix; - x_matrix = Eigen::Matrix(3, 2); + if (jacobian__) { + current_statement__ = 3; + xi = stan::math::lb_constrain(xi, 0, lp__); + } else { + current_statement__ = 3; + xi = stan::math::lb_constrain(xi, 0); + } + local_scalar_t__ delta; - current_statement__ = 3; - x_matrix = in__.matrix(3, 2); current_statement__ = 4; - validate_non_negative_index("x_vector", "2", 2); - Eigen::Matrix x_vector; - x_vector = Eigen::Matrix(2); - + delta = in__.scalar(); current_statement__ = 4; - x_vector = in__.vector(2); - current_statement__ = 5; - validate_non_negative_index("x_cov", "2", 2); - current_statement__ = 5; - validate_non_negative_index("x_cov", "2", 2); - Eigen::Matrix x_cov; - x_cov = Eigen::Matrix(2, 2); - - Eigen::Matrix x_cov_in__; - x_cov_in__ = Eigen::Matrix(3); - - current_statement__ = 5; - x_cov_in__ = in__.vector(3); - current_statement__ = 5; if (jacobian__) { - current_statement__ = 5; - assign(x_cov, nil_index_list(), - stan::math::cov_matrix_constrain(x_cov_in__, 2, lp__), - "assigning variable x_cov"); + current_statement__ = 4; + delta = stan::math::lb_constrain(delta, 0, lp__); } else { - current_statement__ = 5; - assign(x_cov, nil_index_list(), - stan::math::cov_matrix_constrain(x_cov_in__, 2), - "assigning variable x_cov"); + current_statement__ = 4; + delta = stan::math::lb_constrain(delta, 0); } + current_statement__ = 5; + validate_non_negative_index("y", "N_t", N_t); + current_statement__ = 5; + validate_non_negative_index("y", "4", 4); + std::vector> y; + y = std::vector>(N_t, std::vector(4, 0)); + { - double x; - - int inline_sym1__; - - for (size_t inline_sym2__ = 1; inline_sym2__ <= 1; ++inline_sym2__) { - current_statement__ = 7; - lp_accum__.add(3);} - int inline_sym3__; - int inline_sym4__; - - for (size_t inline_sym5__ = 1; inline_sym5__ <= 1; ++inline_sym5__) { - { - inline_sym3__ = 27; - break; - } - inline_sym3__ = 5; - break;} - if (pstream__) { - stan_print(pstream__, inline_sym3__); - stan_print(pstream__, "\n"); - } - int inline_sym6__; - int inline_sym7__; - - for (size_t inline_sym8__ = 1; inline_sym8__ <= 1; ++inline_sym8__) { - { - inline_sym6__ = 28; - break; - } - inline_sym6__ = 6; - break;} - if (inline_sym6__) { - current_statement__ = 11; - if (pstream__) { - stan_print(pstream__, "a"); - stan_print(pstream__, "\n"); - } - } - int inline_sym9__; - int inline_sym12__; - int inline_sym10__; - - for (size_t inline_sym11__ = 1; inline_sym11__ <= 1; ++inline_sym11__) { - { - inline_sym9__ = 31; - break; - } - inline_sym9__ = 9; - break;} - int inline_sym13__; + current_statement__ = 6; + validate_non_negative_index("theta", "5", 5); + std::vector theta; + theta = std::vector(5, 0); - for (size_t inline_sym14__ = 1; inline_sym14__ <= 1; ++inline_sym14__) { - { - inline_sym12__ = 29; - break; - } - inline_sym12__ = 7; - break;} - if (logical_gte(inline_sym12__, inline_sym9__)) { + assign(lcm_sym25__, nil_index_list(), + stan::math::array_builder().add(beta) + .add(1000000).add(gamma).add(xi).add(delta).array(), + "assigning variable lcm_sym25__"); + assign(lcm_sym20__, nil_index_list(), + integrate_ode_rk45(simple_SIR_functor__(), y0, 0, t, lcm_sym25__, + x_r, x_i, pstream__), "assigning variable lcm_sym20__"); + assign(y, nil_index_list(), lcm_sym20__, "assigning variable y"); + } + current_statement__ = 5; + if (logical_gte(N_t, 1)) { + { { - int inline_sym15__; - int inline_sym16__; - - for (size_t inline_sym17__ = 1; inline_sym17__ <= 1; - ++inline_sym17__) { + { + lcm_sym29__ = lcm_sym20__[(1 - 1)][(1 - 1)]; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + lcm_sym29__, 0); { - inline_sym15__ = 32; - break; + current_statement__ = 5; + current_statement__ = 5; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + lcm_sym20__[(1 - 1)][(2 - 1)], 0); } - inline_sym15__ = 10; - break;} - lp_accum__.add(inline_sym15__); - int inline_sym18__; - - for (size_t inline_sym19__ = 1; inline_sym19__ <= 1; - ++inline_sym19__) { - current_statement__ = 7; - lp_accum__.add(3);} - } - int inline_sym13__; - - lcm_sym75__ = (inline_sym9__ + 1); - for (size_t inline_sym14__ = 1; inline_sym14__ <= 1; - ++inline_sym14__) { - { - inline_sym12__ = 29; - lcm_sym75__ = (inline_sym9__ + 1); - break; - } - inline_sym12__ = 7; - lcm_sym75__ = (inline_sym9__ + 1); - break;} - for (size_t i = lcm_sym75__; i <= inline_sym12__; ++i) { - { - int inline_sym15__; - int inline_sym16__; - - for (size_t inline_sym17__ = 1; inline_sym17__ <= 1; - ++inline_sym17__) { - { - inline_sym15__ = 32; - break; - } - inline_sym15__ = 10; - break;} - lp_accum__.add(inline_sym15__); - int inline_sym18__; - - for (size_t inline_sym19__ = 1; inline_sym19__ <= 1; - ++inline_sym19__) { - current_statement__ = 7; - lp_accum__.add(3);} - } - int inline_sym13__; - - for (size_t inline_sym14__ = 1; inline_sym14__ <= 1; - ++inline_sym14__) { { - inline_sym12__ = 29; - break; + current_statement__ = 5; + current_statement__ = 5; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + lcm_sym20__[(1 - 1)][(3 - 1)], 0); } - inline_sym12__ = 7; - break;}} - } - { - current_statement__ = 13; - lp_accum__.add(53); - { - current_statement__ = 13; - lp_accum__.add(53); - } - { - current_statement__ = 13; - lp_accum__.add(53); - } - { - current_statement__ = 13; - lp_accum__.add(53); - } - { - current_statement__ = 13; - lp_accum__.add(53); - } - } - { - { - { - current_statement__ = 15; - lp_accum__.add(53); { - current_statement__ = 15; - lp_accum__.add(53); + current_statement__ = 5; + current_statement__ = 5; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + lcm_sym20__[(1 - 1)][(4 - 1)], 0); } } - { - lcm_sym78__ = (2 * 2); - if (logical_gte(lcm_sym78__, 2)) { - lcm_sym76__ = (2 + 1); - lp_accum__.add(53); - for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { - current_statement__ = 15; - lp_accum__.add(53);} - } - } - { - lcm_sym78__ = (3 * 2); - if (logical_gte(lcm_sym78__, 3)) { - lcm_sym76__ = (3 + 1); - lp_accum__.add(53); - for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { - current_statement__ = 15; - lp_accum__.add(53);} - } - } } - { - lcm_sym74__ = (2 + 2); - if (logical_gte(lcm_sym74__, 2)) { - lcm_sym77__ = (2 * 2); - if (logical_gte(lcm_sym77__, 2)) { - { - lcm_sym73__ = (2 + 1); - lp_accum__.add(53); - for (size_t k = lcm_sym73__; k <= lcm_sym77__; ++k) { - current_statement__ = 15; - lp_accum__.add(53);} - } - } else { - lcm_sym73__ = (2 + 1); + for (size_t sym1__ = 2; sym1__ <= N_t; ++sym1__) { + { + current_statement__ = 5; + current_statement__ = 5; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + lcm_sym20__[(sym1__ - 1)][(1 - 1)], 0); + { + current_statement__ = 5; + current_statement__ = 5; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + lcm_sym20__[(sym1__ - 1)][(2 - 1)], 0); } - for (size_t j = lcm_sym73__; j <= lcm_sym74__; ++j) { - lcm_sym78__ = (j * 2); - if (logical_gte(lcm_sym78__, j)) { - lcm_sym76__ = (j + 1); - lp_accum__.add(53); - for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { - current_statement__ = 15; - lp_accum__.add(53);} - } } - } - } - { - lcm_sym74__ = (3 + 2); - if (logical_gte(lcm_sym74__, 3)) { - lcm_sym77__ = (3 * 2); - if (logical_gte(lcm_sym77__, 3)) { - { - lcm_sym73__ = (3 + 1); - lp_accum__.add(53); - for (size_t k = lcm_sym73__; k <= lcm_sym77__; ++k) { - current_statement__ = 15; - lp_accum__.add(53);} - } - } else { - lcm_sym73__ = (3 + 1); + { + current_statement__ = 5; + current_statement__ = 5; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + lcm_sym20__[(sym1__ - 1)][(3 - 1)], 0); } - for (size_t j = lcm_sym73__; j <= lcm_sym74__; ++j) { - lcm_sym78__ = (j * 2); - if (logical_gte(lcm_sym78__, j)) { - lcm_sym76__ = (j + 1); - lp_accum__.add(53); - for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { - current_statement__ = 15; - lp_accum__.add(53);} - } } - } - } - { - lcm_sym74__ = (4 + 2); - if (logical_gte(lcm_sym74__, 4)) { - lcm_sym77__ = (4 * 2); - if (logical_gte(lcm_sym77__, 4)) { - { - lcm_sym73__ = (4 + 1); - lp_accum__.add(53); - for (size_t k = lcm_sym73__; k <= lcm_sym77__; ++k) { - current_statement__ = 15; - lp_accum__.add(53);} - } - } else { - lcm_sym73__ = (4 + 1); - } - for (size_t j = lcm_sym73__; j <= lcm_sym74__; ++j) { - lcm_sym78__ = (j * 2); - if (logical_gte(lcm_sym78__, j)) { - lcm_sym76__ = (j + 1); - lp_accum__.add(53); - for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { - current_statement__ = 15; - lp_accum__.add(53);} - } } - } - } - { - lcm_sym74__ = (5 + 2); - if (logical_gte(lcm_sym74__, 5)) { - lcm_sym77__ = (5 * 2); - if (logical_gte(lcm_sym77__, 5)) { - { - lcm_sym73__ = (5 + 1); - lp_accum__.add(53); - for (size_t k = lcm_sym73__; k <= lcm_sym77__; ++k) { - current_statement__ = 15; - lp_accum__.add(53);} - } - } else { - lcm_sym73__ = (5 + 1); + { + current_statement__ = 5; + current_statement__ = 5; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + lcm_sym20__[(sym1__ - 1)][(4 - 1)], 0); } - for (size_t j = lcm_sym73__; j <= lcm_sym74__; ++j) { - lcm_sym78__ = (j * 2); - if (logical_gte(lcm_sym78__, j)) { - lcm_sym76__ = (j + 1); - lp_accum__.add(53); - for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { - current_statement__ = 15; - lp_accum__.add(53);} - } } - } - } + }} } - current_statement__ = 23; - for (size_t i = 1; i <= 5; ++i) { - current_statement__ = 20; - if (logical_gt(i, 4)) { - break; + } else { + lcm_sym29__ = lcm_sym20__[(1 - 1)][(1 - 1)]; + } + { + current_statement__ = 8; + lp_accum__.add(cauchy_log(beta, 0, 2.5)); + current_statement__ = 9; + lp_accum__.add(cauchy_log(gamma, 0, 1)); + current_statement__ = 10; + lp_accum__.add(cauchy_log(xi, 0, 25)); + current_statement__ = 11; + lp_accum__.add(cauchy_log(delta, 0, 1)); + current_statement__ = 12; + lp_accum__.add( + poisson_log(stoi_hat[(1 - 1)], + (y0[(1 - 1)] - lcm_sym29__))); + current_statement__ = 14; + if (logical_gte(N_t, 2)) { + current_statement__ = 13; + lp_accum__.add( + poisson_log(stoi_hat[(2 - 1)], + (lcm_sym29__ - lcm_sym20__[(2 - 1)][(1 - 1)]))); + for (size_t n = 3; n <= N_t; ++n) { + current_statement__ = 13; + lp_accum__.add( + poisson_log(stoi_hat[(n - 1)], + (lcm_sym20__[((n - 1) - 1)][(1 - 1)] - + lcm_sym20__[(n - 1)][(1 - 1)])));} + } + current_statement__ = 15; + lp_accum__.add( + lognormal_log(B_hat, + stan::math::log(col(to_matrix(lcm_sym20__), 4)), 0.15)); + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "ad_level_failing_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + double lcm_sym13__; + double lcm_sym12__; + double lcm_sym11__; + double lcm_sym10__; + std::vector lcm_sym9__; + std::vector> lcm_sym8__; + int lcm_sym7__; + int lcm_sym6__; + int lcm_sym5__; + double beta; + + current_statement__ = 1; + beta = in__.scalar(); + current_statement__ = 1; + beta = stan::math::lb_constrain(beta, 0); + double gamma; + + current_statement__ = 2; + gamma = in__.scalar(); + current_statement__ = 2; + gamma = stan::math::lb_constrain(gamma, 0); + double xi; + + current_statement__ = 3; + xi = in__.scalar(); + current_statement__ = 3; + xi = stan::math::lb_constrain(xi, 0); + double delta; + + current_statement__ = 4; + delta = in__.scalar(); + current_statement__ = 4; + delta = stan::math::lb_constrain(delta, 0); + current_statement__ = 5; + validate_non_negative_index("y", "N_t", N_t); + current_statement__ = 5; + validate_non_negative_index("y", "4", 4); + std::vector> y; + y = std::vector>(N_t, std::vector(4, 0)); + + vars__.push_back(beta); + vars__.push_back(gamma); + vars__.push_back(xi); + vars__.push_back(delta); + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + { + current_statement__ = 6; + validate_non_negative_index("theta", "5", 5); + std::vector theta; + theta = std::vector(5, 0); + + assign(lcm_sym9__, nil_index_list(), + stan::math::array_builder().add(beta).add(1000000) + .add(gamma).add(xi).add(delta).array(), + "assigning variable lcm_sym9__"); + assign(lcm_sym8__, nil_index_list(), + integrate_ode_rk45(simple_SIR_functor__(), y0, 0, t, lcm_sym9__, + x_r, x_i, pstream__), "assigning variable lcm_sym8__"); + assign(y, nil_index_list(), lcm_sym8__, "assigning variable y"); + } + { + lcm_sym5__ = logical_gte(N_t, 1); + if (lcm_sym5__) { + vars__.push_back(lcm_sym8__[(1 - 1)][(1 - 1)]); + for (size_t sym2__ = 2; sym2__ <= N_t; ++sym2__) { + vars__.push_back(lcm_sym8__[(sym2__ - 1)][(1 - 1)]);} + } + { + if (lcm_sym5__) { + vars__.push_back(lcm_sym8__[(1 - 1)][(2 - 1)]); + for (size_t sym2__ = 2; sym2__ <= N_t; ++sym2__) { + vars__.push_back(lcm_sym8__[(sym2__ - 1)][(2 - 1)]);} } - current_statement__ = 21; - lp_accum__.add(2);} - current_statement__ = 28; - for (size_t i = 1; i <= 5; ++i) { - current_statement__ = 25; - if (logical_gt(i, 4)) { - continue; + } + { + if (lcm_sym5__) { + vars__.push_back(lcm_sym8__[(1 - 1)][(3 - 1)]); + for (size_t sym2__ = 2; sym2__ <= N_t; ++sym2__) { + vars__.push_back(lcm_sym8__[(sym2__ - 1)][(3 - 1)]);} } - current_statement__ = 26; - lp_accum__.add(2);} - current_statement__ = 33; - for (size_t i = 1; i <= 5; ++i) { - current_statement__ = 30; - if (logical_gt(i, 4)) { - continue; + } + { + if (lcm_sym5__) { + vars__.push_back(lcm_sym8__[(1 - 1)][(4 - 1)]); + for (size_t sym2__ = 2; sym2__ <= N_t; ++sym2__) { + vars__.push_back(lcm_sym8__[(sym2__ - 1)][(4 - 1)]);} } - current_statement__ = 31; - lp_accum__.add(2);} - current_statement__ = 34; - x = 3; - current_statement__ = 35; - lp_accum__.add(3); - current_statement__ = 37; - if (logical_gt(theta, 2)) { - current_statement__ = 36; - x = 2; - } - current_statement__ = 38; - lp_accum__.add(x); - current_statement__ = 39; - lp_accum__.add(247); - current_statement__ = 40; - x = 576; - current_statement__ = 41; - lp_accum__.add(576); - lcm_sym72__ = logical_gt(theta, 46); - if (lcm_sym72__) { - current_statement__ = 42; - x = 5880; + } + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + int pos__; + + pos__ = 1; + double beta; + + current_statement__ = 1; + beta = context__.vals_r("beta")[(1 - 1)]; + current_statement__ = 1; + beta = stan::math::lb_free(beta, 0); + double gamma; + + current_statement__ = 2; + gamma = context__.vals_r("gamma")[(1 - 1)]; + current_statement__ = 2; + gamma = stan::math::lb_free(gamma, 0); + double xi; + + current_statement__ = 3; + xi = context__.vals_r("xi")[(1 - 1)]; + current_statement__ = 3; + xi = stan::math::lb_free(xi, 0); + double delta; + + current_statement__ = 4; + delta = context__.vals_r("delta")[(1 - 1)]; + current_statement__ = 4; + delta = stan::math::lb_free(delta, 0); + vars__.push_back(beta); + vars__.push_back(gamma); + vars__.push_back(xi); + vars__.push_back(delta); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("beta"); + names__.push_back("gamma"); + names__.push_back("xi"); + names__.push_back("delta"); + names__.push_back("y"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(N_t); + + dims__.push_back(4); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "beta"); + param_names__.push_back(std::string() + "gamma"); + param_names__.push_back(std::string() + "xi"); + param_names__.push_back(std::string() + "delta"); + if (emit_transformed_parameters__) { + for (size_t sym31__ = 1; sym31__ <= 4; ++sym31__) { + { + for (size_t sym32__ = 1; sym32__ <= N_t; ++sym32__) { + { + param_names__.push_back(std::string() + "y" + '.' + std::to_string(sym32__) + '.' + std::to_string(sym31__)); + }} + }} + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "beta"); + param_names__.push_back(std::string() + "gamma"); + param_names__.push_back(std::string() + "xi"); + param_names__.push_back(std::string() + "delta"); + if (emit_transformed_parameters__) { + for (size_t sym31__ = 1; sym31__ <= 4; ++sym31__) { + { + for (size_t sym32__ = 1; sym32__ <= N_t; ++sym32__) { + { + param_names__.push_back(std::string() + "y" + '.' + std::to_string(sym32__) + '.' + std::to_string(sym31__)); + }} + }} + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"gamma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"xi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"delta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y\",\"type\":{\"name\":\"array\",\"length\":" << N_t << ",\"element_type\":{\"name\":\"array\",\"length\":" << 4 << ",\"element_type\":{\"name\":\"real\"}}},\"block\":\"transformed_parameters\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"gamma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"xi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"delta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y\",\"type\":{\"name\":\"array\",\"length\":" << N_t << ",\"element_type\":{\"name\":\"array\",\"length\":" << 4 << ",\"element_type\":{\"name\":\"real\"}}},\"block\":\"transformed_parameters\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef ad_level_failing_model_namespace::ad_level_failing_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp copy_fail.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace copy_fail_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'copy_fail.stan', line 71, column 2 to column 31)", + " (in 'copy_fail.stan', line 72, column 2 to column 40)", + " (in 'copy_fail.stan', line 76, column 2 to column 51)", + " (in 'copy_fail.stan', line 77, column 2 to column 49)", + " (in 'copy_fail.stan', line 78, column 2 to column 49)", + " (in 'copy_fail.stan', line 83, column 6 to column 20)", + " (in 'copy_fail.stan', line 84, column 6 to column 18)", + " (in 'copy_fail.stan', line 82, column 32 to line 85, column 5)", + " (in 'copy_fail.stan', line 87, column 6 to column 32)", + " (in 'copy_fail.stan', line 88, column 6 to column 23)", + " (in 'copy_fail.stan', line 86, column 38 to line 89, column 5)", + " (in 'copy_fail.stan', line 86, column 4 to line 89, column 5)", + " (in 'copy_fail.stan', line 81, column 20 to line 90, column 3)", + " (in 'copy_fail.stan', line 81, column 2 to line 90, column 3)", + " (in 'copy_fail.stan', line 26, column 4 to column 34)", + " (in 'copy_fail.stan', line 29, column 6 to column 32)", + " (in 'copy_fail.stan', line 32, column 8 to column 37)", + " (in 'copy_fail.stan', line 33, column 8 to column 32)", + " (in 'copy_fail.stan', line 41, column 8 to line 42, column 83)", + " (in 'copy_fail.stan', line 30, column 37 to line 43, column 7)", + " (in 'copy_fail.stan', line 28, column 22 to line 44, column 5)", + " (in 'copy_fail.stan', line 25, column 47 to line 46, column 3)", + " (in 'copy_fail.stan', line 105, column 8 to column 37)", + " (in 'copy_fail.stan', line 106, column 8 to column 41)", + " (in 'copy_fail.stan', line 104, column 40 to line 107, column 7)", + " (in 'copy_fail.stan', line 108, column 6 to column 37)", + " (in 'copy_fail.stan', line 103, column 22 to line 109, column 5)", + " (in 'copy_fail.stan', line 102, column 20 to line 110, column 3)", + " (in 'copy_fail.stan', line 102, column 2 to line 110, column 3)", + " (in 'copy_fail.stan', line 50, column 2 to column 20)", + " (in 'copy_fail.stan', line 51, column 2 to column 27)", + " (in 'copy_fail.stan', line 52, column 2 to column 44)", + " (in 'copy_fail.stan', line 53, column 2 to column 23)", + " (in 'copy_fail.stan', line 54, column 2 to column 54)", + " (in 'copy_fail.stan', line 58, column 2 to column 38)", + " (in 'copy_fail.stan', line 60, column 2 to column 45)", + " (in 'copy_fail.stan', line 61, column 2 to column 44)", + " (in 'copy_fail.stan', line 8, column 8 to column 17)", + " (in 'copy_fail.stan', line 7, column 6 to line 8, column 17)", + " (in 'copy_fail.stan', line 5, column 31 to line 10, column 3)", + " (in 'copy_fail.stan', line 65, column 4 to column 35)", + " (in 'copy_fail.stan', line 64, column 2 to line 65, column 35)", + " (in 'copy_fail.stan', line 15, column 6 to column 32)", + " (in 'copy_fail.stan', line 19, column 8 to column 17)", + " (in 'copy_fail.stan', line 18, column 6 to line 19, column 17)", + " (in 'copy_fail.stan', line 13, column 37 to line 20, column 5)", + " (in 'copy_fail.stan', line 12, column 30 to line 22, column 3)", + " (in 'copy_fail.stan', line 67, column 4 to column 33)", + " (in 'copy_fail.stan', line 66, column 2 to line 67, column 33)", + " (in 'copy_fail.stan', line 9, column 4 to column 13)", + " (in 'copy_fail.stan', line 21, column 4 to column 13)", + " (in 'copy_fail.stan', line 30, column 6 to line 43, column 7)", + " (in 'copy_fail.stan', line 28, column 4 to line 44, column 5)", + " (in 'copy_fail.stan', line 45, column 4 to column 15)"}; + + +int +first_capture(const std::vector& y_i, std::ostream* pstream__) { + using local_scalar_t__ = double; + const static bool propto__ = true; + (void) propto__; + + try { + int lcm_sym33__; + int lcm_sym32__; + int lcm_sym31__; + int lcm_sym30__; + { + lcm_sym31__ = size(y_i); + if (logical_gte(lcm_sym31__, 1)) { + current_statement__ = 39; + if (y_i[(1 - 1)]) { + current_statement__ = 38; + return 1; + } + for (size_t k = 2; k <= lcm_sym31__; ++k) { + current_statement__ = 39; + if (y_i[(k - 1)]) { + current_statement__ = 38; + return k; + } } + } + current_statement__ = 50; + return 0; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct first_capture_functor__ { +int +operator()(const std::vector& y_i, std::ostream* pstream__) const +{ +return first_capture(y_i, pstream__); +} +}; + +int +last_capture(const std::vector& y_i, std::ostream* pstream__) { + using local_scalar_t__ = double; + const static bool propto__ = true; + (void) propto__; + + try { + int lcm_sym39__; + int lcm_sym38__; + int lcm_sym37__; + int lcm_sym36__; + int lcm_sym35__; + int lcm_sym34__; + { + lcm_sym37__ = (size(y_i) - 1); + if (logical_gte(lcm_sym37__, 0)) { + int k; + + lcm_sym36__ = (size(y_i) - 0); + current_statement__ = 45; + if (y_i[(lcm_sym36__ - 1)]) { + current_statement__ = 44; + return lcm_sym36__; + } + for (size_t k_rev = 1; k_rev <= lcm_sym37__; ++k_rev) { + int k; + + lcm_sym35__ = (size(y_i) - k_rev); + current_statement__ = 45; + if (y_i[(lcm_sym35__ - 1)]) { + current_statement__ = 44; + return lcm_sym35__; + } } + } + current_statement__ = 51; + return 0; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct last_capture_functor__ { +int +operator()(const std::vector& y_i, std::ostream* pstream__) const +{ +return last_capture(y_i, pstream__); +} +}; + +template +Eigen::Matrix::type, -1, -1> +prob_uncaptured(const int& nind, const int& n_occasions, + const Eigen::Matrix& p, + const Eigen::Matrix& phi, + std::ostream* pstream__) { + using local_scalar_t__ = typename boost::math::tools::promote_args::type; + const static bool propto__ = true; + (void) propto__; + + try { + double lcm_sym51__; + double lcm_sym50__; + double lcm_sym49__; + double lcm_sym48__; + double lcm_sym47__; + int lcm_sym46__; + int lcm_sym45__; + int lcm_sym44__; + int lcm_sym43__; + int lcm_sym42__; + int lcm_sym41__; + int lcm_sym40__; + { + current_statement__ = 15; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 15; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix chi; + chi = Eigen::Matrix(nind, n_occasions); + + lcm_sym41__ = logical_gte(nind, 1); + if (lcm_sym41__) { + lcm_sym40__ = logical_gte(n_occasions, 1); + if (lcm_sym40__) { + lcm_sym51__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym51__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 15; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), lcm_sym51__, + "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 15; + if (lcm_sym40__) { + lcm_sym51__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym51__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 15; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym51__, "assigning variable chi");} + } } + } + current_statement__ = 53; + if (lcm_sym41__) { + current_statement__ = 16; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(n_occasions), nil_index_list())), 1.0, + "assigning variable chi"); + lcm_sym44__ = (n_occasions - 1); + lcm_sym42__ = logical_gte(lcm_sym44__, 1); + if (lcm_sym42__) { + int t_curr; + + int t_next; + + lcm_sym46__ = (lcm_sym44__ + 1); + current_statement__ = 19; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym46__ - 1)), + nil_index_list())), "p"))), + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym46__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + "phi"))), "assigning variable chi"); + for (size_t t = 2; t <= lcm_sym44__; ++t) { + int t_curr; + + lcm_sym43__ = (n_occasions - t); + int t_next; + + lcm_sym45__ = (lcm_sym43__ + 1); + current_statement__ = 19; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym45__ - 1)), + nil_index_list())), "p"))), + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym45__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + "phi"))), "assigning variable chi");} + } + for (size_t i = 2; i <= nind; ++i) { + current_statement__ = 16; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(n_occasions), nil_index_list())), 1.0, + "assigning variable chi"); + current_statement__ = 52; + if (lcm_sym42__) { + int t_curr; + + int t_next; + + lcm_sym46__ = (lcm_sym44__ + 1); + current_statement__ = 19; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym46__ - 1)), + nil_index_list())), "p"))), + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym46__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + "phi"))), "assigning variable chi"); + for (size_t t = 2; t <= lcm_sym44__; ++t) { + int t_curr; + + lcm_sym43__ = (n_occasions - t); + int t_next; + + lcm_sym45__ = (lcm_sym43__ + 1); + current_statement__ = 19; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym45__ - 1)), + nil_index_list())), "p"))), + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym45__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + "phi"))), "assigning variable chi");} + } } + } + current_statement__ = 54; + return chi; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct prob_uncaptured_functor__ { +template +Eigen::Matrix::type, -1, -1> +operator()(const int& nind, const int& n_occasions, + const Eigen::Matrix& p, + const Eigen::Matrix& phi, std::ostream* pstream__) const +{ +return prob_uncaptured(nind, n_occasions, p, phi, pstream__); +} +}; + +class copy_fail_model : public model_base_crtp { + + private: + int lcm_sym180__; + int lcm_sym179__; + int lcm_sym178__; + int lcm_sym177__; + int lcm_sym176__; + int lcm_sym175__; + int lcm_sym174__; + int lcm_sym173__; + int lcm_sym172__; + int lcm_sym171__; + int lcm_sym170__; + int lcm_sym169__; + int lcm_sym168__; + int lcm_sym167__; + int lcm_sym166__; + int lcm_sym165__; + int lcm_sym164__; + int lcm_sym163__; + int lcm_sym162__; + int lcm_sym161__; + int lcm_sym160__; + int lcm_sym159__; + int lcm_sym158__; + int lcm_sym157__; + int lcm_sym156__; + int lcm_sym155__; + int lcm_sym154__; + int lcm_sym153__; + int lcm_sym152__; + int lcm_sym151__; + int lcm_sym150__; + int pos__; + int nind; + int n_occasions; + std::vector> y; + int max_age; + std::vector> x; + int n_occ_minus_1; + std::vector first; + std::vector last; + + public: + ~copy_fail_model() { } + + std::string model_name() const { return "copy_fail_model"; } + + copy_fail_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "copy_fail_model_namespace::copy_fail_model"; + (void) function__; // suppress unused var warning + + try { + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + pos__ = 1; + context__.validate_dims("data initialization","nind","int", + context__.to_vec()); + + current_statement__ = 30; + nind = context__.vals_i("nind")[(1 - 1)]; + context__.validate_dims("data initialization","n_occasions","int", + context__.to_vec()); + + current_statement__ = 31; + n_occasions = context__.vals_i("n_occasions")[(1 - 1)]; + current_statement__ = 32; + validate_non_negative_index("y", "nind", nind); + current_statement__ = 32; + validate_non_negative_index("y", "n_occasions", n_occasions); + context__.validate_dims("data initialization","y","int", + context__.to_vec(nind, n_occasions)); + y = std::vector>(nind, std::vector(n_occasions, 0)); + + { + std::vector y_flat__; + current_statement__ = 32; + assign(y_flat__, nil_index_list(), context__.vals_i("y"), + "assigning variable y_flat__"); + current_statement__ = 32; + pos__ = 1; + lcm_sym150__ = logical_gte(n_occasions, 1); + if (lcm_sym150__) { + { + lcm_sym151__ = logical_gte(nind, 1); + if (lcm_sym151__) { + current_statement__ = 32; + assign(y, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + y_flat__[(1 - 1)], "assigning variable y"); + current_statement__ = 32; + pos__ = 2; + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + current_statement__ = 32; + assign(y, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 32; + pos__ = (pos__ + 1);} + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 32; + if (lcm_sym151__) { + current_statement__ = 32; + assign(y, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 32; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + current_statement__ = 32; + assign(y, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 32; + pos__ = (pos__ + 1);} + } } + } + } else { + lcm_sym151__ = logical_gte(nind, 1); + } + } + context__.validate_dims("data initialization","max_age","int", + context__.to_vec()); + + current_statement__ = 33; + max_age = context__.vals_i("max_age")[(1 - 1)]; + current_statement__ = 34; + validate_non_negative_index("x", "nind", nind); + lcm_sym153__ = (n_occasions - 1); + validate_non_negative_index("x", "(n_occasions - 1)", lcm_sym153__); + context__.validate_dims("data initialization","x","int", + context__.to_vec(nind, lcm_sym153__)); + x = std::vector>(nind, std::vector(lcm_sym153__, 0)); + + { + std::vector x_flat__; + current_statement__ = 34; + assign(x_flat__, nil_index_list(), context__.vals_i("x"), + "assigning variable x_flat__"); + current_statement__ = 34; + pos__ = 1; + lcm_sym152__ = logical_gte(lcm_sym153__, 1); + if (lcm_sym152__) { + current_statement__ = 34; + if (lcm_sym151__) { + current_statement__ = 34; + assign(x, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + x_flat__[(1 - 1)], "assigning variable x"); + current_statement__ = 34; + pos__ = 2; + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + current_statement__ = 34; + assign(x, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + x_flat__[(pos__ - 1)], "assigning variable x"); + current_statement__ = 34; + pos__ = (pos__ + 1);} + } + for (size_t sym1__ = 2; sym1__ <= lcm_sym153__; ++sym1__) { + current_statement__ = 34; + if (lcm_sym151__) { + current_statement__ = 34; + assign(x, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + x_flat__[(pos__ - 1)], "assigning variable x"); + current_statement__ = 34; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + current_statement__ = 34; + assign(x, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + x_flat__[(pos__ - 1)], "assigning variable x"); + current_statement__ = 34; + pos__ = (pos__ + 1);} + } } + } + } + + current_statement__ = 35; + n_occ_minus_1 = lcm_sym153__; + current_statement__ = 36; + validate_non_negative_index("first", "nind", nind); + first = std::vector(nind, 0); + + current_statement__ = 37; + validate_non_negative_index("last", "nind", nind); + last = std::vector(nind, 0); + + current_statement__ = 42; + if (lcm_sym151__) { + int inline_sym21__; + int inline_sym23__; + + inline_sym23__ = 0; + for (size_t inline_sym24__ = 1; inline_sym24__ <= 1; ++inline_sym24__) { + lcm_sym160__ = size(y[(1 - 1)]); + for (size_t inline_sym22__ = 1; inline_sym22__ <= lcm_sym160__; + ++inline_sym22__) { + current_statement__ = 39; + if (y[(1 - 1)][(inline_sym22__ - 1)]) { + inline_sym23__ = 1; + inline_sym21__ = inline_sym22__; + break; + } } + if (inline_sym23__) { + break; + } + inline_sym23__ = 1; + inline_sym21__ = 0; + break;} + assign(first, cons_list(index_uni(1), nil_index_list()), + inline_sym21__, "assigning variable first"); + for (size_t i = 2; i <= nind; ++i) { + int inline_sym21__; + int inline_sym23__; + + inline_sym23__ = 0; + for (size_t inline_sym24__ = 1; inline_sym24__ <= 1; + ++inline_sym24__) { + lcm_sym159__ = size(y[(i - 1)]); + for (size_t inline_sym22__ = 1; inline_sym22__ <= lcm_sym159__; + ++inline_sym22__) { + current_statement__ = 39; + if (y[(i - 1)][(inline_sym22__ - 1)]) { + inline_sym23__ = 1; + inline_sym21__ = inline_sym22__; + break; + } } + if (inline_sym23__) { + break; + } + inline_sym23__ = 1; + inline_sym21__ = 0; + break;} + assign(first, cons_list(index_uni(i), nil_index_list()), + inline_sym21__, "assigning variable first");} + } + current_statement__ = 49; + if (lcm_sym151__) { + int inline_sym25__; + int inline_sym28__; + + inline_sym28__ = 0; + for (size_t inline_sym29__ = 1; inline_sym29__ <= 1; ++inline_sym29__) { + lcm_sym160__ = size(y[(1 - 1)]); + lcm_sym157__ = (lcm_sym160__ - 1); + for (size_t inline_sym27__ = 0; inline_sym27__ <= lcm_sym157__; + ++inline_sym27__) { + int inline_sym26__; + + lcm_sym156__ = (lcm_sym160__ - inline_sym27__); + inline_sym26__ = lcm_sym156__; + current_statement__ = 45; + if (y[(1 - 1)][(lcm_sym156__ - 1)]) { + inline_sym28__ = 1; + inline_sym25__ = lcm_sym156__; + break; + } } + if (inline_sym28__) { + break; + } + inline_sym28__ = 1; + inline_sym25__ = 0; + break;} + assign(last, cons_list(index_uni(1), nil_index_list()), + inline_sym25__, "assigning variable last"); + for (size_t i = 2; i <= nind; ++i) { + int inline_sym25__; + int inline_sym28__; + + inline_sym28__ = 0; + for (size_t inline_sym29__ = 1; inline_sym29__ <= 1; + ++inline_sym29__) { + lcm_sym159__ = size(y[(i - 1)]); + lcm_sym155__ = (lcm_sym159__ - 1); + for (size_t inline_sym27__ = 0; inline_sym27__ <= lcm_sym155__; + ++inline_sym27__) { + int inline_sym26__; + + lcm_sym154__ = (lcm_sym159__ - inline_sym27__); + inline_sym26__ = lcm_sym154__; + current_statement__ = 45; + if (y[(i - 1)][(lcm_sym154__ - 1)]) { + inline_sym28__ = 1; + inline_sym25__ = lcm_sym154__; + break; + } } + if (inline_sym28__) { + break; + } + inline_sym28__ = 1; + inline_sym25__ = 0; + break;} + assign(last, cons_list(index_uni(i), nil_index_list()), + inline_sym25__, "assigning variable last");} + } + current_statement__ = 30; + current_statement__ = 30; + check_greater_or_equal(function__, "nind", nind, 0); + current_statement__ = 31; + current_statement__ = 31; + check_greater_or_equal(function__, "n_occasions", n_occasions, 2); + current_statement__ = 32; + if (lcm_sym151__) { + current_statement__ = 32; + if (lcm_sym150__) { + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(sym2__ - 1)], 0);} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 32; + if (lcm_sym150__) { + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(sym2__ - 1)], 0);} + } } + } + current_statement__ = 32; + if (lcm_sym151__) { + current_statement__ = 32; + if (lcm_sym150__) { + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(sym2__ - 1)], 1);} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 32; + if (lcm_sym150__) { + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(sym2__ - 1)], 1);} + } } + } + current_statement__ = 33; + current_statement__ = 33; + check_greater_or_equal(function__, "max_age", max_age, 1); + current_statement__ = 34; + if (lcm_sym151__) { + current_statement__ = 34; + if (lcm_sym152__) { + current_statement__ = 34; + current_statement__ = 34; + check_greater_or_equal(function__, "x[sym1__, sym2__]", + x[(1 - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= lcm_sym153__; ++sym2__) { + current_statement__ = 34; + current_statement__ = 34; + check_greater_or_equal(function__, "x[sym1__, sym2__]", + x[(1 - 1)][(sym2__ - 1)], 0);} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 34; + if (lcm_sym152__) { + current_statement__ = 34; + current_statement__ = 34; + check_greater_or_equal(function__, "x[sym1__, sym2__]", + x[(sym1__ - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= lcm_sym153__; ++sym2__) { + current_statement__ = 34; + current_statement__ = 34; + check_greater_or_equal(function__, "x[sym1__, sym2__]", + x[(sym1__ - 1)][(sym2__ - 1)], 0);} + } } + } + current_statement__ = 34; + if (lcm_sym151__) { + current_statement__ = 34; + if (lcm_sym152__) { + current_statement__ = 34; + current_statement__ = 34; + check_less_or_equal(function__, "x[sym1__, sym2__]", + x[(1 - 1)][(1 - 1)], max_age); + for (size_t sym2__ = 2; sym2__ <= lcm_sym153__; ++sym2__) { + current_statement__ = 34; + current_statement__ = 34; + check_less_or_equal(function__, "x[sym1__, sym2__]", + x[(1 - 1)][(sym2__ - 1)], max_age);} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 34; + if (lcm_sym152__) { + current_statement__ = 34; + current_statement__ = 34; + check_less_or_equal(function__, "x[sym1__, sym2__]", + x[(sym1__ - 1)][(1 - 1)], max_age); + for (size_t sym2__ = 2; sym2__ <= lcm_sym153__; ++sym2__) { + current_statement__ = 34; + current_statement__ = 34; + check_less_or_equal(function__, "x[sym1__, sym2__]", + x[(sym1__ - 1)][(sym2__ - 1)], max_age);} + } } + } + current_statement__ = 36; + if (lcm_sym151__) { + current_statement__ = 36; + current_statement__ = 36; + check_greater_or_equal(function__, "first[sym1__]", first[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 36; + current_statement__ = 36; + check_greater_or_equal(function__, "first[sym1__]", + first[(sym1__ - 1)], 0);} + } + current_statement__ = 36; + if (lcm_sym151__) { + current_statement__ = 36; + current_statement__ = 36; + check_less_or_equal(function__, "first[sym1__]", first[(1 - 1)], + n_occasions); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 36; + current_statement__ = 36; + check_less_or_equal(function__, "first[sym1__]", + first[(sym1__ - 1)], n_occasions);} + } + current_statement__ = 37; + if (lcm_sym151__) { + current_statement__ = 37; + current_statement__ = 37; + check_greater_or_equal(function__, "last[sym1__]", last[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 37; + current_statement__ = 37; + check_greater_or_equal(function__, "last[sym1__]", + last[(sym1__ - 1)], 0);} + } + current_statement__ = 37; + if (lcm_sym151__) { + current_statement__ = 37; + current_statement__ = 37; + check_less_or_equal(function__, "last[sym1__]", last[(1 - 1)], + n_occasions); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 37; + current_statement__ = 37; + check_less_or_equal(function__, "last[sym1__]", last[(sym1__ - 1)], + n_occasions);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + num_params_r__ += 1; + current_statement__ = 2; + validate_non_negative_index("beta", "max_age", max_age); + num_params_r__ += max_age; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "copy_fail_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + int lcm_sym149__; + int lcm_sym148__; + int lcm_sym147__; + int lcm_sym146__; + double lcm_sym145__; + double lcm_sym144__; + double lcm_sym143__; + double lcm_sym142__; + double lcm_sym140__; + double lcm_sym138__; + double lcm_sym141__; + double lcm_sym136__; + double lcm_sym135__; + double lcm_sym134__; + double lcm_sym133__; + double lcm_sym132__; + double lcm_sym131__; + double lcm_sym130__; + double lcm_sym129__; + double lcm_sym128__; + double lcm_sym127__; + double lcm_sym126__; + double lcm_sym125__; + int lcm_sym124__; + int lcm_sym123__; + int lcm_sym122__; + int lcm_sym121__; + int lcm_sym120__; + int lcm_sym119__; + int lcm_sym118__; + int lcm_sym117__; + int lcm_sym116__; + int lcm_sym115__; + int lcm_sym114__; + int lcm_sym113__; + int lcm_sym112__; + int lcm_sym111__; + int lcm_sym110__; + int lcm_sym109__; + int lcm_sym108__; + int lcm_sym107__; + int lcm_sym106__; + int lcm_sym105__; + int lcm_sym104__; + int lcm_sym103__; + local_scalar_t__ mean_p; + + current_statement__ = 1; + mean_p = in__.scalar(); + current_statement__ = 1; + if (jacobian__) { + current_statement__ = 1; + mean_p = stan::math::lub_constrain(mean_p, 0, 1, lp__); + } else { + current_statement__ = 1; + mean_p = stan::math::lub_constrain(mean_p, 0, 1); + } + current_statement__ = 2; + validate_non_negative_index("beta", "max_age", max_age); + Eigen::Matrix beta; + beta = Eigen::Matrix(max_age); + + current_statement__ = 2; + beta = in__.vector(max_age); + current_statement__ = 2; + if (logical_gte(max_age, 1)) { + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + assign(beta, cons_list(index_uni(1), nil_index_list()), + stan::math::lub_constrain(beta[(1 - 1)], 0, 1, lp__), + "assigning variable beta"); + } else { + current_statement__ = 2; + assign(beta, cons_list(index_uni(1), nil_index_list()), + stan::math::lub_constrain(beta[(1 - 1)], 0, 1), + "assigning variable beta"); + } + for (size_t sym1__ = 2; sym1__ <= max_age; ++sym1__) { + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + assign(beta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(beta[(sym1__ - 1)], 0, 1, lp__), + "assigning variable beta"); + } else { + current_statement__ = 2; + assign(beta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(beta[(sym1__ - 1)], 0, 1), + "assigning variable beta"); + }} + } + current_statement__ = 3; + validate_non_negative_index("phi", "nind", nind); + lcm_sym116__ = (n_occasions - 1); + validate_non_negative_index("phi", "n_occ_minus_1", lcm_sym116__); + Eigen::Matrix phi; + phi = Eigen::Matrix(nind, lcm_sym116__); + + lcm_sym105__ = logical_gte(nind, 1); + if (lcm_sym105__) { + lcm_sym106__ = logical_gte(lcm_sym116__, 1); + if (lcm_sym106__) { + lcm_sym141__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym141__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym116__; ++sym2__) { + current_statement__ = 3; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym141__, "assigning variable phi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 3; + if (lcm_sym106__) { + lcm_sym141__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym141__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym116__; ++sym2__) { + current_statement__ = 3; + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym141__, "assigning variable phi");} + } } + } + current_statement__ = 4; + validate_non_negative_index("p", "nind", nind); + current_statement__ = 4; + validate_non_negative_index("p", "n_occ_minus_1", lcm_sym116__); + Eigen::Matrix p; + p = Eigen::Matrix(nind, lcm_sym116__); + + current_statement__ = 4; + if (lcm_sym105__) { + lcm_sym106__ = logical_gte(lcm_sym116__, 1); + if (lcm_sym106__) { + lcm_sym141__ = std::numeric_limits::quiet_NaN(); + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym141__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym116__; ++sym2__) { + current_statement__ = 4; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym141__, "assigning variable p");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 4; + if (lcm_sym106__) { + lcm_sym141__ = std::numeric_limits::quiet_NaN(); + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym141__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym116__; ++sym2__) { + current_statement__ = 4; + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym141__, "assigning variable p");} + } } + } + current_statement__ = 5; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 5; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix chi; + chi = Eigen::Matrix(nind, n_occasions); + + current_statement__ = 5; + if (lcm_sym105__) { + lcm_sym104__ = logical_gte(n_occasions, 1); + if (lcm_sym104__) { + lcm_sym141__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym141__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 5; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym141__, "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 5; + if (lcm_sym104__) { + lcm_sym141__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym141__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 5; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym141__, "assigning variable chi");} + } } + } + current_statement__ = 14; + if (lcm_sym105__) { + lcm_sym147__ = first[(1 - 1)]; + lcm_sym118__ = (lcm_sym147__ - 1); + if (logical_gte(lcm_sym118__, 1)) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable p"); + for (size_t t = 2; t <= lcm_sym118__; ++t) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable p");} + } + current_statement__ = 12; + if (logical_gte(lcm_sym116__, lcm_sym147__)) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym147__), nil_index_list())), + beta[(x[(1 - 1)][(lcm_sym147__ - 1)] - 1)], + "assigning variable phi"); + lcm_sym124__ = (lcm_sym147__ + 1); + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym147__), nil_index_list())), mean_p, + "assigning variable p"); + for (size_t t = lcm_sym124__; t <= lcm_sym116__; ++t) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), + beta[(x[(1 - 1)][(t - 1)] - 1)], "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), mean_p, + "assigning variable p");} + } + for (size_t i = 2; i <= nind; ++i) { + lcm_sym146__ = first[(i - 1)]; + lcm_sym117__ = (lcm_sym146__ - 1); + if (logical_gte(lcm_sym117__, 1)) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable p"); + for (size_t t = 2; t <= lcm_sym117__; ++t) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable p");} + } + current_statement__ = 12; + if (logical_gte(lcm_sym116__, lcm_sym146__)) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym146__), nil_index_list())), + beta[(x[(i - 1)][(lcm_sym146__ - 1)] - 1)], + "assigning variable phi"); + lcm_sym123__ = (lcm_sym146__ + 1); + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym146__), nil_index_list())), + mean_p, "assigning variable p"); + for (size_t t = lcm_sym123__; t <= lcm_sym116__; ++t) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), + beta[(x[(i - 1)][(t - 1)] - 1)], "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), mean_p, + "assigning variable p");} + } } + } + Eigen::Matrix inline_sym11__; + int inline_sym19__; + + inline_sym19__ = 0; + for (size_t inline_sym20__ = 1; inline_sym20__ <= 1; ++inline_sym20__) { + current_statement__ = 15; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 15; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix inline_sym12__; + inline_sym12__ = Eigen::Matrix(nind, n_occasions); + + for (size_t inline_sym14__ = 1; inline_sym14__ <= nind; + ++inline_sym14__) { + if (logical_gte(n_occasions, 1)) { + lcm_sym141__ = std::numeric_limits::quiet_NaN(); + assign(inline_sym12__, + cons_list(index_uni(inline_sym14__), + cons_list(index_uni(1), nil_index_list())), lcm_sym141__, + "assigning variable inline_sym12__"); + for (size_t inline_sym13__ = 2; inline_sym13__ <= n_occasions; + ++inline_sym13__) { + current_statement__ = 15; + assign(inline_sym12__, + cons_list(index_uni(inline_sym14__), + cons_list(index_uni(inline_sym13__), nil_index_list())), + lcm_sym141__, "assigning variable inline_sym12__");} + } + if (inline_sym19__) { + break; + } } + if (inline_sym19__) { + break; + } + for (size_t inline_sym18__ = 1; inline_sym18__ <= nind; + ++inline_sym18__) { + current_statement__ = 16; + assign(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(n_occasions), nil_index_list())), 1.0, + "assigning variable inline_sym12__"); + if (logical_gte(lcm_sym116__, 1)) { + int inline_sym15__; + + int inline_sym16__; + + lcm_sym120__ = (lcm_sym116__ + 1); + current_statement__ = 19; + assign(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym116__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym116__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni((lcm_sym120__ - 1)), + nil_index_list())), "p"))), + rvalue(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym120__), nil_index_list())), + "inline_sym12__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym116__), nil_index_list())), + "phi"))), "assigning variable inline_sym12__"); + for (size_t inline_sym17__ = 2; inline_sym17__ <= lcm_sym116__; + ++inline_sym17__) { + int inline_sym15__; + + lcm_sym115__ = (n_occasions - inline_sym17__); + int inline_sym16__; + + lcm_sym119__ = (lcm_sym115__ + 1); + current_statement__ = 19; + assign(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym115__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym115__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni((lcm_sym119__ - 1)), + nil_index_list())), "p"))), + rvalue(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym119__), nil_index_list())), + "inline_sym12__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym115__), nil_index_list())), + "phi"))), "assigning variable inline_sym12__");} + } + if (inline_sym19__) { + break; + } } + if (inline_sym19__) { + break; + } + inline_sym19__ = 1; + assign(inline_sym11__, nil_index_list(), inline_sym12__, + "assigning variable inline_sym11__"); + break;} + assign(chi, nil_index_list(), inline_sym11__, "assigning variable chi"); + current_statement__ = 3; + current_statement__ = 3; + check_greater_or_equal(function__, "phi", phi, 0); + current_statement__ = 3; + current_statement__ = 3; + check_less_or_equal(function__, "phi", phi, 1); + current_statement__ = 4; + current_statement__ = 4; + check_greater_or_equal(function__, "p", p, 0); + current_statement__ = 4; + current_statement__ = 4; + check_less_or_equal(function__, "p", p, 1); + current_statement__ = 5; + current_statement__ = 5; + check_greater_or_equal(function__, "chi", inline_sym11__, 0); + current_statement__ = 5; + current_statement__ = 5; + check_less_or_equal(function__, "chi", inline_sym11__, 1); + { + current_statement__ = 29; + if (lcm_sym105__) { + lcm_sym147__ = first[(1 - 1)]; + if (logical_gt(lcm_sym147__, 0)) { + lcm_sym149__ = last[(1 - 1)]; + lcm_sym124__ = (lcm_sym147__ + 1); + if (logical_gte(lcm_sym149__, lcm_sym124__)) { + current_statement__ = 23; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym124__ - 1)), + nil_index_list())), "phi"))); + lcm_sym122__ = (lcm_sym124__ + 1); + lp_accum__.add( + bernoulli_log(y[(1 - 1)][(lcm_sym124__ - 1)], + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym124__ - 1)), + nil_index_list())), "p"))); + for (size_t t = lcm_sym122__; t <= lcm_sym149__; ++t) { + current_statement__ = 23; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni((t - 1)), nil_index_list())), + "phi"))); + current_statement__ = 24; + lp_accum__.add( + bernoulli_log(y[(1 - 1)][(t - 1)], + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((t - 1)), nil_index_list())), + "p")));} + } + current_statement__ = 26; + lp_accum__.add( + bernoulli_log(1, + rvalue(inline_sym11__, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym149__), nil_index_list())), + "inline_sym11__"))); + } + for (size_t i = 2; i <= nind; ++i) { + lcm_sym146__ = first[(i - 1)]; + if (logical_gt(lcm_sym146__, 0)) { + lcm_sym148__ = last[(i - 1)]; + lcm_sym123__ = (lcm_sym146__ + 1); + if (logical_gte(lcm_sym148__, lcm_sym123__)) { + current_statement__ = 23; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym123__ - 1)), + nil_index_list())), "phi"))); + lcm_sym121__ = (lcm_sym123__ + 1); + lp_accum__.add( + bernoulli_log(y[(i - 1)][(lcm_sym123__ - 1)], + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym123__ - 1)), + nil_index_list())), "p"))); + for (size_t t = lcm_sym121__; t <= lcm_sym148__; ++t) { + current_statement__ = 23; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni((t - 1)), nil_index_list())), + "phi"))); + current_statement__ = 24; + lp_accum__.add( + bernoulli_log(y[(i - 1)][(t - 1)], + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((t - 1)), nil_index_list())), + "p")));} + } + current_statement__ = 26; + lp_accum__.add( + bernoulli_log(1, + rvalue(inline_sym11__, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym148__), nil_index_list())), + "inline_sym11__"))); + } } + } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "copy_fail_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + double lcm_sym102__; + double lcm_sym101__; + double lcm_sym100__; + double lcm_sym99__; + double lcm_sym98__; + double lcm_sym97__; + double lcm_sym96__; + double lcm_sym95__; + double lcm_sym94__; + double lcm_sym93__; + double lcm_sym92__; + double lcm_sym91__; + int lcm_sym90__; + int lcm_sym89__; + double lcm_sym88__; + double lcm_sym87__; + double lcm_sym86__; + double lcm_sym85__; + double lcm_sym84__; + double lcm_sym83__; + double lcm_sym82__; + double lcm_sym79__; + double lcm_sym78__; + int lcm_sym77__; + int lcm_sym76__; + int lcm_sym75__; + int lcm_sym74__; + int lcm_sym73__; + int lcm_sym72__; + int lcm_sym71__; + int lcm_sym70__; + int lcm_sym69__; + int lcm_sym68__; + int lcm_sym67__; + int lcm_sym66__; + int lcm_sym65__; + int lcm_sym64__; + int lcm_sym63__; + int lcm_sym62__; + int lcm_sym61__; + int lcm_sym60__; + double mean_p; + + current_statement__ = 1; + mean_p = in__.scalar(); + current_statement__ = 1; + mean_p = stan::math::lub_constrain(mean_p, 0, 1); + current_statement__ = 2; + validate_non_negative_index("beta", "max_age", max_age); + Eigen::Matrix beta; + beta = Eigen::Matrix(max_age); + + current_statement__ = 2; + beta = in__.vector(max_age); + lcm_sym60__ = logical_gte(max_age, 1); + if (lcm_sym60__) { + current_statement__ = 2; + assign(beta, cons_list(index_uni(1), nil_index_list()), + stan::math::lub_constrain(beta[(1 - 1)], 0, 1), + "assigning variable beta"); + for (size_t sym1__ = 2; sym1__ <= max_age; ++sym1__) { + current_statement__ = 2; + assign(beta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(beta[(sym1__ - 1)], 0, 1), + "assigning variable beta");} + } + current_statement__ = 3; + validate_non_negative_index("phi", "nind", nind); + lcm_sym69__ = (n_occasions - 1); + validate_non_negative_index("phi", "n_occ_minus_1", lcm_sym69__); + Eigen::Matrix phi; + phi = Eigen::Matrix(nind, lcm_sym69__); + + lcm_sym62__ = logical_gte(nind, 1); + if (lcm_sym62__) { + { + lcm_sym63__ = logical_gte(lcm_sym69__, 1); + if (lcm_sym63__) { + lcm_sym82__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym82__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym69__; ++sym2__) { + current_statement__ = 3; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym82__, "assigning variable phi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 3; + if (lcm_sym63__) { + lcm_sym82__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym82__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym69__; ++sym2__) { + current_statement__ = 3; + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym82__, "assigning variable phi");} + } } + } + } else { + lcm_sym63__ = logical_gte(lcm_sym69__, 1); + } + current_statement__ = 4; + validate_non_negative_index("p", "nind", nind); + current_statement__ = 4; + validate_non_negative_index("p", "n_occ_minus_1", lcm_sym69__); + Eigen::Matrix p; + p = Eigen::Matrix(nind, lcm_sym69__); + + current_statement__ = 4; + if (lcm_sym62__) { + current_statement__ = 4; + if (lcm_sym63__) { + lcm_sym82__ = std::numeric_limits::quiet_NaN(); + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym82__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym69__; ++sym2__) { + current_statement__ = 4; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), lcm_sym82__, + "assigning variable p");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 4; + if (lcm_sym63__) { + lcm_sym82__ = std::numeric_limits::quiet_NaN(); + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym82__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym69__; ++sym2__) { + current_statement__ = 4; + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym82__, "assigning variable p");} + } } + } + current_statement__ = 5; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 5; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix chi; + chi = Eigen::Matrix(nind, n_occasions); + + current_statement__ = 5; + if (lcm_sym62__) { + { + lcm_sym61__ = logical_gte(n_occasions, 1); + if (lcm_sym61__) { + lcm_sym82__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym82__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 5; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym82__, "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 5; + if (lcm_sym61__) { + lcm_sym82__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym82__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 5; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym82__, "assigning variable chi");} + } } + } + } else { + lcm_sym61__ = logical_gte(n_occasions, 1); + } + vars__.push_back(mean_p); + if (lcm_sym60__) { + vars__.push_back(beta[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= max_age; ++sym1__) { + vars__.push_back(beta[(sym1__ - 1)]);} + } + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + current_statement__ = 14; + if (lcm_sym62__) { + lcm_sym90__ = first[(1 - 1)]; + lcm_sym71__ = (lcm_sym90__ - 1); + if (logical_gte(lcm_sym71__, 1)) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable p"); + for (size_t t = 2; t <= lcm_sym71__; ++t) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable p");} + } + current_statement__ = 12; + if (logical_gte(lcm_sym69__, lcm_sym90__)) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym90__), nil_index_list())), + beta[(x[(1 - 1)][(lcm_sym90__ - 1)] - 1)], + "assigning variable phi"); + lcm_sym77__ = (lcm_sym90__ + 1); + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym90__), nil_index_list())), mean_p, + "assigning variable p"); + for (size_t t = lcm_sym77__; t <= lcm_sym69__; ++t) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), + beta[(x[(1 - 1)][(t - 1)] - 1)], "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), mean_p, + "assigning variable p");} + } + for (size_t i = 2; i <= nind; ++i) { + lcm_sym89__ = first[(i - 1)]; + lcm_sym70__ = (lcm_sym89__ - 1); + if (logical_gte(lcm_sym70__, 1)) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable p"); + for (size_t t = 2; t <= lcm_sym70__; ++t) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable p");} + } + current_statement__ = 12; + if (logical_gte(lcm_sym69__, lcm_sym89__)) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym89__), nil_index_list())), + beta[(x[(i - 1)][(lcm_sym89__ - 1)] - 1)], + "assigning variable phi"); + lcm_sym76__ = (lcm_sym89__ + 1); + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym89__), nil_index_list())), mean_p, + "assigning variable p"); + for (size_t t = lcm_sym76__; t <= lcm_sym69__; ++t) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), + beta[(x[(i - 1)][(t - 1)] - 1)], "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), mean_p, + "assigning variable p");} + } } + } + Eigen::Matrix inline_sym1__; + int inline_sym9__; + + inline_sym9__ = 0; + for (size_t inline_sym10__ = 1; inline_sym10__ <= 1; ++inline_sym10__) { + current_statement__ = 15; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 15; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix inline_sym2__; + inline_sym2__ = Eigen::Matrix(nind, n_occasions); + + for (size_t inline_sym4__ = 1; inline_sym4__ <= nind; ++inline_sym4__) { + if (lcm_sym61__) { + lcm_sym82__ = std::numeric_limits::quiet_NaN(); + assign(inline_sym2__, + cons_list(index_uni(inline_sym4__), + cons_list(index_uni(1), nil_index_list())), lcm_sym82__, + "assigning variable inline_sym2__"); + for (size_t inline_sym3__ = 2; inline_sym3__ <= n_occasions; + ++inline_sym3__) { + current_statement__ = 15; + assign(inline_sym2__, + cons_list(index_uni(inline_sym4__), + cons_list(index_uni(inline_sym3__), nil_index_list())), + lcm_sym82__, "assigning variable inline_sym2__");} + } + if (inline_sym9__) { + break; + } } + if (inline_sym9__) { + break; + } + for (size_t inline_sym8__ = 1; inline_sym8__ <= nind; ++inline_sym8__) { + current_statement__ = 16; + assign(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(n_occasions), nil_index_list())), 1.0, + "assigning variable inline_sym2__"); + if (lcm_sym63__) { + int inline_sym5__; + + int inline_sym6__; + + lcm_sym75__ = (lcm_sym69__ + 1); + current_statement__ = 19; + assign(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym69__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym69__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni((lcm_sym75__ - 1)), + nil_index_list())), "p"))), + rvalue(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym75__), nil_index_list())), + "inline_sym2__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym69__), nil_index_list())), + "phi"))), "assigning variable inline_sym2__"); + for (size_t inline_sym7__ = 2; inline_sym7__ <= lcm_sym69__; + ++inline_sym7__) { + int inline_sym5__; + + lcm_sym68__ = (n_occasions - inline_sym7__); + int inline_sym6__; + + lcm_sym74__ = (lcm_sym68__ + 1); + current_statement__ = 19; + assign(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym68__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym68__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni((lcm_sym74__ - 1)), + nil_index_list())), "p"))), + rvalue(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym74__), nil_index_list())), + "inline_sym2__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym68__), nil_index_list())), + "phi"))), "assigning variable inline_sym2__");} + } + if (inline_sym9__) { + break; + } } + if (inline_sym9__) { + break; + } + inline_sym9__ = 1; + assign(inline_sym1__, nil_index_list(), inline_sym2__, + "assigning variable inline_sym1__"); + break;} + assign(chi, nil_index_list(), inline_sym1__, "assigning variable chi"); + if (lcm_sym63__) { + if (lcm_sym62__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "phi")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), "phi"));} + } + for (size_t sym1__ = 2; sym1__ <= lcm_sym69__; ++sym1__) { + if (lcm_sym62__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), "phi")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "phi")); + } + } } + } + if (lcm_sym63__) { + if (lcm_sym62__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "p")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), "p"));} + } + for (size_t sym1__ = 2; sym1__ <= lcm_sym69__; ++sym1__) { + if (lcm_sym62__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), "p")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "p"));} + } } + } + if (lcm_sym61__) { + if (lcm_sym62__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "inline_sym1__")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + "inline_sym1__"));} + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + if (lcm_sym62__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + "inline_sym1__")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "inline_sym1__"));} + } } + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + double lcm_sym59__; + double lcm_sym58__; + double lcm_sym57__; + double lcm_sym56__; + int lcm_sym53__; + int lcm_sym52__; + int pos__; + + pos__ = 1; + double mean_p; + + current_statement__ = 1; + mean_p = context__.vals_r("mean_p")[(1 - 1)]; + current_statement__ = 1; + mean_p = stan::math::lub_free(mean_p, 0, 1); + current_statement__ = 2; + validate_non_negative_index("beta", "max_age", max_age); + Eigen::Matrix beta; + beta = Eigen::Matrix(max_age); + + { + std::vector beta_flat__; + current_statement__ = 2; + assign(beta_flat__, nil_index_list(), context__.vals_r("beta"), + "assigning variable beta_flat__"); + current_statement__ = 2; + pos__ = 1; + lcm_sym52__ = logical_gte(max_age, 1); + if (lcm_sym52__) { + current_statement__ = 2; + assign(beta, cons_list(index_uni(1), nil_index_list()), + beta_flat__[(1 - 1)], "assigning variable beta"); + current_statement__ = 2; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= max_age; ++sym1__) { + current_statement__ = 2; + assign(beta, cons_list(index_uni(sym1__), nil_index_list()), + beta_flat__[(pos__ - 1)], "assigning variable beta"); + current_statement__ = 2; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 2; + if (lcm_sym52__) { + current_statement__ = 2; + assign(beta, cons_list(index_uni(1), nil_index_list()), + stan::math::lub_free(beta[(1 - 1)], 0, 1), + "assigning variable beta"); + for (size_t sym1__ = 2; sym1__ <= max_age; ++sym1__) { + current_statement__ = 2; + assign(beta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_free(beta[(sym1__ - 1)], 0, 1), + "assigning variable beta");} + } + vars__.push_back(mean_p); + if (lcm_sym52__) { + vars__.push_back(beta[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= max_age; ++sym1__) { + vars__.push_back(beta[(sym1__ - 1)]);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("mean_p"); + names__.push_back("beta"); + names__.push_back("phi"); + names__.push_back("p"); + names__.push_back("chi"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(max_age); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(nind); + + dims__.push_back(n_occ_minus_1); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(nind); + + dims__.push_back(n_occ_minus_1); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(nind); + + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "mean_p"); + for (size_t sym181__ = 1; sym181__ <= max_age; ++sym181__) { + { + param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym181__)); + }} + if (emit_transformed_parameters__) { + for (size_t sym181__ = 1; sym181__ <= n_occ_minus_1; ++sym181__) { + { + for (size_t sym182__ = 1; sym182__ <= nind; ++sym182__) { + { + param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym182__) + '.' + std::to_string(sym181__)); + }} + }} + for (size_t sym181__ = 1; sym181__ <= n_occ_minus_1; ++sym181__) { + { + for (size_t sym182__ = 1; sym182__ <= nind; ++sym182__) { + { + param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym182__) + '.' + std::to_string(sym181__)); + }} + }} + for (size_t sym181__ = 1; sym181__ <= n_occasions; ++sym181__) { + { + for (size_t sym182__ = 1; sym182__ <= nind; ++sym182__) { + { + param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym182__) + '.' + std::to_string(sym181__)); + }} + }} + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "mean_p"); + for (size_t sym181__ = 1; sym181__ <= max_age; ++sym181__) { + { + param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym181__)); + }} + if (emit_transformed_parameters__) { + for (size_t sym181__ = 1; sym181__ <= n_occ_minus_1; ++sym181__) { + { + for (size_t sym182__ = 1; sym182__ <= nind; ++sym182__) { + { + param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym182__) + '.' + std::to_string(sym181__)); + }} + }} + for (size_t sym181__ = 1; sym181__ <= n_occ_minus_1; ++sym181__) { + { + for (size_t sym182__ = 1; sym182__ <= nind; ++sym182__) { + { + param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym182__) + '.' + std::to_string(sym181__)); + }} + }} + for (size_t sym181__ = 1; sym181__ <= n_occasions; ++sym181__) { + { + for (size_t sym182__ = 1; sym182__ <= nind; ++sym182__) { + { + param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym182__) + '.' + std::to_string(sym181__)); + }} + }} + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << max_age << "},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << max_age << "},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef copy_fail_model_namespace::copy_fail_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp dce-fail.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace dce_fail_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'dce-fail.stan', line 18, column 2 to column 22)", + " (in 'dce-fail.stan', line 19, column 2 to column 26)", + " (in 'dce-fail.stan', line 20, column 2 to column 26)", + " (in 'dce-fail.stan', line 21, column 2 to column 28)", + " (in 'dce-fail.stan', line 22, column 2 to column 29)", + " (in 'dce-fail.stan', line 23, column 2 to column 30)", + " (in 'dce-fail.stan', line 25, column 2 to column 11)", + " (in 'dce-fail.stan', line 26, column 2 to column 16)", + " (in 'dce-fail.stan', line 27, column 2 to column 15)", + " (in 'dce-fail.stan', line 28, column 2 to column 22)", + " (in 'dce-fail.stan', line 30, column 2 to column 16)", + " (in 'dce-fail.stan', line 32, column 2 to column 22)", + " (in 'dce-fail.stan', line 33, column 2 to column 22)", + " (in 'dce-fail.stan', line 34, column 2 to column 28)", + " (in 'dce-fail.stan', line 35, column 2 to column 32)", + " (in 'dce-fail.stan', line 37, column 2 to column 24)", + " (in 'dce-fail.stan', line 40, column 2 to column 14)", + " (in 'dce-fail.stan', line 41, column 2 to column 30)", + " (in 'dce-fail.stan', line 43, column 2 to column 23)", + " (in 'dce-fail.stan', line 44, column 2 to column 28)", + " (in 'dce-fail.stan', line 45, column 2 to column 27)", + " (in 'dce-fail.stan', line 46, column 2 to column 34)", + " (in 'dce-fail.stan', line 48, column 2 to column 31)", + " (in 'dce-fail.stan', line 49, column 2 to column 31)", + " (in 'dce-fail.stan', line 50, column 2 to column 37)", + " (in 'dce-fail.stan', line 54, column 6 to column 48)", + " (in 'dce-fail.stan', line 53, column 4 to line 54, column 48)", + " (in 'dce-fail.stan', line 52, column 21 to line 55, column 3)", + " (in 'dce-fail.stan', line 52, column 2 to line 55, column 3)", + " (in 'dce-fail.stan', line 57, column 2 to column 28)", + " (in 'dce-fail.stan', line 60, column 4 to column 64)", + " (in 'dce-fail.stan', line 59, column 2 to line 60, column 64)", + " (in 'dce-fail.stan', line 62, column 2 to column 43)", + " (in 'dce-fail.stan', line 65, column 4 to line 68, column 25)", + " (in 'dce-fail.stan', line 64, column 2 to line 68, column 25)", + " (in 'dce-fail.stan', line 70, column 2 to column 19)", + " (in 'dce-fail.stan', line 2, column 2 to column 17)", + " (in 'dce-fail.stan', line 3, column 2 to column 21)", + " (in 'dce-fail.stan', line 4, column 2 to column 21)", + " (in 'dce-fail.stan', line 5, column 2 to column 24)", + " (in 'dce-fail.stan', line 6, column 2 to column 23)", + " (in 'dce-fail.stan', line 8, column 2 to column 34)", + " (in 'dce-fail.stan', line 9, column 2 to column 33)", + " (in 'dce-fail.stan', line 10, column 2 to column 35)", + " (in 'dce-fail.stan', line 11, column 2 to column 35)", + " (in 'dce-fail.stan', line 12, column 2 to column 46)", + " (in 'dce-fail.stan', line 13, column 2 to column 39)", + " (in 'dce-fail.stan', line 14, column 2 to column 29)", + " (in 'dce-fail.stan', line 15, column 2 to column 25)"}; + + + +class dce_fail_model : public model_base_crtp { + + private: + int lcm_sym87__; + int lcm_sym86__; + double lcm_sym85__; + double lcm_sym84__; + int lcm_sym83__; + int lcm_sym82__; + int lcm_sym81__; + int lcm_sym80__; + int lcm_sym79__; + int lcm_sym78__; + int lcm_sym77__; + int lcm_sym76__; + int lcm_sym75__; + int lcm_sym74__; + int lcm_sym73__; + int lcm_sym72__; + int lcm_sym71__; + int lcm_sym70__; + int lcm_sym69__; + int pos__; + int N; + int n_age; + int n_edu; + int n_region; + int n_state; + std::vector female; + std::vector black; + std::vector age; + std::vector edu; + std::vector region; + std::vector state; + std::vector y; + Eigen::Matrix v_prev; + + public: + ~dce_fail_model() { } + + std::string model_name() const { return "dce_fail_model"; } + + dce_fail_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "dce_fail_model_namespace::dce_fail_model"; + (void) function__; // suppress unused var warning + + try { + + + + + + + + + + + + + + + + + + + + + pos__ = 1; + context__.validate_dims("data initialization","N","int", + context__.to_vec()); + + current_statement__ = 37; + N = context__.vals_i("N")[(1 - 1)]; + context__.validate_dims("data initialization","n_age","int", + context__.to_vec()); + + current_statement__ = 38; + n_age = context__.vals_i("n_age")[(1 - 1)]; + context__.validate_dims("data initialization","n_edu","int", + context__.to_vec()); + + current_statement__ = 39; + n_edu = context__.vals_i("n_edu")[(1 - 1)]; + context__.validate_dims("data initialization","n_region","int", + context__.to_vec()); + + current_statement__ = 40; + n_region = context__.vals_i("n_region")[(1 - 1)]; + context__.validate_dims("data initialization","n_state","int", + context__.to_vec()); + + current_statement__ = 41; + n_state = context__.vals_i("n_state")[(1 - 1)]; + current_statement__ = 42; + validate_non_negative_index("female", "N", N); + context__.validate_dims("data initialization","female","int", + context__.to_vec(N)); + female = std::vector(N, 0); + + current_statement__ = 42; + assign(female, nil_index_list(), context__.vals_i("female"), + "assigning variable female"); + current_statement__ = 43; + validate_non_negative_index("black", "N", N); + context__.validate_dims("data initialization","black","int", + context__.to_vec(N)); + black = std::vector(N, 0); + + current_statement__ = 43; + assign(black, nil_index_list(), context__.vals_i("black"), + "assigning variable black"); + current_statement__ = 44; + validate_non_negative_index("age", "N", N); + context__.validate_dims("data initialization","age","int", + context__.to_vec(N)); + age = std::vector(N, 0); + + current_statement__ = 44; + assign(age, nil_index_list(), context__.vals_i("age"), + "assigning variable age"); + current_statement__ = 45; + validate_non_negative_index("edu", "N", N); + context__.validate_dims("data initialization","edu","int", + context__.to_vec(N)); + edu = std::vector(N, 0); + + current_statement__ = 45; + assign(edu, nil_index_list(), context__.vals_i("edu"), + "assigning variable edu"); + current_statement__ = 46; + validate_non_negative_index("region", "n_state", n_state); + context__.validate_dims("data initialization","region","int", + context__.to_vec(n_state)); + region = std::vector(n_state, 0); + + current_statement__ = 46; + assign(region, nil_index_list(), context__.vals_i("region"), + "assigning variable region"); + current_statement__ = 47; + validate_non_negative_index("state", "N", N); + context__.validate_dims("data initialization","state","int", + context__.to_vec(N)); + state = std::vector(N, 0); + + current_statement__ = 47; + assign(state, nil_index_list(), context__.vals_i("state"), + "assigning variable state"); + current_statement__ = 48; + validate_non_negative_index("y", "N", N); + context__.validate_dims("data initialization","y","int", + context__.to_vec(N)); + y = std::vector(N, 0); + + current_statement__ = 48; + assign(y, nil_index_list(), context__.vals_i("y"), + "assigning variable y"); + current_statement__ = 49; + validate_non_negative_index("v_prev", "n_state", n_state); + context__.validate_dims("data initialization","v_prev","double", + context__.to_vec(n_state)); + v_prev = Eigen::Matrix(n_state); + + { + std::vector v_prev_flat__; + current_statement__ = 49; + assign(v_prev_flat__, nil_index_list(), context__.vals_r("v_prev"), + "assigning variable v_prev_flat__"); + current_statement__ = 49; + pos__ = 1; + lcm_sym70__ = logical_gte(n_state, 1); + if (lcm_sym70__) { + current_statement__ = 49; + assign(v_prev, cons_list(index_uni(1), nil_index_list()), + v_prev_flat__[(1 - 1)], "assigning variable v_prev"); + current_statement__ = 49; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= n_state; ++sym1__) { + current_statement__ = 49; + assign(v_prev, cons_list(index_uni(sym1__), nil_index_list()), + v_prev_flat__[(pos__ - 1)], "assigning variable v_prev"); + current_statement__ = 49; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 37; + current_statement__ = 37; + check_greater_or_equal(function__, "N", N, 0); + current_statement__ = 38; + current_statement__ = 38; + check_greater_or_equal(function__, "n_age", n_age, 0); + current_statement__ = 39; + current_statement__ = 39; + check_greater_or_equal(function__, "n_edu", n_edu, 0); + current_statement__ = 40; + current_statement__ = 40; + check_greater_or_equal(function__, "n_region", n_region, 0); + current_statement__ = 41; + current_statement__ = 41; + check_greater_or_equal(function__, "n_state", n_state, 0); + lcm_sym69__ = logical_gte(N, 1); + if (lcm_sym69__) { + current_statement__ = 42; + current_statement__ = 42; + check_greater_or_equal(function__, "female[sym1__]", female[(1 - 1)], + 0); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 42; + current_statement__ = 42; + check_greater_or_equal(function__, "female[sym1__]", + female[(sym1__ - 1)], 0);} + } + current_statement__ = 42; + if (lcm_sym69__) { + current_statement__ = 42; + current_statement__ = 42; + check_less_or_equal(function__, "female[sym1__]", female[(1 - 1)], 1); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 42; + current_statement__ = 42; + check_less_or_equal(function__, "female[sym1__]", + female[(sym1__ - 1)], 1);} + } + current_statement__ = 43; + if (lcm_sym69__) { + current_statement__ = 43; + current_statement__ = 43; + check_greater_or_equal(function__, "black[sym1__]", black[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 43; + current_statement__ = 43; + check_greater_or_equal(function__, "black[sym1__]", + black[(sym1__ - 1)], 0);} + } + current_statement__ = 43; + if (lcm_sym69__) { + current_statement__ = 43; + current_statement__ = 43; + check_less_or_equal(function__, "black[sym1__]", black[(1 - 1)], 1); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 43; + current_statement__ = 43; + check_less_or_equal(function__, "black[sym1__]", + black[(sym1__ - 1)], 1);} + } + current_statement__ = 44; + if (lcm_sym69__) { + current_statement__ = 44; + current_statement__ = 44; + check_greater_or_equal(function__, "age[sym1__]", age[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 44; + current_statement__ = 44; + check_greater_or_equal(function__, "age[sym1__]", + age[(sym1__ - 1)], 0);} + } + current_statement__ = 44; + if (lcm_sym69__) { + current_statement__ = 44; + current_statement__ = 44; + check_less_or_equal(function__, "age[sym1__]", age[(1 - 1)], n_age); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 44; + current_statement__ = 44; + check_less_or_equal(function__, "age[sym1__]", age[(sym1__ - 1)], + n_age);} + } + current_statement__ = 45; + if (lcm_sym69__) { + current_statement__ = 45; + current_statement__ = 45; + check_greater_or_equal(function__, "edu[sym1__]", edu[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 45; + current_statement__ = 45; + check_greater_or_equal(function__, "edu[sym1__]", + edu[(sym1__ - 1)], 0);} + } + current_statement__ = 45; + if (lcm_sym69__) { + current_statement__ = 45; + current_statement__ = 45; + check_less_or_equal(function__, "edu[sym1__]", edu[(1 - 1)], n_edu); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 45; + current_statement__ = 45; + check_less_or_equal(function__, "edu[sym1__]", edu[(sym1__ - 1)], + n_edu);} + } + current_statement__ = 46; + if (lcm_sym70__) { + current_statement__ = 46; + current_statement__ = 46; + check_greater_or_equal(function__, "region[sym1__]", region[(1 - 1)], + 0); + for (size_t sym1__ = 2; sym1__ <= n_state; ++sym1__) { + current_statement__ = 46; + current_statement__ = 46; + check_greater_or_equal(function__, "region[sym1__]", + region[(sym1__ - 1)], 0);} + } + current_statement__ = 46; + if (lcm_sym70__) { + current_statement__ = 46; + current_statement__ = 46; + check_less_or_equal(function__, "region[sym1__]", region[(1 - 1)], + n_state); + for (size_t sym1__ = 2; sym1__ <= n_state; ++sym1__) { + current_statement__ = 46; + current_statement__ = 46; + check_less_or_equal(function__, "region[sym1__]", + region[(sym1__ - 1)], n_state);} + } + current_statement__ = 47; + if (lcm_sym69__) { + current_statement__ = 47; + current_statement__ = 47; + check_greater_or_equal(function__, "state[sym1__]", state[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 47; + current_statement__ = 47; + check_greater_or_equal(function__, "state[sym1__]", + state[(sym1__ - 1)], 0);} + } + current_statement__ = 47; + if (lcm_sym69__) { + current_statement__ = 47; + current_statement__ = 47; + check_less_or_equal(function__, "state[sym1__]", state[(1 - 1)], + n_state); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 47; + current_statement__ = 47; + check_less_or_equal(function__, "state[sym1__]", + state[(sym1__ - 1)], n_state);} + } + current_statement__ = 48; + if (lcm_sym69__) { + current_statement__ = 48; + current_statement__ = 48; + check_greater_or_equal(function__, "y[sym1__]", y[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 48; + current_statement__ = 48; + check_greater_or_equal(function__, "y[sym1__]", y[(sym1__ - 1)], 0); + } + } + current_statement__ = 48; + if (lcm_sym69__) { + current_statement__ = 48; + current_statement__ = 48; + check_less_or_equal(function__, "y[sym1__]", y[(1 - 1)], 1); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 48; + current_statement__ = 48; + check_less_or_equal(function__, "y[sym1__]", y[(sym1__ - 1)], 1);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + current_statement__ = 12; + validate_non_negative_index("b_age", "n_age", n_age); + num_params_r__ += n_age; + current_statement__ = 13; + validate_non_negative_index("b_edu", "n_edu", n_edu); + num_params_r__ += n_edu; + current_statement__ = 14; + validate_non_negative_index("b_region", "n_region", n_region); + num_params_r__ += n_region; + current_statement__ = 15; + validate_non_negative_index("b_age_edu", "n_age", n_age); + current_statement__ = 15; + validate_non_negative_index("b_age_edu", "n_edu", n_edu); + num_params_r__ += n_age * n_edu; + current_statement__ = 16; + validate_non_negative_index("b_hat", "n_state", n_state); + num_params_r__ += n_state; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "dce_fail_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + double lcm_sym68__; + double lcm_sym67__; + double lcm_sym66__; + double lcm_sym65__; + double lcm_sym64__; + double lcm_sym63__; + double lcm_sym62__; + double lcm_sym61__; + double lcm_sym60__; + double lcm_sym59__; + double lcm_sym58__; + double lcm_sym57__; + double lcm_sym56__; + double lcm_sym55__; + double lcm_sym54__; + double lcm_sym53__; + double lcm_sym52__; + double lcm_sym51__; + double lcm_sym50__; + int lcm_sym49__; + int lcm_sym48__; + int lcm_sym47__; + int lcm_sym46__; + local_scalar_t__ sigma; + + current_statement__ = 1; + sigma = in__.scalar(); + current_statement__ = 1; + if (jacobian__) { + current_statement__ = 1; + sigma = stan::math::lb_constrain(sigma, 0, lp__); + } else { + current_statement__ = 1; + sigma = stan::math::lb_constrain(sigma, 0); + } + local_scalar_t__ sigma_age; + + current_statement__ = 2; + sigma_age = in__.scalar(); + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + sigma_age = stan::math::lb_constrain(sigma_age, 0, lp__); + } else { + current_statement__ = 2; + sigma_age = stan::math::lb_constrain(sigma_age, 0); + } + local_scalar_t__ sigma_edu; + + current_statement__ = 3; + sigma_edu = in__.scalar(); + current_statement__ = 3; + if (jacobian__) { + current_statement__ = 3; + sigma_edu = stan::math::lb_constrain(sigma_edu, 0, lp__); + } else { + current_statement__ = 3; + sigma_edu = stan::math::lb_constrain(sigma_edu, 0); + } + local_scalar_t__ sigma_state; + + current_statement__ = 4; + sigma_state = in__.scalar(); + current_statement__ = 4; + if (jacobian__) { + current_statement__ = 4; + sigma_state = stan::math::lb_constrain(sigma_state, 0, lp__); + } else { + current_statement__ = 4; + sigma_state = stan::math::lb_constrain(sigma_state, 0); + } + local_scalar_t__ sigma_region; + + current_statement__ = 5; + sigma_region = in__.scalar(); + current_statement__ = 5; + if (jacobian__) { + current_statement__ = 5; + sigma_region = stan::math::lb_constrain(sigma_region, 0, lp__); + } else { + current_statement__ = 5; + sigma_region = stan::math::lb_constrain(sigma_region, 0); + } + local_scalar_t__ sigma_age_edu; + + current_statement__ = 6; + sigma_age_edu = in__.scalar(); + current_statement__ = 6; + if (jacobian__) { + current_statement__ = 6; + sigma_age_edu = stan::math::lb_constrain(sigma_age_edu, 0, lp__); + } else { + current_statement__ = 6; + sigma_age_edu = stan::math::lb_constrain(sigma_age_edu, 0); + } + local_scalar_t__ b_0; + + current_statement__ = 7; + b_0 = in__.scalar(); + local_scalar_t__ b_female; + + current_statement__ = 8; + b_female = in__.scalar(); + local_scalar_t__ b_black; + + current_statement__ = 9; + b_black = in__.scalar(); + local_scalar_t__ b_female_black; + + current_statement__ = 10; + b_female_black = in__.scalar(); + local_scalar_t__ b_v_prev; + + current_statement__ = 11; + b_v_prev = in__.scalar(); + current_statement__ = 12; + validate_non_negative_index("b_age", "n_age", n_age); + Eigen::Matrix b_age; + b_age = Eigen::Matrix(n_age); + + current_statement__ = 12; + b_age = in__.vector(n_age); + current_statement__ = 13; + validate_non_negative_index("b_edu", "n_edu", n_edu); + Eigen::Matrix b_edu; + b_edu = Eigen::Matrix(n_edu); + + current_statement__ = 13; + b_edu = in__.vector(n_edu); + current_statement__ = 14; + validate_non_negative_index("b_region", "n_region", n_region); + Eigen::Matrix b_region; + b_region = Eigen::Matrix(n_region); + + current_statement__ = 14; + b_region = in__.vector(n_region); + current_statement__ = 15; + validate_non_negative_index("b_age_edu", "n_age", n_age); + current_statement__ = 15; + validate_non_negative_index("b_age_edu", "n_edu", n_edu); + Eigen::Matrix b_age_edu; + b_age_edu = Eigen::Matrix(n_age, n_edu); + + current_statement__ = 15; + b_age_edu = in__.matrix(n_age, n_edu); + current_statement__ = 16; + validate_non_negative_index("b_hat", "n_state", n_state); + Eigen::Matrix b_hat; + b_hat = Eigen::Matrix(n_state); + + current_statement__ = 16; + b_hat = in__.vector(n_state); + { + current_statement__ = 17; + validate_non_negative_index("p", "N", N); + Eigen::Matrix p; + p = Eigen::Matrix(N); + + lcm_sym46__ = logical_gte(N, 1); + if (lcm_sym46__) { + lcm_sym68__ = std::numeric_limits::quiet_NaN(); + assign(p, cons_list(index_uni(1), nil_index_list()), lcm_sym68__, + "assigning variable p"); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 17; + assign(p, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym68__, "assigning variable p");} + } + current_statement__ = 18; + validate_non_negative_index("b_state_hat", "n_state", n_state); + Eigen::Matrix b_state_hat; + b_state_hat = Eigen::Matrix(n_state); + + lcm_sym49__ = logical_gte(n_state, 1); + if (lcm_sym49__) { + lcm_sym68__ = std::numeric_limits::quiet_NaN(); + assign(b_state_hat, cons_list(index_uni(1), nil_index_list()), + lcm_sym68__, "assigning variable b_state_hat"); + for (size_t sym1__ = 2; sym1__ <= n_state; ++sym1__) { + current_statement__ = 18; + assign(b_state_hat, + cons_list(index_uni(sym1__), nil_index_list()), lcm_sym68__, + "assigning variable b_state_hat");} + } + current_statement__ = 19; + lp_accum__.add(normal_log(b_0, 0, 100)); + current_statement__ = 20; + lp_accum__.add(normal_log(b_female, 0, 100)); + current_statement__ = 21; + lp_accum__.add(normal_log(b_black, 0, 100)); + current_statement__ = 22; + lp_accum__.add(normal_log(b_female_black, 0, 100)); + current_statement__ = 23; + lp_accum__.add(normal_log(b_age, 0, sigma_age)); + current_statement__ = 24; + lp_accum__.add(normal_log(b_edu, 0, sigma_edu)); + current_statement__ = 25; + lp_accum__.add(normal_log(b_region, 0, sigma_region)); + current_statement__ = 29; + if (logical_gte(n_age, 1)) { + lcm_sym48__ = logical_gte(n_edu, 1); + if (lcm_sym48__) { + current_statement__ = 26; + lp_accum__.add( + normal_log( + rvalue(b_age_edu, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "b_age_edu"), + 0, sigma_age_edu)); + for (size_t i = 2; i <= n_edu; ++i) { + current_statement__ = 26; + lp_accum__.add( + normal_log( + rvalue(b_age_edu, + cons_list(index_uni(1), + cons_list(index_uni(i), nil_index_list())), + "b_age_edu"), 0, sigma_age_edu));} + } + for (size_t j = 2; j <= n_age; ++j) { + current_statement__ = 27; + if (lcm_sym48__) { + current_statement__ = 26; + lp_accum__.add( + normal_log( + rvalue(b_age_edu, + cons_list(index_uni(j), + cons_list(index_uni(1), nil_index_list())), + "b_age_edu"), 0, sigma_age_edu)); + for (size_t i = 2; i <= n_edu; ++i) { + current_statement__ = 26; + lp_accum__.add( + normal_log( + rvalue(b_age_edu, + cons_list(index_uni(j), + cons_list(index_uni(i), nil_index_list())), + "b_age_edu"), 0, sigma_age_edu));} + } } + } + current_statement__ = 30; + lp_accum__.add(normal_log(b_v_prev, 0, 100)); + current_statement__ = 32; + if (lcm_sym49__) { + current_statement__ = 31; + assign(b_state_hat, cons_list(index_uni(1), nil_index_list()), + stan::math::fma(b_v_prev, v_prev[(1 - 1)], + b_region[(region[(1 - 1)] - 1)]), + "assigning variable b_state_hat"); + for (size_t j = 2; j <= n_state; ++j) { + current_statement__ = 31; + assign(b_state_hat, cons_list(index_uni(j), nil_index_list()), + stan::math::fma(b_v_prev, v_prev[(j - 1)], + b_region[(region[(j - 1)] - 1)]), + "assigning variable b_state_hat");} + } + current_statement__ = 33; + lp_accum__.add(normal_log(b_hat, b_state_hat, sigma_state)); + current_statement__ = 35; + if (lcm_sym46__) { + current_statement__ = 34; + assign(p, cons_list(index_uni(1), nil_index_list()), + stan::math::fmax(0, + stan::math::fmin(1, + inv_logit( + ((((stan::math::fma((b_female_black * female[(1 - 1)]), + black[(1 - 1)], + stan::math::fma(b_black, black[(1 - 1)], + stan::math::fma(b_female, female[(1 - 1)], b_0))) + + b_age[(age[(1 - 1)] - 1)]) + + b_edu[(edu[(1 - 1)] - 1)]) + + rvalue(b_age_edu, + cons_list(index_uni(age[(1 - 1)]), + cons_list(index_uni(edu[(1 - 1)]), nil_index_list())), + "b_age_edu")) + b_hat[(state[(1 - 1)] - 1)])))), + "assigning variable p"); + for (size_t i = 2; i <= N; ++i) { + current_statement__ = 34; + assign(p, cons_list(index_uni(i), nil_index_list()), + stan::math::fmax(0, + stan::math::fmin(1, + inv_logit( + ((((stan::math::fma((b_female_black * female[(i - 1)]), + black[(i - 1)], + stan::math::fma(b_black, black[(i - 1)], + stan::math::fma(b_female, female[(i - 1)], b_0))) + + b_age[(age[(i - 1)] - 1)]) + + b_edu[(edu[(i - 1)] - 1)]) + + rvalue(b_age_edu, + cons_list(index_uni(age[(i - 1)]), + cons_list(index_uni(edu[(i - 1)]), + nil_index_list())), "b_age_edu")) + + b_hat[(state[(i - 1)] - 1)])))), "assigning variable p"); + } + } + current_statement__ = 36; + lp_accum__.add(bernoulli_log(y, p)); + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "dce_fail_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + double lcm_sym45__; + double lcm_sym44__; + double lcm_sym43__; + double lcm_sym42__; + double lcm_sym41__; + double lcm_sym40__; + double lcm_sym39__; + double lcm_sym38__; + double lcm_sym37__; + double lcm_sym36__; + double lcm_sym35__; + double lcm_sym34__; + int lcm_sym33__; + int lcm_sym32__; + int lcm_sym31__; + int lcm_sym30__; + int lcm_sym29__; + int lcm_sym28__; + double sigma; + + current_statement__ = 1; + sigma = in__.scalar(); + current_statement__ = 1; + sigma = stan::math::lb_constrain(sigma, 0); + double sigma_age; + + current_statement__ = 2; + sigma_age = in__.scalar(); + current_statement__ = 2; + sigma_age = stan::math::lb_constrain(sigma_age, 0); + double sigma_edu; + + current_statement__ = 3; + sigma_edu = in__.scalar(); + current_statement__ = 3; + sigma_edu = stan::math::lb_constrain(sigma_edu, 0); + double sigma_state; + + current_statement__ = 4; + sigma_state = in__.scalar(); + current_statement__ = 4; + sigma_state = stan::math::lb_constrain(sigma_state, 0); + double sigma_region; + + current_statement__ = 5; + sigma_region = in__.scalar(); + current_statement__ = 5; + sigma_region = stan::math::lb_constrain(sigma_region, 0); + double sigma_age_edu; + + current_statement__ = 6; + sigma_age_edu = in__.scalar(); + current_statement__ = 6; + sigma_age_edu = stan::math::lb_constrain(sigma_age_edu, 0); + double b_0; + + current_statement__ = 7; + b_0 = in__.scalar(); + double b_female; + + current_statement__ = 8; + b_female = in__.scalar(); + double b_black; + + current_statement__ = 9; + b_black = in__.scalar(); + double b_female_black; + + current_statement__ = 10; + b_female_black = in__.scalar(); + double b_v_prev; + + current_statement__ = 11; + b_v_prev = in__.scalar(); + current_statement__ = 12; + validate_non_negative_index("b_age", "n_age", n_age); + Eigen::Matrix b_age; + b_age = Eigen::Matrix(n_age); + + current_statement__ = 12; + b_age = in__.vector(n_age); + current_statement__ = 13; + validate_non_negative_index("b_edu", "n_edu", n_edu); + Eigen::Matrix b_edu; + b_edu = Eigen::Matrix(n_edu); + + current_statement__ = 13; + b_edu = in__.vector(n_edu); + current_statement__ = 14; + validate_non_negative_index("b_region", "n_region", n_region); + Eigen::Matrix b_region; + b_region = Eigen::Matrix(n_region); + + current_statement__ = 14; + b_region = in__.vector(n_region); + current_statement__ = 15; + validate_non_negative_index("b_age_edu", "n_age", n_age); + current_statement__ = 15; + validate_non_negative_index("b_age_edu", "n_edu", n_edu); + Eigen::Matrix b_age_edu; + b_age_edu = Eigen::Matrix(n_age, n_edu); + + current_statement__ = 15; + b_age_edu = in__.matrix(n_age, n_edu); + current_statement__ = 16; + validate_non_negative_index("b_hat", "n_state", n_state); + Eigen::Matrix b_hat; + b_hat = Eigen::Matrix(n_state); + + current_statement__ = 16; + b_hat = in__.vector(n_state); + vars__.push_back(sigma); + vars__.push_back(sigma_age); + vars__.push_back(sigma_edu); + vars__.push_back(sigma_state); + vars__.push_back(sigma_region); + vars__.push_back(sigma_age_edu); + vars__.push_back(b_0); + vars__.push_back(b_female); + vars__.push_back(b_black); + vars__.push_back(b_female_black); + vars__.push_back(b_v_prev); + lcm_sym28__ = logical_gte(n_age, 1); + if (lcm_sym28__) { + vars__.push_back(b_age[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_age; ++sym1__) { + vars__.push_back(b_age[(sym1__ - 1)]);} + } + lcm_sym29__ = logical_gte(n_edu, 1); + if (lcm_sym29__) { + vars__.push_back(b_edu[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_edu; ++sym1__) { + vars__.push_back(b_edu[(sym1__ - 1)]);} + } + if (logical_gte(n_region, 1)) { + vars__.push_back(b_region[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_region; ++sym1__) { + vars__.push_back(b_region[(sym1__ - 1)]);} + } + if (lcm_sym29__) { + if (lcm_sym28__) { + vars__.push_back( + rvalue(b_age_edu, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "b_age_edu")); + for (size_t sym2__ = 2; sym2__ <= n_age; ++sym2__) { + vars__.push_back( + rvalue(b_age_edu, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), "b_age_edu"));} + } + for (size_t sym1__ = 2; sym1__ <= n_edu; ++sym1__) { + if (lcm_sym28__) { + vars__.push_back( + rvalue(b_age_edu, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + "b_age_edu")); + for (size_t sym2__ = 2; sym2__ <= n_age; ++sym2__) { + vars__.push_back( + rvalue(b_age_edu, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "b_age_edu"));} + } } + } + if (logical_gte(n_state, 1)) { + vars__.push_back(b_hat[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_state; ++sym1__) { + vars__.push_back(b_hat[(sym1__ - 1)]);} + } + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + double lcm_sym27__; + double lcm_sym26__; + double lcm_sym25__; + double lcm_sym24__; + double lcm_sym23__; + double lcm_sym22__; + double lcm_sym21__; + double lcm_sym20__; + double lcm_sym19__; + double lcm_sym18__; + double lcm_sym17__; + double lcm_sym16__; + double lcm_sym15__; + double lcm_sym14__; + double lcm_sym13__; + double lcm_sym12__; + double lcm_sym11__; + double lcm_sym10__; + double lcm_sym9__; + double lcm_sym8__; + double lcm_sym7__; + double lcm_sym6__; + int lcm_sym5__; + int lcm_sym4__; + int lcm_sym3__; + int lcm_sym2__; + int lcm_sym1__; + int pos__; + + pos__ = 1; + double sigma; + + current_statement__ = 1; + sigma = context__.vals_r("sigma")[(1 - 1)]; + current_statement__ = 1; + sigma = stan::math::lb_free(sigma, 0); + double sigma_age; + + current_statement__ = 2; + sigma_age = context__.vals_r("sigma_age")[(1 - 1)]; + current_statement__ = 2; + sigma_age = stan::math::lb_free(sigma_age, 0); + double sigma_edu; + + current_statement__ = 3; + sigma_edu = context__.vals_r("sigma_edu")[(1 - 1)]; + current_statement__ = 3; + sigma_edu = stan::math::lb_free(sigma_edu, 0); + double sigma_state; + + current_statement__ = 4; + sigma_state = context__.vals_r("sigma_state")[(1 - 1)]; + current_statement__ = 4; + sigma_state = stan::math::lb_free(sigma_state, 0); + double sigma_region; + + current_statement__ = 5; + sigma_region = context__.vals_r("sigma_region")[(1 - 1)]; + current_statement__ = 5; + sigma_region = stan::math::lb_free(sigma_region, 0); + double sigma_age_edu; + + current_statement__ = 6; + sigma_age_edu = context__.vals_r("sigma_age_edu")[(1 - 1)]; + current_statement__ = 6; + sigma_age_edu = stan::math::lb_free(sigma_age_edu, 0); + double b_0; + + current_statement__ = 7; + b_0 = context__.vals_r("b_0")[(1 - 1)]; + double b_female; + + current_statement__ = 8; + b_female = context__.vals_r("b_female")[(1 - 1)]; + double b_black; + + current_statement__ = 9; + b_black = context__.vals_r("b_black")[(1 - 1)]; + double b_female_black; + + current_statement__ = 10; + b_female_black = context__.vals_r("b_female_black")[(1 - 1)]; + double b_v_prev; + + current_statement__ = 11; + b_v_prev = context__.vals_r("b_v_prev")[(1 - 1)]; + current_statement__ = 12; + validate_non_negative_index("b_age", "n_age", n_age); + Eigen::Matrix b_age; + b_age = Eigen::Matrix(n_age); + + { + std::vector b_age_flat__; + current_statement__ = 12; + assign(b_age_flat__, nil_index_list(), context__.vals_r("b_age"), + "assigning variable b_age_flat__"); + current_statement__ = 12; + pos__ = 1; + lcm_sym1__ = logical_gte(n_age, 1); + if (lcm_sym1__) { + current_statement__ = 12; + assign(b_age, cons_list(index_uni(1), nil_index_list()), + b_age_flat__[(1 - 1)], "assigning variable b_age"); + current_statement__ = 12; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= n_age; ++sym1__) { + current_statement__ = 12; + assign(b_age, cons_list(index_uni(sym1__), nil_index_list()), + b_age_flat__[(pos__ - 1)], "assigning variable b_age"); + current_statement__ = 12; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 13; + validate_non_negative_index("b_edu", "n_edu", n_edu); + Eigen::Matrix b_edu; + b_edu = Eigen::Matrix(n_edu); + + { + std::vector b_edu_flat__; + current_statement__ = 13; + assign(b_edu_flat__, nil_index_list(), context__.vals_r("b_edu"), + "assigning variable b_edu_flat__"); + current_statement__ = 13; + pos__ = 1; + lcm_sym2__ = logical_gte(n_edu, 1); + if (lcm_sym2__) { + current_statement__ = 13; + assign(b_edu, cons_list(index_uni(1), nil_index_list()), + b_edu_flat__[(1 - 1)], "assigning variable b_edu"); + current_statement__ = 13; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= n_edu; ++sym1__) { + current_statement__ = 13; + assign(b_edu, cons_list(index_uni(sym1__), nil_index_list()), + b_edu_flat__[(pos__ - 1)], "assigning variable b_edu"); + current_statement__ = 13; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 14; + validate_non_negative_index("b_region", "n_region", n_region); + Eigen::Matrix b_region; + b_region = Eigen::Matrix(n_region); + + { + std::vector b_region_flat__; + current_statement__ = 14; + assign(b_region_flat__, nil_index_list(), + context__.vals_r("b_region"), "assigning variable b_region_flat__"); + current_statement__ = 14; + pos__ = 1; + lcm_sym3__ = logical_gte(n_region, 1); + if (lcm_sym3__) { + current_statement__ = 14; + assign(b_region, cons_list(index_uni(1), nil_index_list()), + b_region_flat__[(1 - 1)], "assigning variable b_region"); + current_statement__ = 14; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= n_region; ++sym1__) { + current_statement__ = 14; + assign(b_region, cons_list(index_uni(sym1__), nil_index_list()), + b_region_flat__[(pos__ - 1)], "assigning variable b_region"); + current_statement__ = 14; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 15; + validate_non_negative_index("b_age_edu", "n_age", n_age); + current_statement__ = 15; + validate_non_negative_index("b_age_edu", "n_edu", n_edu); + Eigen::Matrix b_age_edu; + b_age_edu = Eigen::Matrix(n_age, n_edu); + + { + std::vector b_age_edu_flat__; + current_statement__ = 15; + assign(b_age_edu_flat__, nil_index_list(), + context__.vals_r("b_age_edu"), + "assigning variable b_age_edu_flat__"); + current_statement__ = 15; + pos__ = 1; + current_statement__ = 15; + if (lcm_sym2__) { + current_statement__ = 15; + if (lcm_sym1__) { + current_statement__ = 15; + assign(b_age_edu, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + b_age_edu_flat__[(1 - 1)], "assigning variable b_age_edu"); + current_statement__ = 15; + pos__ = 2; + for (size_t sym2__ = 2; sym2__ <= n_age; ++sym2__) { + current_statement__ = 15; + assign(b_age_edu, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + b_age_edu_flat__[(pos__ - 1)], "assigning variable b_age_edu"); + current_statement__ = 15; + pos__ = (pos__ + 1);} + } + for (size_t sym1__ = 2; sym1__ <= n_edu; ++sym1__) { + current_statement__ = 15; + if (lcm_sym1__) { + current_statement__ = 15; + assign(b_age_edu, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + b_age_edu_flat__[(pos__ - 1)], "assigning variable b_age_edu"); + current_statement__ = 15; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= n_age; ++sym2__) { + current_statement__ = 15; + assign(b_age_edu, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + b_age_edu_flat__[(pos__ - 1)], + "assigning variable b_age_edu"); + current_statement__ = 15; + pos__ = (pos__ + 1);} + } } + } + } + current_statement__ = 16; + validate_non_negative_index("b_hat", "n_state", n_state); + Eigen::Matrix b_hat; + b_hat = Eigen::Matrix(n_state); + + { + std::vector b_hat_flat__; + current_statement__ = 16; + assign(b_hat_flat__, nil_index_list(), context__.vals_r("b_hat"), + "assigning variable b_hat_flat__"); + current_statement__ = 16; + pos__ = 1; + lcm_sym4__ = logical_gte(n_state, 1); + if (lcm_sym4__) { + current_statement__ = 16; + assign(b_hat, cons_list(index_uni(1), nil_index_list()), + b_hat_flat__[(1 - 1)], "assigning variable b_hat"); + current_statement__ = 16; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= n_state; ++sym1__) { + current_statement__ = 16; + assign(b_hat, cons_list(index_uni(sym1__), nil_index_list()), + b_hat_flat__[(pos__ - 1)], "assigning variable b_hat"); + current_statement__ = 16; + pos__ = (pos__ + 1);} + } + } + vars__.push_back(sigma); + vars__.push_back(sigma_age); + vars__.push_back(sigma_edu); + vars__.push_back(sigma_state); + vars__.push_back(sigma_region); + vars__.push_back(sigma_age_edu); + vars__.push_back(b_0); + vars__.push_back(b_female); + vars__.push_back(b_black); + vars__.push_back(b_female_black); + vars__.push_back(b_v_prev); + if (lcm_sym1__) { + vars__.push_back(b_age[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_age; ++sym1__) { + vars__.push_back(b_age[(sym1__ - 1)]);} + } + if (lcm_sym2__) { + vars__.push_back(b_edu[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_edu; ++sym1__) { + vars__.push_back(b_edu[(sym1__ - 1)]);} + } + if (lcm_sym3__) { + vars__.push_back(b_region[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_region; ++sym1__) { + vars__.push_back(b_region[(sym1__ - 1)]);} + } + if (lcm_sym2__) { + if (lcm_sym1__) { + vars__.push_back( + rvalue(b_age_edu, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "b_age_edu")); + for (size_t sym2__ = 2; sym2__ <= n_age; ++sym2__) { + vars__.push_back( + rvalue(b_age_edu, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), "b_age_edu"));} + } + for (size_t sym1__ = 2; sym1__ <= n_edu; ++sym1__) { + if (lcm_sym1__) { + vars__.push_back( + rvalue(b_age_edu, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + "b_age_edu")); + for (size_t sym2__ = 2; sym2__ <= n_age; ++sym2__) { + vars__.push_back( + rvalue(b_age_edu, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "b_age_edu"));} + } } + } + if (lcm_sym4__) { + vars__.push_back(b_hat[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_state; ++sym1__) { + vars__.push_back(b_hat[(sym1__ - 1)]);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("sigma"); + names__.push_back("sigma_age"); + names__.push_back("sigma_edu"); + names__.push_back("sigma_state"); + names__.push_back("sigma_region"); + names__.push_back("sigma_age_edu"); + names__.push_back("b_0"); + names__.push_back("b_female"); + names__.push_back("b_black"); + names__.push_back("b_female_black"); + names__.push_back("b_v_prev"); + names__.push_back("b_age"); + names__.push_back("b_edu"); + names__.push_back("b_region"); + names__.push_back("b_age_edu"); + names__.push_back("b_hat"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_age); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_edu); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_region); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_age); + + dims__.push_back(n_edu); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_state); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "sigma"); + param_names__.push_back(std::string() + "sigma_age"); + param_names__.push_back(std::string() + "sigma_edu"); + param_names__.push_back(std::string() + "sigma_state"); + param_names__.push_back(std::string() + "sigma_region"); + param_names__.push_back(std::string() + "sigma_age_edu"); + param_names__.push_back(std::string() + "b_0"); + param_names__.push_back(std::string() + "b_female"); + param_names__.push_back(std::string() + "b_black"); + param_names__.push_back(std::string() + "b_female_black"); + param_names__.push_back(std::string() + "b_v_prev"); + for (size_t sym88__ = 1; sym88__ <= n_age; ++sym88__) { + { + param_names__.push_back(std::string() + "b_age" + '.' + std::to_string(sym88__)); + }} + for (size_t sym88__ = 1; sym88__ <= n_edu; ++sym88__) { + { + param_names__.push_back(std::string() + "b_edu" + '.' + std::to_string(sym88__)); + }} + for (size_t sym88__ = 1; sym88__ <= n_region; ++sym88__) { + { + param_names__.push_back(std::string() + "b_region" + '.' + std::to_string(sym88__)); + }} + for (size_t sym88__ = 1; sym88__ <= n_edu; ++sym88__) { + { + for (size_t sym89__ = 1; sym89__ <= n_age; ++sym89__) { + { + param_names__.push_back(std::string() + "b_age_edu" + '.' + std::to_string(sym89__) + '.' + std::to_string(sym88__)); + }} + }} + for (size_t sym88__ = 1; sym88__ <= n_state; ++sym88__) { + { + param_names__.push_back(std::string() + "b_hat" + '.' + std::to_string(sym88__)); + }} + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "sigma"); + param_names__.push_back(std::string() + "sigma_age"); + param_names__.push_back(std::string() + "sigma_edu"); + param_names__.push_back(std::string() + "sigma_state"); + param_names__.push_back(std::string() + "sigma_region"); + param_names__.push_back(std::string() + "sigma_age_edu"); + param_names__.push_back(std::string() + "b_0"); + param_names__.push_back(std::string() + "b_female"); + param_names__.push_back(std::string() + "b_black"); + param_names__.push_back(std::string() + "b_female_black"); + param_names__.push_back(std::string() + "b_v_prev"); + for (size_t sym88__ = 1; sym88__ <= n_age; ++sym88__) { + { + param_names__.push_back(std::string() + "b_age" + '.' + std::to_string(sym88__)); + }} + for (size_t sym88__ = 1; sym88__ <= n_edu; ++sym88__) { + { + param_names__.push_back(std::string() + "b_edu" + '.' + std::to_string(sym88__)); + }} + for (size_t sym88__ = 1; sym88__ <= n_region; ++sym88__) { + { + param_names__.push_back(std::string() + "b_region" + '.' + std::to_string(sym88__)); + }} + for (size_t sym88__ = 1; sym88__ <= n_edu; ++sym88__) { + { + for (size_t sym89__ = 1; sym89__ <= n_age; ++sym89__) { + { + param_names__.push_back(std::string() + "b_age_edu" + '.' + std::to_string(sym89__) + '.' + std::to_string(sym88__)); + }} + }} + for (size_t sym88__ = 1; sym88__ <= n_state; ++sym88__) { + { + param_names__.push_back(std::string() + "b_hat" + '.' + std::to_string(sym88__)); + }} + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_age\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_edu\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_state\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_region\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_age_edu\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_0\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_female\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_black\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_female_black\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_v_prev\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_age\",\"type\":{\"name\":\"vector\",\"length\":" << n_age << "},\"block\":\"parameters\"},{\"name\":\"b_edu\",\"type\":{\"name\":\"vector\",\"length\":" << n_edu << "},\"block\":\"parameters\"},{\"name\":\"b_region\",\"type\":{\"name\":\"vector\",\"length\":" << n_region << "},\"block\":\"parameters\"},{\"name\":\"b_age_edu\",\"type\":{\"name\":\"matrix\",\"rows\":" << n_age << ",\"cols\":" << n_edu << "},\"block\":\"parameters\"},{\"name\":\"b_hat\",\"type\":{\"name\":\"vector\",\"length\":" << n_state << "},\"block\":\"parameters\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_age\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_edu\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_state\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_region\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_age_edu\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_0\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_female\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_black\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_female_black\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_v_prev\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_age\",\"type\":{\"name\":\"vector\",\"length\":" << n_age << "},\"block\":\"parameters\"},{\"name\":\"b_edu\",\"type\":{\"name\":\"vector\",\"length\":" << n_edu << "},\"block\":\"parameters\"},{\"name\":\"b_region\",\"type\":{\"name\":\"vector\",\"length\":" << n_region << "},\"block\":\"parameters\"},{\"name\":\"b_age_edu\",\"type\":{\"name\":\"matrix\",\"rows\":" << n_age << ",\"cols\":" << n_edu << "},\"block\":\"parameters\"},{\"name\":\"b_hat\",\"type\":{\"name\":\"vector\",\"length\":" << n_state << "},\"block\":\"parameters\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef dce_fail_model_namespace::dce_fail_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-experiment.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace expr_prop_experiment_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'expr-prop-experiment.stan', line 2, column 2 to column 8)", + " (in 'expr-prop-experiment.stan', line 5, column 2 to column 9)", + " (in 'expr-prop-experiment.stan', line 6, column 2 to column 9)", + " (in 'expr-prop-experiment.stan', line 7, column 2 to column 9)", + " (in 'expr-prop-experiment.stan', line 8, column 2 to column 28)", + " (in 'expr-prop-experiment.stan', line 10, column 2 to column 23)", + " (in 'expr-prop-experiment.stan', line 11, column 2 to column 23)", + " (in 'expr-prop-experiment.stan', line 12, column 2 to column 23)"}; + + + +class expr_prop_experiment_model : public model_base_crtp { + + private: + double lcm_sym5__; + double lcm_sym4__; + int pos__; + int j; + double z; + double x; + double y; + double i; + + public: + ~expr_prop_experiment_model() { } + + std::string model_name() const { return "expr_prop_experiment_model"; } + + expr_prop_experiment_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "expr_prop_experiment_model_namespace::expr_prop_experiment_model"; + (void) function__; // suppress unused var warning + + try { + + + + pos__ = 1; + context__.validate_dims("data initialization","j","int", + context__.to_vec()); + + current_statement__ = 1; + j = context__.vals_i("j")[(1 - 1)]; + + lcm_sym5__ = std::numeric_limits::quiet_NaN(); + z = lcm_sym5__; + + current_statement__ = 3; + x = lcm_sym5__; + + current_statement__ = 4; + y = lcm_sym5__; + + current_statement__ = 5; + i = lcm_sym5__; + current_statement__ = 5; + i = normal_rng(5, 1, base_rng__); + lcm_sym4__ = (i * j); + z = lcm_sym4__; + current_statement__ = 6; + x = normal_rng(lcm_sym4__, 1, base_rng__); + current_statement__ = 7; + i = normal_rng(5, 1, base_rng__); + current_statement__ = 8; + y = normal_rng(z, 1, base_rng__); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "expr_prop_experiment_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "expr_prop_experiment_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + int lcm_sym2__; + int lcm_sym1__; + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + int pos__; + + pos__ = 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} + +typedef expr_prop_experiment_model_namespace::expr_prop_experiment_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-experiment2.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace expr_prop_experiment2_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'expr-prop-experiment2.stan', line 2, column 2 to column 8)", + " (in 'expr-prop-experiment2.stan', line 5, column 2 to column 13)", + " (in 'expr-prop-experiment2.stan', line 6, column 2 to column 9)", + " (in 'expr-prop-experiment2.stan', line 8, column 4 to column 32)", + " (in 'expr-prop-experiment2.stan', line 10, column 4 to column 25)", + " (in 'expr-prop-experiment2.stan', line 7, column 2 to line 11, column 3)", + " (in 'expr-prop-experiment2.stan', line 12, column 2 to column 23)"}; + + + +class expr_prop_experiment2_model : public model_base_crtp { + + private: + double lcm_sym5__; + double lcm_sym4__; + int pos__; + int j; + double z; + double y; + + public: + ~expr_prop_experiment2_model() { } + + std::string model_name() const { return "expr_prop_experiment2_model"; } + + expr_prop_experiment2_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "expr_prop_experiment2_model_namespace::expr_prop_experiment2_model"; + (void) function__; // suppress unused var warning + + try { + + + + pos__ = 1; + context__.validate_dims("data initialization","j","int", + context__.to_vec()); + + current_statement__ = 1; + j = context__.vals_i("j")[(1 - 1)]; + + lcm_sym5__ = std::numeric_limits::quiet_NaN(); + z = lcm_sym5__; + current_statement__ = 2; + z = 1; + + current_statement__ = 3; + y = lcm_sym5__; + { + double x; + + current_statement__ = 4; + x = lcm_sym5__; + current_statement__ = 4; + x = normal_rng(123, 1, base_rng__); + lcm_sym4__ = (x * 2); + z = lcm_sym4__; + current_statement__ = 5; + y = normal_rng(lcm_sym4__, 1, base_rng__); + } + current_statement__ = 7; + y = normal_rng(z, 1, base_rng__); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "expr_prop_experiment2_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "expr_prop_experiment2_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + int lcm_sym2__; + int lcm_sym1__; + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + int pos__; + + pos__ = 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} + +typedef expr_prop_experiment2_model_namespace::expr_prop_experiment2_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-fail.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace expr_prop_fail_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'expr-prop-fail.stan', line 7, column 2 to column 16)", + " (in 'expr-prop-fail.stan', line 8, column 2 to column 25)", + " (in 'expr-prop-fail.stan', line 9, column 2 to column 31)", + " (in 'expr-prop-fail.stan', line 13, column 1 to column 22)", + " (in 'expr-prop-fail.stan', line 14, column 1 to column 19)", + " (in 'expr-prop-fail.stan', line 15, column 1 to column 20)", + " (in 'expr-prop-fail.stan', line 17, column 3 to line 19, column 58)", + " (in 'expr-prop-fail.stan', line 16, column 1 to line 19, column 58)", + " (in 'expr-prop-fail.stan', line 2, column 1 to column 18)", + " (in 'expr-prop-fail.stan', line 3, column 1 to column 13)"}; + + + +class expr_prop_fail_model : public model_base_crtp { + + private: + double lcm_sym31__; + double lcm_sym30__; + int lcm_sym29__; + int lcm_sym28__; + int pos__; + int N; + Eigen::Matrix y; + + public: + ~expr_prop_fail_model() { } + + std::string model_name() const { return "expr_prop_fail_model"; } + + expr_prop_fail_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "expr_prop_fail_model_namespace::expr_prop_fail_model"; + (void) function__; // suppress unused var warning + + try { + + + + + + pos__ = 1; + context__.validate_dims("data initialization","N","int", + context__.to_vec()); + + current_statement__ = 9; + N = context__.vals_i("N")[(1 - 1)]; + current_statement__ = 10; + validate_non_negative_index("y", "N", N); + context__.validate_dims("data initialization","y","double", + context__.to_vec(N)); + y = Eigen::Matrix(N); + + { + std::vector y_flat__; + current_statement__ = 10; + assign(y_flat__, nil_index_list(), context__.vals_r("y"), + "assigning variable y_flat__"); + current_statement__ = 10; + pos__ = 1; + current_statement__ = 10; + if (logical_gte(N, 1)) { + current_statement__ = 10; + assign(y, cons_list(index_uni(1), nil_index_list()), + y_flat__[(1 - 1)], "assigning variable y"); + current_statement__ = 10; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 10; + assign(y, cons_list(index_uni(sym1__), nil_index_list()), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 10; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 9; + current_statement__ = 9; + check_greater_or_equal(function__, "N", N, 0); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + current_statement__ = 1; + validate_non_negative_index("mu", "2", 2); + num_params_r__ += 2; + current_statement__ = 2; + validate_non_negative_index("sigma", "2", 2); + num_params_r__ += 2; + num_params_r__ += 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "expr_prop_fail_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + local_scalar_t__ lcm_sym27__; + double lcm_sym25__; + double lcm_sym23__; + double lcm_sym22__; + double lcm_sym21__; + double lcm_sym20__; + double lcm_sym19__; + int lcm_sym18__; + current_statement__ = 1; + validate_non_negative_index("mu", "2", 2); + Eigen::Matrix mu; + mu = Eigen::Matrix(2); + + current_statement__ = 1; + mu = in__.vector(2); + current_statement__ = 1; + if (jacobian__) { + current_statement__ = 1; + assign(mu, nil_index_list(), stan::math::ordered_constrain(mu, lp__), + "assigning variable mu"); + } else { + current_statement__ = 1; + assign(mu, nil_index_list(), stan::math::ordered_constrain(mu), + "assigning variable mu"); + } + current_statement__ = 2; + validate_non_negative_index("sigma", "2", 2); + std::vector sigma; + sigma = std::vector(2, 0); + + { + current_statement__ = 2; + assign(sigma, cons_list(index_uni(1), nil_index_list()), + in__.scalar(), "assigning variable sigma"); + { + current_statement__ = 2; + assign(sigma, cons_list(index_uni(2), nil_index_list()), + in__.scalar(), "assigning variable sigma"); + } + } + { + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + assign(sigma, cons_list(index_uni(1), nil_index_list()), + stan::math::lb_constrain(sigma[(1 - 1)], 0, lp__), + "assigning variable sigma"); + } else { + current_statement__ = 2; + assign(sigma, cons_list(index_uni(1), nil_index_list()), + stan::math::lb_constrain(sigma[(1 - 1)], 0), + "assigning variable sigma"); + } + { + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + assign(sigma, cons_list(index_uni(2), nil_index_list()), + stan::math::lb_constrain(sigma[(2 - 1)], 0, lp__), + "assigning variable sigma"); + } else { + current_statement__ = 2; + assign(sigma, cons_list(index_uni(2), nil_index_list()), + stan::math::lb_constrain(sigma[(2 - 1)], 0), + "assigning variable sigma"); + } + } + } + local_scalar_t__ theta; + + current_statement__ = 3; + theta = in__.scalar(); + current_statement__ = 3; + if (jacobian__) { + current_statement__ = 3; + theta = stan::math::lub_constrain(theta, 0, 1, lp__); + } else { + current_statement__ = 3; + theta = stan::math::lub_constrain(theta, 0, 1); + } + { + current_statement__ = 4; + lp_accum__.add(normal_log(sigma, 0, 2)); + current_statement__ = 5; + lp_accum__.add(normal_log(mu, 0, 2)); + current_statement__ = 6; + lp_accum__.add(beta_log(theta, 5, 5)); + current_statement__ = 8; + if (logical_gte(N, 1)) { + lcm_sym27__ = sigma[(1 - 1)]; + lp_accum__.add( + log_mix(theta, + normal_lpdf(y[(1 - 1)], mu[(1 - 1)], lcm_sym27__), + normal_lpdf(y[(1 - 1)], mu[(2 - 1)], sigma[(2 - 1)]))); + for (size_t n = 2; n <= N; ++n) { + current_statement__ = 7; + lp_accum__.add( + log_mix(theta, + normal_lpdf(y[(n - 1)], mu[(1 - 1)], lcm_sym27__), + normal_lpdf(y[(n - 1)], mu[(2 - 1)], sigma[(2 - 1)]))); + } + } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "expr_prop_fail_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + double lcm_sym17__; + double lcm_sym16__; + double lcm_sym15__; + double lcm_sym14__; + int lcm_sym11__; + int lcm_sym10__; + current_statement__ = 1; + validate_non_negative_index("mu", "2", 2); + Eigen::Matrix mu; + mu = Eigen::Matrix(2); + + current_statement__ = 1; + mu = in__.vector(2); + current_statement__ = 1; + assign(mu, nil_index_list(), stan::math::ordered_constrain(mu), + "assigning variable mu"); + current_statement__ = 2; + validate_non_negative_index("sigma", "2", 2); + std::vector sigma; + sigma = std::vector(2, 0); + + { + current_statement__ = 2; + assign(sigma, cons_list(index_uni(1), nil_index_list()), + in__.scalar(), "assigning variable sigma"); + { + current_statement__ = 2; + assign(sigma, cons_list(index_uni(2), nil_index_list()), + in__.scalar(), "assigning variable sigma"); + } + } + { + current_statement__ = 2; + assign(sigma, cons_list(index_uni(1), nil_index_list()), + stan::math::lb_constrain(sigma[(1 - 1)], 0), + "assigning variable sigma"); + { + current_statement__ = 2; + assign(sigma, cons_list(index_uni(2), nil_index_list()), + stan::math::lb_constrain(sigma[(2 - 1)], 0), + "assigning variable sigma"); + } + } + double theta; + + current_statement__ = 3; + theta = in__.scalar(); + current_statement__ = 3; + theta = stan::math::lub_constrain(theta, 0, 1); + { + vars__.push_back(mu[(1 - 1)]); + { + vars__.push_back(mu[(2 - 1)]); + } + } + { + vars__.push_back(sigma[(1 - 1)]); + { + vars__.push_back(sigma[(2 - 1)]); + } + } + vars__.push_back(theta); + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + double lcm_sym9__; + double lcm_sym8__; + double lcm_sym7__; + double lcm_sym6__; + double lcm_sym5__; + double lcm_sym4__; + int lcm_sym1__; + int pos__; + + pos__ = 1; + current_statement__ = 1; + validate_non_negative_index("mu", "2", 2); + Eigen::Matrix mu; + mu = Eigen::Matrix(2); + + { + std::vector mu_flat__; + current_statement__ = 1; + assign(mu_flat__, nil_index_list(), context__.vals_r("mu"), + "assigning variable mu_flat__"); + current_statement__ = 1; + pos__ = 1; + { + current_statement__ = 1; + assign(mu, cons_list(index_uni(1), nil_index_list()), + mu_flat__[(1 - 1)], "assigning variable mu"); + current_statement__ = 1; + pos__ = 2; + { + current_statement__ = 1; + assign(mu, cons_list(index_uni(2), nil_index_list()), + mu_flat__[(pos__ - 1)], "assigning variable mu"); + current_statement__ = 1; + pos__ = (pos__ + 1); + } + } + } + current_statement__ = 1; + assign(mu, nil_index_list(), stan::math::ordered_free(mu), + "assigning variable mu"); + current_statement__ = 2; + validate_non_negative_index("sigma", "2", 2); + std::vector sigma; + sigma = std::vector(2, 0); + + current_statement__ = 2; + assign(sigma, nil_index_list(), context__.vals_r("sigma"), + "assigning variable sigma"); + { + current_statement__ = 2; + assign(sigma, cons_list(index_uni(1), nil_index_list()), + stan::math::lb_free(sigma[(1 - 1)], 0), "assigning variable sigma"); + { + current_statement__ = 2; + assign(sigma, cons_list(index_uni(2), nil_index_list()), + stan::math::lb_free(sigma[(2 - 1)], 0), + "assigning variable sigma"); + } + } + double theta; + + current_statement__ = 3; + theta = context__.vals_r("theta")[(1 - 1)]; + current_statement__ = 3; + theta = stan::math::lub_free(theta, 0, 1); + { + vars__.push_back(mu[(1 - 1)]); + { + vars__.push_back(mu[(2 - 1)]); + } + } + { + vars__.push_back(sigma[(1 - 1)]); + { + vars__.push_back(sigma[(2 - 1)]); + } + } + vars__.push_back(theta); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("mu"); + names__.push_back("sigma"); + names__.push_back("theta"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dims__.push_back(2); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(2); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + for (size_t sym32__ = 1; sym32__ <= 2; ++sym32__) { + { + param_names__.push_back(std::string() + "mu" + '.' + std::to_string(sym32__)); + }} + for (size_t sym32__ = 1; sym32__ <= 2; ++sym32__) { + { + param_names__.push_back(std::string() + "sigma" + '.' + std::to_string(sym32__)); + }} + param_names__.push_back(std::string() + "theta"); + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + for (size_t sym32__ = 1; sym32__ <= 2; ++sym32__) { + { + param_names__.push_back(std::string() + "mu" + '.' + std::to_string(sym32__)); + }} + for (size_t sym32__ = 1; sym32__ <= 2; ++sym32__) { + { + param_names__.push_back(std::string() + "sigma" + '.' + std::to_string(sym32__)); + }} + param_names__.push_back(std::string() + "theta"); + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mu\",\"type\":{\"name\":\"vector\",\"length\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"array\",\"length\":" << 2 << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mu\",\"type\":{\"name\":\"vector\",\"length\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"array\",\"length\":" << 2 << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef expr_prop_fail_model_namespace::expr_prop_fail_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-fail2.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace expr_prop_fail2_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'expr-prop-fail2.stan', line 7, column 2 to column 10)", + " (in 'expr-prop-fail2.stan', line 8, column 2 to column 16)", + " (in 'expr-prop-fail2.stan', line 9, column 2 to column 20)", + " (in 'expr-prop-fail2.stan', line 12, column 2 to column 26)", + " (in 'expr-prop-fail2.stan', line 13, column 2 to column 26)", + " (in 'expr-prop-fail2.stan', line 2, column 2 to column 17)", + " (in 'expr-prop-fail2.stan', line 3, column 2 to column 12)", + " (in 'expr-prop-fail2.stan', line 4, column 2 to column 25)"}; + + + +class expr_prop_fail2_model : public model_base_crtp { + + private: + double lcm_sym14__; + double lcm_sym13__; + int lcm_sym12__; + int pos__; + int J; + std::vector y; + std::vector sigma; + + public: + ~expr_prop_fail2_model() { } + + std::string model_name() const { return "expr_prop_fail2_model"; } + + expr_prop_fail2_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "expr_prop_fail2_model_namespace::expr_prop_fail2_model"; + (void) function__; // suppress unused var warning + + try { + + + + + pos__ = 1; + context__.validate_dims("data initialization","J","int", + context__.to_vec()); + + current_statement__ = 6; + J = context__.vals_i("J")[(1 - 1)]; + current_statement__ = 7; + validate_non_negative_index("y", "J", J); + context__.validate_dims("data initialization","y","double", + context__.to_vec(J)); + y = std::vector(J, 0); + + current_statement__ = 7; + assign(y, nil_index_list(), context__.vals_r("y"), + "assigning variable y"); + current_statement__ = 8; + validate_non_negative_index("sigma", "J", J); + context__.validate_dims("data initialization","sigma","double", + context__.to_vec(J)); + sigma = std::vector(J, 0); + + current_statement__ = 8; + assign(sigma, nil_index_list(), context__.vals_r("sigma"), + "assigning variable sigma"); + current_statement__ = 6; + current_statement__ = 6; + check_greater_or_equal(function__, "J", J, 0); + current_statement__ = 8; + if (logical_gte(J, 1)) { + current_statement__ = 8; + current_statement__ = 8; + check_greater_or_equal(function__, "sigma[sym1__]", sigma[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + current_statement__ = 8; + current_statement__ = 8; + check_greater_or_equal(function__, "sigma[sym1__]", + sigma[(sym1__ - 1)], 0);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + num_params_r__ += 1; + current_statement__ = 2; + validate_non_negative_index("theta", "J", J); + num_params_r__ += J; + num_params_r__ += 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "expr_prop_fail2_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + double lcm_sym11__; + double lcm_sym10__; + int lcm_sym9__; + local_scalar_t__ mu; + + current_statement__ = 1; + mu = in__.scalar(); + current_statement__ = 2; + validate_non_negative_index("theta", "J", J); + std::vector theta; + theta = std::vector(J, 0); + + current_statement__ = 2; + if (logical_gte(J, 1)) { + current_statement__ = 2; + assign(theta, cons_list(index_uni(1), nil_index_list()), + in__.scalar(), "assigning variable theta"); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + current_statement__ = 2; + assign(theta, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable theta");} + } + local_scalar_t__ tau; + + current_statement__ = 3; + tau = in__.scalar(); + current_statement__ = 3; + if (jacobian__) { + current_statement__ = 3; + tau = stan::math::lb_constrain(tau, 0, lp__); + } else { + current_statement__ = 3; + tau = stan::math::lb_constrain(tau, 0); + } + { + current_statement__ = 4; + lp_accum__.add(normal_log(theta, mu, tau)); + current_statement__ = 5; + lp_accum__.add(normal_log(y, theta, sigma)); + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "expr_prop_fail2_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + double lcm_sym8__; + double lcm_sym7__; + int lcm_sym6__; + int lcm_sym5__; + int lcm_sym4__; + double mu; + + current_statement__ = 1; + mu = in__.scalar(); + current_statement__ = 2; + validate_non_negative_index("theta", "J", J); + std::vector theta; + theta = std::vector(J, 0); + + lcm_sym4__ = logical_gte(J, 1); + if (lcm_sym4__) { + current_statement__ = 2; + assign(theta, cons_list(index_uni(1), nil_index_list()), + in__.scalar(), "assigning variable theta"); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + current_statement__ = 2; + assign(theta, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable theta");} + } + double tau; + + current_statement__ = 3; + tau = in__.scalar(); + current_statement__ = 3; + tau = stan::math::lb_constrain(tau, 0); + vars__.push_back(mu); + if (lcm_sym4__) { + vars__.push_back(theta[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + vars__.push_back(theta[(sym1__ - 1)]);} + } + vars__.push_back(tau); + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + double lcm_sym3__; + double lcm_sym2__; + int lcm_sym1__; + int pos__; + + pos__ = 1; + double mu; + + current_statement__ = 1; + mu = context__.vals_r("mu")[(1 - 1)]; + current_statement__ = 2; + validate_non_negative_index("theta", "J", J); + std::vector theta; + theta = std::vector(J, 0); + + current_statement__ = 2; + assign(theta, nil_index_list(), context__.vals_r("theta"), + "assigning variable theta"); + double tau; + + current_statement__ = 3; + tau = context__.vals_r("tau")[(1 - 1)]; + current_statement__ = 3; + tau = stan::math::lb_free(tau, 0); + vars__.push_back(mu); + if (logical_gte(J, 1)) { + vars__.push_back(theta[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + vars__.push_back(theta[(sym1__ - 1)]);} + } + vars__.push_back(tau); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("mu"); + names__.push_back("theta"); + names__.push_back("tau"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(J); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "mu"); + for (size_t sym15__ = 1; sym15__ <= J; ++sym15__) { + { + param_names__.push_back(std::string() + "theta" + '.' + std::to_string(sym15__)); + }} + param_names__.push_back(std::string() + "tau"); + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "mu"); + for (size_t sym15__ = 1; sym15__ <= J; ++sym15__) { + { + param_names__.push_back(std::string() + "theta" + '.' + std::to_string(sym15__)); + }} + param_names__.push_back(std::string() + "tau"); + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mu\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"array\",\"length\":" << J << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"tau\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mu\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"array\",\"length\":" << J << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"tau\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef expr_prop_fail2_model_namespace::expr_prop_fail2_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-fail3.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace expr_prop_fail3_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'expr-prop-fail3.stan', line 19, column 2 to column 18)", + " (in 'expr-prop-fail3.stan', line 20, column 2 to column 18)", + " (in 'expr-prop-fail3.stan', line 21, column 2 to column 22)", + " (in 'expr-prop-fail3.stan', line 22, column 2 to column 20)", + " (in 'expr-prop-fail3.stan', line 23, column 2 to column 26)", + " (in 'expr-prop-fail3.stan', line 24, column 2 to column 17)", + " (in 'expr-prop-fail3.stan', line 25, column 2 to column 34)", + " (in 'expr-prop-fail3.stan', line 26, column 2 to column 34)", + " (in 'expr-prop-fail3.stan', line 27, column 2 to column 34)", + " (in 'expr-prop-fail3.stan', line 28, column 2 to column 34)", + " (in 'expr-prop-fail3.stan', line 29, column 2 to column 34)", + " (in 'expr-prop-fail3.stan', line 32, column 2 to column 18)", + " (in 'expr-prop-fail3.stan', line 35, column 4 to line 38, column 66)", + " (in 'expr-prop-fail3.stan', line 34, column 2 to line 38, column 66)", + " (in 'expr-prop-fail3.stan', line 41, column 2 to column 26)", + " (in 'expr-prop-fail3.stan', line 42, column 2 to column 26)", + " (in 'expr-prop-fail3.stan', line 43, column 2 to column 26)", + " (in 'expr-prop-fail3.stan', line 44, column 2 to column 26)", + " (in 'expr-prop-fail3.stan', line 45, column 2 to column 26)", + " (in 'expr-prop-fail3.stan', line 46, column 2 to column 24)", + " (in 'expr-prop-fail3.stan', line 47, column 2 to column 29)", + " (in 'expr-prop-fail3.stan', line 2, column 2 to column 17)", + " (in 'expr-prop-fail3.stan', line 3, column 2 to column 21)", + " (in 'expr-prop-fail3.stan', line 4, column 2 to column 25)", + " (in 'expr-prop-fail3.stan', line 5, column 2 to column 21)", + " (in 'expr-prop-fail3.stan', line 6, column 2 to column 29)", + " (in 'expr-prop-fail3.stan', line 7, column 2 to column 23)", + " (in 'expr-prop-fail3.stan', line 8, column 2 to column 34)", + " (in 'expr-prop-fail3.stan', line 9, column 2 to column 42)", + " (in 'expr-prop-fail3.stan', line 10, column 2 to column 35)", + " (in 'expr-prop-fail3.stan', line 11, column 2 to column 34)", + " (in 'expr-prop-fail3.stan', line 12, column 2 to column 36)", + " (in 'expr-prop-fail3.stan', line 13, column 2 to column 50)", + " (in 'expr-prop-fail3.stan', line 14, column 2 to column 38)", + " (in 'expr-prop-fail3.stan', line 15, column 2 to column 24)", + " (in 'expr-prop-fail3.stan', line 16, column 2 to column 28)"}; + + + +class expr_prop_fail3_model : public model_base_crtp { + + private: + int lcm_sym86__; + int lcm_sym85__; + double lcm_sym84__; + double lcm_sym83__; + int lcm_sym82__; + int lcm_sym81__; + int lcm_sym80__; + int lcm_sym79__; + double lcm_sym78__; + double lcm_sym77__; + int lcm_sym76__; + int lcm_sym75__; + double lcm_sym74__; + double lcm_sym73__; + int lcm_sym72__; + int lcm_sym71__; + int lcm_sym70__; + int lcm_sym69__; + int lcm_sym68__; + int lcm_sym67__; + int pos__; + int N; + int n_age; + int n_age_edu; + int n_edu; + int n_region_full; + int n_state; + std::vector age; + std::vector age_edu; + Eigen::Matrix black; + std::vector edu; + Eigen::Matrix female; + std::vector region_full; + std::vector state; + Eigen::Matrix v_prev_full; + std::vector y; + + public: + ~expr_prop_fail3_model() { } + + std::string model_name() const { return "expr_prop_fail3_model"; } + + expr_prop_fail3_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "expr_prop_fail3_model_namespace::expr_prop_fail3_model"; + (void) function__; // suppress unused var warning + + try { + + + + + + + + + + + + + + + + + + + + + + pos__ = 1; + context__.validate_dims("data initialization","N","int", + context__.to_vec()); + + current_statement__ = 22; + N = context__.vals_i("N")[(1 - 1)]; + context__.validate_dims("data initialization","n_age","int", + context__.to_vec()); + + current_statement__ = 23; + n_age = context__.vals_i("n_age")[(1 - 1)]; + context__.validate_dims("data initialization","n_age_edu","int", + context__.to_vec()); + + current_statement__ = 24; + n_age_edu = context__.vals_i("n_age_edu")[(1 - 1)]; + context__.validate_dims("data initialization","n_edu","int", + context__.to_vec()); + + current_statement__ = 25; + n_edu = context__.vals_i("n_edu")[(1 - 1)]; + context__.validate_dims("data initialization","n_region_full","int", + context__.to_vec()); + + current_statement__ = 26; + n_region_full = context__.vals_i("n_region_full")[(1 - 1)]; + context__.validate_dims("data initialization","n_state","int", + context__.to_vec()); + + current_statement__ = 27; + n_state = context__.vals_i("n_state")[(1 - 1)]; + current_statement__ = 28; + validate_non_negative_index("age", "N", N); + context__.validate_dims("data initialization","age","int", + context__.to_vec(N)); + age = std::vector(N, 0); + + current_statement__ = 28; + assign(age, nil_index_list(), context__.vals_i("age"), + "assigning variable age"); + current_statement__ = 29; + validate_non_negative_index("age_edu", "N", N); + context__.validate_dims("data initialization","age_edu","int", + context__.to_vec(N)); + age_edu = std::vector(N, 0); + + current_statement__ = 29; + assign(age_edu, nil_index_list(), context__.vals_i("age_edu"), + "assigning variable age_edu"); + current_statement__ = 30; + validate_non_negative_index("black", "N", N); + context__.validate_dims("data initialization","black","double", + context__.to_vec(N)); + black = Eigen::Matrix(N); + + { + std::vector black_flat__; + current_statement__ = 30; + assign(black_flat__, nil_index_list(), context__.vals_r("black"), + "assigning variable black_flat__"); + current_statement__ = 30; + pos__ = 1; + lcm_sym67__ = logical_gte(N, 1); + if (lcm_sym67__) { + current_statement__ = 30; + assign(black, cons_list(index_uni(1), nil_index_list()), + black_flat__[(1 - 1)], "assigning variable black"); + current_statement__ = 30; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 30; + assign(black, cons_list(index_uni(sym1__), nil_index_list()), + black_flat__[(pos__ - 1)], "assigning variable black"); + current_statement__ = 30; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 31; + validate_non_negative_index("edu", "N", N); + context__.validate_dims("data initialization","edu","int", + context__.to_vec(N)); + edu = std::vector(N, 0); + + current_statement__ = 31; + assign(edu, nil_index_list(), context__.vals_i("edu"), + "assigning variable edu"); + current_statement__ = 32; + validate_non_negative_index("female", "N", N); + context__.validate_dims("data initialization","female","double", + context__.to_vec(N)); + female = Eigen::Matrix(N); + + { + std::vector female_flat__; + current_statement__ = 32; + assign(female_flat__, nil_index_list(), context__.vals_r("female"), + "assigning variable female_flat__"); + current_statement__ = 32; + pos__ = 1; + current_statement__ = 32; + if (lcm_sym67__) { + current_statement__ = 32; + assign(female, cons_list(index_uni(1), nil_index_list()), + female_flat__[(1 - 1)], "assigning variable female"); + current_statement__ = 32; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 32; + assign(female, cons_list(index_uni(sym1__), nil_index_list()), + female_flat__[(pos__ - 1)], "assigning variable female"); + current_statement__ = 32; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 33; + validate_non_negative_index("region_full", "N", N); + context__.validate_dims("data initialization","region_full","int", + context__.to_vec(N)); + region_full = std::vector(N, 0); + + current_statement__ = 33; + assign(region_full, nil_index_list(), context__.vals_i("region_full"), + "assigning variable region_full"); + current_statement__ = 34; + validate_non_negative_index("state", "N", N); + context__.validate_dims("data initialization","state","int", + context__.to_vec(N)); + state = std::vector(N, 0); + + current_statement__ = 34; + assign(state, nil_index_list(), context__.vals_i("state"), + "assigning variable state"); + current_statement__ = 35; + validate_non_negative_index("v_prev_full", "N", N); + context__.validate_dims("data initialization","v_prev_full","double", + context__.to_vec(N)); + v_prev_full = Eigen::Matrix(N); + + { + std::vector v_prev_full_flat__; + current_statement__ = 35; + assign(v_prev_full_flat__, nil_index_list(), + context__.vals_r("v_prev_full"), + "assigning variable v_prev_full_flat__"); + current_statement__ = 35; + pos__ = 1; + current_statement__ = 35; + if (lcm_sym67__) { + current_statement__ = 35; + assign(v_prev_full, cons_list(index_uni(1), nil_index_list()), + v_prev_full_flat__[(1 - 1)], "assigning variable v_prev_full"); + current_statement__ = 35; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 35; + assign(v_prev_full, + cons_list(index_uni(sym1__), nil_index_list()), + v_prev_full_flat__[(pos__ - 1)], + "assigning variable v_prev_full"); + current_statement__ = 35; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 36; + validate_non_negative_index("y", "N", N); + context__.validate_dims("data initialization","y","int", + context__.to_vec(N)); + y = std::vector(N, 0); + + current_statement__ = 36; + assign(y, nil_index_list(), context__.vals_i("y"), + "assigning variable y"); + current_statement__ = 22; + current_statement__ = 22; + check_greater_or_equal(function__, "N", N, 0); + current_statement__ = 23; + current_statement__ = 23; + check_greater_or_equal(function__, "n_age", n_age, 0); + current_statement__ = 24; + current_statement__ = 24; + check_greater_or_equal(function__, "n_age_edu", n_age_edu, 0); + current_statement__ = 25; + current_statement__ = 25; + check_greater_or_equal(function__, "n_edu", n_edu, 0); + current_statement__ = 26; + current_statement__ = 26; + check_greater_or_equal(function__, "n_region_full", n_region_full, 0); + current_statement__ = 27; + current_statement__ = 27; + check_greater_or_equal(function__, "n_state", n_state, 0); + current_statement__ = 28; + if (lcm_sym67__) { + current_statement__ = 28; + current_statement__ = 28; + check_greater_or_equal(function__, "age[sym1__]", age[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 28; + current_statement__ = 28; + check_greater_or_equal(function__, "age[sym1__]", + age[(sym1__ - 1)], 0);} + } + current_statement__ = 28; + if (lcm_sym67__) { + current_statement__ = 28; + current_statement__ = 28; + check_less_or_equal(function__, "age[sym1__]", age[(1 - 1)], n_age); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 28; + current_statement__ = 28; + check_less_or_equal(function__, "age[sym1__]", age[(sym1__ - 1)], + n_age);} + } + current_statement__ = 29; + if (lcm_sym67__) { + current_statement__ = 29; + current_statement__ = 29; + check_greater_or_equal(function__, "age_edu[sym1__]", + age_edu[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 29; + current_statement__ = 29; + check_greater_or_equal(function__, "age_edu[sym1__]", + age_edu[(sym1__ - 1)], 0);} + } + current_statement__ = 29; + if (lcm_sym67__) { + current_statement__ = 29; + current_statement__ = 29; + check_less_or_equal(function__, "age_edu[sym1__]", age_edu[(1 - 1)], + n_age_edu); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 29; + current_statement__ = 29; + check_less_or_equal(function__, "age_edu[sym1__]", + age_edu[(sym1__ - 1)], n_age_edu);} + } + current_statement__ = 30; + current_statement__ = 30; + check_greater_or_equal(function__, "black", black, 0); + current_statement__ = 30; + current_statement__ = 30; + check_less_or_equal(function__, "black", black, 1); + current_statement__ = 31; + if (lcm_sym67__) { + current_statement__ = 31; + current_statement__ = 31; + check_greater_or_equal(function__, "edu[sym1__]", edu[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 31; + current_statement__ = 31; + check_greater_or_equal(function__, "edu[sym1__]", + edu[(sym1__ - 1)], 0);} + } + current_statement__ = 31; + if (lcm_sym67__) { + current_statement__ = 31; + current_statement__ = 31; + check_less_or_equal(function__, "edu[sym1__]", edu[(1 - 1)], n_edu); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 31; + current_statement__ = 31; + check_less_or_equal(function__, "edu[sym1__]", edu[(sym1__ - 1)], + n_edu);} + } + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "female", female, 0); + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "female", female, 1); + current_statement__ = 33; + if (lcm_sym67__) { + current_statement__ = 33; + current_statement__ = 33; + check_greater_or_equal(function__, "region_full[sym1__]", + region_full[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 33; + current_statement__ = 33; + check_greater_or_equal(function__, "region_full[sym1__]", + region_full[(sym1__ - 1)], 0);} + } + current_statement__ = 33; + if (lcm_sym67__) { + current_statement__ = 33; + current_statement__ = 33; + check_less_or_equal(function__, "region_full[sym1__]", + region_full[(1 - 1)], n_region_full); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 33; + current_statement__ = 33; + check_less_or_equal(function__, "region_full[sym1__]", + region_full[(sym1__ - 1)], n_region_full);} + } + current_statement__ = 34; + if (lcm_sym67__) { + current_statement__ = 34; + current_statement__ = 34; + check_greater_or_equal(function__, "state[sym1__]", state[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 34; + current_statement__ = 34; + check_greater_or_equal(function__, "state[sym1__]", + state[(sym1__ - 1)], 0);} + } + current_statement__ = 34; + if (lcm_sym67__) { + current_statement__ = 34; + current_statement__ = 34; + check_less_or_equal(function__, "state[sym1__]", state[(1 - 1)], + n_state); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 34; + current_statement__ = 34; + check_less_or_equal(function__, "state[sym1__]", + state[(sym1__ - 1)], n_state);} + } + current_statement__ = 36; + if (lcm_sym67__) { + current_statement__ = 36; + current_statement__ = 36; + check_greater_or_equal(function__, "y[sym1__]", y[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 36; + current_statement__ = 36; + check_greater_or_equal(function__, "y[sym1__]", y[(sym1__ - 1)], 0); + } + } + current_statement__ = 36; + if (lcm_sym67__) { + current_statement__ = 36; + current_statement__ = 36; + check_less_or_equal(function__, "y[sym1__]", y[(1 - 1)], 1); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 36; + current_statement__ = 36; + check_less_or_equal(function__, "y[sym1__]", y[(sym1__ - 1)], 1);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + current_statement__ = 1; + validate_non_negative_index("a", "n_age", n_age); + num_params_r__ += n_age; + current_statement__ = 2; + validate_non_negative_index("b", "n_edu", n_edu); + num_params_r__ += n_edu; + current_statement__ = 3; + validate_non_negative_index("c", "n_age_edu", n_age_edu); + num_params_r__ += n_age_edu; + current_statement__ = 4; + validate_non_negative_index("d", "n_state", n_state); + num_params_r__ += n_state; + current_statement__ = 5; + validate_non_negative_index("e", "n_region_full", n_region_full); + num_params_r__ += n_region_full; + current_statement__ = 6; + validate_non_negative_index("beta", "5", 5); + num_params_r__ += 5; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "expr_prop_fail3_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + double lcm_sym66__; + double lcm_sym65__; + double lcm_sym64__; + double lcm_sym63__; + double lcm_sym62__; + double lcm_sym61__; + double lcm_sym60__; + double lcm_sym59__; + double lcm_sym58__; + double lcm_sym57__; + int lcm_sym56__; + current_statement__ = 1; + validate_non_negative_index("a", "n_age", n_age); + Eigen::Matrix a; + a = Eigen::Matrix(n_age); + + current_statement__ = 1; + a = in__.vector(n_age); + current_statement__ = 2; + validate_non_negative_index("b", "n_edu", n_edu); + Eigen::Matrix b; + b = Eigen::Matrix(n_edu); + + current_statement__ = 2; + b = in__.vector(n_edu); + current_statement__ = 3; + validate_non_negative_index("c", "n_age_edu", n_age_edu); + Eigen::Matrix c; + c = Eigen::Matrix(n_age_edu); + + current_statement__ = 3; + c = in__.vector(n_age_edu); + current_statement__ = 4; + validate_non_negative_index("d", "n_state", n_state); + Eigen::Matrix d; + d = Eigen::Matrix(n_state); + + current_statement__ = 4; + d = in__.vector(n_state); + current_statement__ = 5; + validate_non_negative_index("e", "n_region_full", n_region_full); + Eigen::Matrix e; + e = Eigen::Matrix(n_region_full); + + current_statement__ = 5; + e = in__.vector(n_region_full); + current_statement__ = 6; + validate_non_negative_index("beta", "5", 5); + Eigen::Matrix beta; + beta = Eigen::Matrix(5); + + current_statement__ = 6; + beta = in__.vector(5); + local_scalar_t__ sigma_a; + + current_statement__ = 7; + sigma_a = in__.scalar(); + current_statement__ = 7; + if (jacobian__) { + current_statement__ = 7; + sigma_a = stan::math::lub_constrain(sigma_a, 0, 100, lp__); + } else { + current_statement__ = 7; + sigma_a = stan::math::lub_constrain(sigma_a, 0, 100); + } + local_scalar_t__ sigma_b; + + current_statement__ = 8; + sigma_b = in__.scalar(); + current_statement__ = 8; + if (jacobian__) { + current_statement__ = 8; + sigma_b = stan::math::lub_constrain(sigma_b, 0, 100, lp__); + } else { + current_statement__ = 8; + sigma_b = stan::math::lub_constrain(sigma_b, 0, 100); + } + local_scalar_t__ sigma_c; + + current_statement__ = 9; + sigma_c = in__.scalar(); + current_statement__ = 9; + if (jacobian__) { + current_statement__ = 9; + sigma_c = stan::math::lub_constrain(sigma_c, 0, 100, lp__); + } else { + current_statement__ = 9; + sigma_c = stan::math::lub_constrain(sigma_c, 0, 100); + } + local_scalar_t__ sigma_d; + + current_statement__ = 10; + sigma_d = in__.scalar(); + current_statement__ = 10; + if (jacobian__) { + current_statement__ = 10; + sigma_d = stan::math::lub_constrain(sigma_d, 0, 100, lp__); + } else { + current_statement__ = 10; + sigma_d = stan::math::lub_constrain(sigma_d, 0, 100); + } + local_scalar_t__ sigma_e; + + current_statement__ = 11; + sigma_e = in__.scalar(); + current_statement__ = 11; + if (jacobian__) { + current_statement__ = 11; + sigma_e = stan::math::lub_constrain(sigma_e, 0, 100, lp__); + } else { + current_statement__ = 11; + sigma_e = stan::math::lub_constrain(sigma_e, 0, 100); + } + current_statement__ = 12; + validate_non_negative_index("y_hat", "N", N); + Eigen::Matrix y_hat; + y_hat = Eigen::Matrix(N); + + lcm_sym56__ = logical_gte(N, 1); + if (lcm_sym56__) { + lcm_sym66__ = std::numeric_limits::quiet_NaN(); + assign(y_hat, cons_list(index_uni(1), nil_index_list()), lcm_sym66__, + "assigning variable y_hat"); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 12; + assign(y_hat, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym66__, "assigning variable y_hat");} + } + current_statement__ = 14; + if (lcm_sym56__) { + current_statement__ = 13; + assign(y_hat, cons_list(index_uni(1), nil_index_list()), + (((((stan::math::fma(beta[(4 - 1)], v_prev_full[(1 - 1)], + stan::math::fma((beta[(5 - 1)] * female[(1 - 1)]), + black[(1 - 1)], + stan::math::fma(beta[(3 - 1)], female[(1 - 1)], + stan::math::fma(beta[(2 - 1)], black[(1 - 1)], + beta[(1 - 1)])))) + a[(age[(1 - 1)] - 1)]) + + b[(edu[(1 - 1)] - 1)]) + c[(age_edu[(1 - 1)] - 1)]) + + d[(state[(1 - 1)] - 1)]) + e[(region_full[(1 - 1)] - 1)]), + "assigning variable y_hat"); + for (size_t i = 2; i <= N; ++i) { + current_statement__ = 13; + assign(y_hat, cons_list(index_uni(i), nil_index_list()), + (((((stan::math::fma(beta[(4 - 1)], v_prev_full[(i - 1)], + stan::math::fma((beta[(5 - 1)] * female[(i - 1)]), + black[(i - 1)], + stan::math::fma(beta[(3 - 1)], female[(i - 1)], + stan::math::fma(beta[(2 - 1)], black[(i - 1)], + beta[(1 - 1)])))) + a[(age[(i - 1)] - 1)]) + + b[(edu[(i - 1)] - 1)]) + c[(age_edu[(i - 1)] - 1)]) + + d[(state[(i - 1)] - 1)]) + e[(region_full[(i - 1)] - 1)]), + "assigning variable y_hat");} + } + { + current_statement__ = 15; + lp_accum__.add(normal_log(a, 0, sigma_a)); + current_statement__ = 16; + lp_accum__.add(normal_log(b, 0, sigma_b)); + current_statement__ = 17; + lp_accum__.add(normal_log(c, 0, sigma_c)); + current_statement__ = 18; + lp_accum__.add(normal_log(d, 0, sigma_d)); + current_statement__ = 19; + lp_accum__.add(normal_log(e, 0, sigma_e)); + current_statement__ = 20; + lp_accum__.add(normal_log(beta, 0, 100)); + current_statement__ = 21; + lp_accum__.add(bernoulli_logit_log(y, y_hat)); + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "expr_prop_fail3_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + double lcm_sym55__; + double lcm_sym54__; + double lcm_sym53__; + double lcm_sym52__; + double lcm_sym51__; + double lcm_sym50__; + double lcm_sym49__; + double lcm_sym48__; + double lcm_sym47__; + double lcm_sym46__; + double lcm_sym45__; + double lcm_sym44__; + double lcm_sym43__; + double lcm_sym42__; + double lcm_sym41__; + double lcm_sym40__; + double lcm_sym39__; + int lcm_sym38__; + int lcm_sym37__; + int lcm_sym36__; + int lcm_sym35__; + int lcm_sym34__; + int lcm_sym33__; + int lcm_sym32__; + int lcm_sym31__; + current_statement__ = 1; + validate_non_negative_index("a", "n_age", n_age); + Eigen::Matrix a; + a = Eigen::Matrix(n_age); + + current_statement__ = 1; + a = in__.vector(n_age); + current_statement__ = 2; + validate_non_negative_index("b", "n_edu", n_edu); + Eigen::Matrix b; + b = Eigen::Matrix(n_edu); + + current_statement__ = 2; + b = in__.vector(n_edu); + current_statement__ = 3; + validate_non_negative_index("c", "n_age_edu", n_age_edu); + Eigen::Matrix c; + c = Eigen::Matrix(n_age_edu); + + current_statement__ = 3; + c = in__.vector(n_age_edu); + current_statement__ = 4; + validate_non_negative_index("d", "n_state", n_state); + Eigen::Matrix d; + d = Eigen::Matrix(n_state); + + current_statement__ = 4; + d = in__.vector(n_state); + current_statement__ = 5; + validate_non_negative_index("e", "n_region_full", n_region_full); + Eigen::Matrix e; + e = Eigen::Matrix(n_region_full); + + current_statement__ = 5; + e = in__.vector(n_region_full); + current_statement__ = 6; + validate_non_negative_index("beta", "5", 5); + Eigen::Matrix beta; + beta = Eigen::Matrix(5); + + current_statement__ = 6; + beta = in__.vector(5); + double sigma_a; + + current_statement__ = 7; + sigma_a = in__.scalar(); + current_statement__ = 7; + sigma_a = stan::math::lub_constrain(sigma_a, 0, 100); + double sigma_b; + + current_statement__ = 8; + sigma_b = in__.scalar(); + current_statement__ = 8; + sigma_b = stan::math::lub_constrain(sigma_b, 0, 100); + double sigma_c; + + current_statement__ = 9; + sigma_c = in__.scalar(); + current_statement__ = 9; + sigma_c = stan::math::lub_constrain(sigma_c, 0, 100); + double sigma_d; + + current_statement__ = 10; + sigma_d = in__.scalar(); + current_statement__ = 10; + sigma_d = stan::math::lub_constrain(sigma_d, 0, 100); + double sigma_e; + + current_statement__ = 11; + sigma_e = in__.scalar(); + current_statement__ = 11; + sigma_e = stan::math::lub_constrain(sigma_e, 0, 100); + current_statement__ = 12; + validate_non_negative_index("y_hat", "N", N); + Eigen::Matrix y_hat; + y_hat = Eigen::Matrix(N); + + lcm_sym31__ = logical_gte(N, 1); + if (lcm_sym31__) { + lcm_sym41__ = std::numeric_limits::quiet_NaN(); + assign(y_hat, cons_list(index_uni(1), nil_index_list()), lcm_sym41__, + "assigning variable y_hat"); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 12; + assign(y_hat, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym41__, "assigning variable y_hat");} + } + if (logical_gte(n_age, 1)) { + vars__.push_back(a[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_age; ++sym1__) { + vars__.push_back(a[(sym1__ - 1)]);} + } + if (logical_gte(n_edu, 1)) { + vars__.push_back(b[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_edu; ++sym1__) { + vars__.push_back(b[(sym1__ - 1)]);} + } + if (logical_gte(n_age_edu, 1)) { + vars__.push_back(c[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_age_edu; ++sym1__) { + vars__.push_back(c[(sym1__ - 1)]);} + } + if (logical_gte(n_state, 1)) { + vars__.push_back(d[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_state; ++sym1__) { + vars__.push_back(d[(sym1__ - 1)]);} + } + if (logical_gte(n_region_full, 1)) { + vars__.push_back(e[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_region_full; ++sym1__) { + vars__.push_back(e[(sym1__ - 1)]);} + } + { + vars__.push_back(beta[(1 - 1)]); + { + vars__.push_back(beta[(2 - 1)]); + } + { + vars__.push_back(beta[(3 - 1)]); + } + { + vars__.push_back(beta[(4 - 1)]); + } + { + vars__.push_back(beta[(5 - 1)]); + } + } + vars__.push_back(sigma_a); + vars__.push_back(sigma_b); + vars__.push_back(sigma_c); + vars__.push_back(sigma_d); + vars__.push_back(sigma_e); + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + current_statement__ = 14; + if (lcm_sym31__) { + current_statement__ = 13; + assign(y_hat, cons_list(index_uni(1), nil_index_list()), + (((((stan::math::fma(beta[(4 - 1)], v_prev_full[(1 - 1)], + stan::math::fma((beta[(5 - 1)] * female[(1 - 1)]), + black[(1 - 1)], + stan::math::fma(beta[(3 - 1)], female[(1 - 1)], + stan::math::fma(beta[(2 - 1)], black[(1 - 1)], + beta[(1 - 1)])))) + a[(age[(1 - 1)] - 1)]) + + b[(edu[(1 - 1)] - 1)]) + c[(age_edu[(1 - 1)] - 1)]) + + d[(state[(1 - 1)] - 1)]) + e[(region_full[(1 - 1)] - 1)]), + "assigning variable y_hat"); + for (size_t i = 2; i <= N; ++i) { + current_statement__ = 13; + assign(y_hat, cons_list(index_uni(i), nil_index_list()), + (((((stan::math::fma(beta[(4 - 1)], v_prev_full[(i - 1)], + stan::math::fma((beta[(5 - 1)] * female[(i - 1)]), + black[(i - 1)], + stan::math::fma(beta[(3 - 1)], female[(i - 1)], + stan::math::fma(beta[(2 - 1)], black[(i - 1)], + beta[(1 - 1)])))) + a[(age[(i - 1)] - 1)]) + + b[(edu[(i - 1)] - 1)]) + c[(age_edu[(i - 1)] - 1)]) + + d[(state[(i - 1)] - 1)]) + e[(region_full[(i - 1)] - 1)]), + "assigning variable y_hat");} + } + if (lcm_sym31__) { + vars__.push_back(y_hat[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + vars__.push_back(y_hat[(sym1__ - 1)]);} + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + double lcm_sym30__; + double lcm_sym29__; + double lcm_sym28__; + double lcm_sym27__; + double lcm_sym26__; + double lcm_sym25__; + double lcm_sym24__; + double lcm_sym23__; + double lcm_sym22__; + double lcm_sym21__; + double lcm_sym20__; + double lcm_sym19__; + double lcm_sym18__; + double lcm_sym17__; + double lcm_sym16__; + double lcm_sym15__; + double lcm_sym14__; + double lcm_sym13__; + double lcm_sym12__; + double lcm_sym11__; + double lcm_sym10__; + double lcm_sym9__; + double lcm_sym8__; + double lcm_sym7__; + int lcm_sym6__; + int lcm_sym5__; + int lcm_sym4__; + int lcm_sym3__; + int lcm_sym2__; + int lcm_sym1__; + int pos__; + + pos__ = 1; + current_statement__ = 1; + validate_non_negative_index("a", "n_age", n_age); + Eigen::Matrix a; + a = Eigen::Matrix(n_age); + + { + std::vector a_flat__; + current_statement__ = 1; + assign(a_flat__, nil_index_list(), context__.vals_r("a"), + "assigning variable a_flat__"); + current_statement__ = 1; + pos__ = 1; + lcm_sym1__ = logical_gte(n_age, 1); + if (lcm_sym1__) { + current_statement__ = 1; + assign(a, cons_list(index_uni(1), nil_index_list()), + a_flat__[(1 - 1)], "assigning variable a"); + current_statement__ = 1; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= n_age; ++sym1__) { + current_statement__ = 1; + assign(a, cons_list(index_uni(sym1__), nil_index_list()), + a_flat__[(pos__ - 1)], "assigning variable a"); + current_statement__ = 1; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 2; + validate_non_negative_index("b", "n_edu", n_edu); + Eigen::Matrix b; + b = Eigen::Matrix(n_edu); + + { + std::vector b_flat__; + current_statement__ = 2; + assign(b_flat__, nil_index_list(), context__.vals_r("b"), + "assigning variable b_flat__"); + current_statement__ = 2; + pos__ = 1; + lcm_sym3__ = logical_gte(n_edu, 1); + if (lcm_sym3__) { + current_statement__ = 2; + assign(b, cons_list(index_uni(1), nil_index_list()), + b_flat__[(1 - 1)], "assigning variable b"); + current_statement__ = 2; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= n_edu; ++sym1__) { + current_statement__ = 2; + assign(b, cons_list(index_uni(sym1__), nil_index_list()), + b_flat__[(pos__ - 1)], "assigning variable b"); + current_statement__ = 2; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 3; + validate_non_negative_index("c", "n_age_edu", n_age_edu); + Eigen::Matrix c; + c = Eigen::Matrix(n_age_edu); + + { + std::vector c_flat__; + current_statement__ = 3; + assign(c_flat__, nil_index_list(), context__.vals_r("c"), + "assigning variable c_flat__"); + current_statement__ = 3; + pos__ = 1; + lcm_sym2__ = logical_gte(n_age_edu, 1); + if (lcm_sym2__) { + current_statement__ = 3; + assign(c, cons_list(index_uni(1), nil_index_list()), + c_flat__[(1 - 1)], "assigning variable c"); + current_statement__ = 3; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= n_age_edu; ++sym1__) { + current_statement__ = 3; + assign(c, cons_list(index_uni(sym1__), nil_index_list()), + c_flat__[(pos__ - 1)], "assigning variable c"); + current_statement__ = 3; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 4; + validate_non_negative_index("d", "n_state", n_state); + Eigen::Matrix d; + d = Eigen::Matrix(n_state); + + { + std::vector d_flat__; + current_statement__ = 4; + assign(d_flat__, nil_index_list(), context__.vals_r("d"), + "assigning variable d_flat__"); + current_statement__ = 4; + pos__ = 1; + lcm_sym5__ = logical_gte(n_state, 1); + if (lcm_sym5__) { + current_statement__ = 4; + assign(d, cons_list(index_uni(1), nil_index_list()), + d_flat__[(1 - 1)], "assigning variable d"); + current_statement__ = 4; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= n_state; ++sym1__) { + current_statement__ = 4; + assign(d, cons_list(index_uni(sym1__), nil_index_list()), + d_flat__[(pos__ - 1)], "assigning variable d"); + current_statement__ = 4; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 5; + validate_non_negative_index("e", "n_region_full", n_region_full); + Eigen::Matrix e; + e = Eigen::Matrix(n_region_full); + + { + std::vector e_flat__; + current_statement__ = 5; + assign(e_flat__, nil_index_list(), context__.vals_r("e"), + "assigning variable e_flat__"); + current_statement__ = 5; + pos__ = 1; + lcm_sym4__ = logical_gte(n_region_full, 1); + if (lcm_sym4__) { + current_statement__ = 5; + assign(e, cons_list(index_uni(1), nil_index_list()), + e_flat__[(1 - 1)], "assigning variable e"); + current_statement__ = 5; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= n_region_full; ++sym1__) { + current_statement__ = 5; + assign(e, cons_list(index_uni(sym1__), nil_index_list()), + e_flat__[(pos__ - 1)], "assigning variable e"); + current_statement__ = 5; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 6; + validate_non_negative_index("beta", "5", 5); + Eigen::Matrix beta; + beta = Eigen::Matrix(5); + + { + std::vector beta_flat__; + current_statement__ = 6; + assign(beta_flat__, nil_index_list(), context__.vals_r("beta"), + "assigning variable beta_flat__"); + current_statement__ = 6; + pos__ = 1; + { + current_statement__ = 6; + assign(beta, cons_list(index_uni(1), nil_index_list()), + beta_flat__[(1 - 1)], "assigning variable beta"); + current_statement__ = 6; + pos__ = 2; + { + current_statement__ = 6; + assign(beta, cons_list(index_uni(2), nil_index_list()), + beta_flat__[(pos__ - 1)], "assigning variable beta"); + current_statement__ = 6; + pos__ = (pos__ + 1); + } + { + current_statement__ = 6; + assign(beta, cons_list(index_uni(3), nil_index_list()), + beta_flat__[(pos__ - 1)], "assigning variable beta"); + current_statement__ = 6; + pos__ = (pos__ + 1); + } + { + current_statement__ = 6; + assign(beta, cons_list(index_uni(4), nil_index_list()), + beta_flat__[(pos__ - 1)], "assigning variable beta"); + current_statement__ = 6; + pos__ = (pos__ + 1); + } + { + current_statement__ = 6; + assign(beta, cons_list(index_uni(5), nil_index_list()), + beta_flat__[(pos__ - 1)], "assigning variable beta"); + current_statement__ = 6; + pos__ = (pos__ + 1); + } + } + } + double sigma_a; + + current_statement__ = 7; + sigma_a = context__.vals_r("sigma_a")[(1 - 1)]; + current_statement__ = 7; + sigma_a = stan::math::lub_free(sigma_a, 0, 100); + double sigma_b; + + current_statement__ = 8; + sigma_b = context__.vals_r("sigma_b")[(1 - 1)]; + current_statement__ = 8; + sigma_b = stan::math::lub_free(sigma_b, 0, 100); + double sigma_c; + + current_statement__ = 9; + sigma_c = context__.vals_r("sigma_c")[(1 - 1)]; + current_statement__ = 9; + sigma_c = stan::math::lub_free(sigma_c, 0, 100); + double sigma_d; + + current_statement__ = 10; + sigma_d = context__.vals_r("sigma_d")[(1 - 1)]; + current_statement__ = 10; + sigma_d = stan::math::lub_free(sigma_d, 0, 100); + double sigma_e; + + current_statement__ = 11; + sigma_e = context__.vals_r("sigma_e")[(1 - 1)]; + current_statement__ = 11; + sigma_e = stan::math::lub_free(sigma_e, 0, 100); + if (lcm_sym1__) { + vars__.push_back(a[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_age; ++sym1__) { + vars__.push_back(a[(sym1__ - 1)]);} + } + if (lcm_sym3__) { + vars__.push_back(b[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_edu; ++sym1__) { + vars__.push_back(b[(sym1__ - 1)]);} + } + if (lcm_sym2__) { + vars__.push_back(c[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_age_edu; ++sym1__) { + vars__.push_back(c[(sym1__ - 1)]);} + } + if (lcm_sym5__) { + vars__.push_back(d[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_state; ++sym1__) { + vars__.push_back(d[(sym1__ - 1)]);} + } + if (lcm_sym4__) { + vars__.push_back(e[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_region_full; ++sym1__) { + vars__.push_back(e[(sym1__ - 1)]);} + } + { + vars__.push_back(beta[(1 - 1)]); + { + vars__.push_back(beta[(2 - 1)]); + } + { + vars__.push_back(beta[(3 - 1)]); + } + { + vars__.push_back(beta[(4 - 1)]); + } + { + vars__.push_back(beta[(5 - 1)]); + } + } + vars__.push_back(sigma_a); + vars__.push_back(sigma_b); + vars__.push_back(sigma_c); + vars__.push_back(sigma_d); + vars__.push_back(sigma_e); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("a"); + names__.push_back("b"); + names__.push_back("c"); + names__.push_back("d"); + names__.push_back("e"); + names__.push_back("beta"); + names__.push_back("sigma_a"); + names__.push_back("sigma_b"); + names__.push_back("sigma_c"); + names__.push_back("sigma_d"); + names__.push_back("sigma_e"); + names__.push_back("y_hat"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dims__.push_back(n_age); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_edu); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_age_edu); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_state); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_region_full); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(5); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(N); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + for (size_t sym87__ = 1; sym87__ <= n_age; ++sym87__) { + { + param_names__.push_back(std::string() + "a" + '.' + std::to_string(sym87__)); + }} + for (size_t sym87__ = 1; sym87__ <= n_edu; ++sym87__) { + { + param_names__.push_back(std::string() + "b" + '.' + std::to_string(sym87__)); + }} + for (size_t sym87__ = 1; sym87__ <= n_age_edu; ++sym87__) { + { + param_names__.push_back(std::string() + "c" + '.' + std::to_string(sym87__)); + }} + for (size_t sym87__ = 1; sym87__ <= n_state; ++sym87__) { + { + param_names__.push_back(std::string() + "d" + '.' + std::to_string(sym87__)); + }} + for (size_t sym87__ = 1; sym87__ <= n_region_full; ++sym87__) { + { + param_names__.push_back(std::string() + "e" + '.' + std::to_string(sym87__)); + }} + for (size_t sym87__ = 1; sym87__ <= 5; ++sym87__) { + { + param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym87__)); + }} + param_names__.push_back(std::string() + "sigma_a"); + param_names__.push_back(std::string() + "sigma_b"); + param_names__.push_back(std::string() + "sigma_c"); + param_names__.push_back(std::string() + "sigma_d"); + param_names__.push_back(std::string() + "sigma_e"); + if (emit_transformed_parameters__) { + for (size_t sym87__ = 1; sym87__ <= N; ++sym87__) { + { + param_names__.push_back(std::string() + "y_hat" + '.' + std::to_string(sym87__)); + }} + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + for (size_t sym87__ = 1; sym87__ <= n_age; ++sym87__) { + { + param_names__.push_back(std::string() + "a" + '.' + std::to_string(sym87__)); + }} + for (size_t sym87__ = 1; sym87__ <= n_edu; ++sym87__) { + { + param_names__.push_back(std::string() + "b" + '.' + std::to_string(sym87__)); + }} + for (size_t sym87__ = 1; sym87__ <= n_age_edu; ++sym87__) { + { + param_names__.push_back(std::string() + "c" + '.' + std::to_string(sym87__)); + }} + for (size_t sym87__ = 1; sym87__ <= n_state; ++sym87__) { + { + param_names__.push_back(std::string() + "d" + '.' + std::to_string(sym87__)); + }} + for (size_t sym87__ = 1; sym87__ <= n_region_full; ++sym87__) { + { + param_names__.push_back(std::string() + "e" + '.' + std::to_string(sym87__)); + }} + for (size_t sym87__ = 1; sym87__ <= 5; ++sym87__) { + { + param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym87__)); + }} + param_names__.push_back(std::string() + "sigma_a"); + param_names__.push_back(std::string() + "sigma_b"); + param_names__.push_back(std::string() + "sigma_c"); + param_names__.push_back(std::string() + "sigma_d"); + param_names__.push_back(std::string() + "sigma_e"); + if (emit_transformed_parameters__) { + for (size_t sym87__ = 1; sym87__ <= N; ++sym87__) { + { + param_names__.push_back(std::string() + "y_hat" + '.' + std::to_string(sym87__)); + }} + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"a\",\"type\":{\"name\":\"vector\",\"length\":" << n_age << "},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" << n_edu << "},\"block\":\"parameters\"},{\"name\":\"c\",\"type\":{\"name\":\"vector\",\"length\":" << n_age_edu << "},\"block\":\"parameters\"},{\"name\":\"d\",\"type\":{\"name\":\"vector\",\"length\":" << n_state << "},\"block\":\"parameters\"},{\"name\":\"e\",\"type\":{\"name\":\"vector\",\"length\":" << n_region_full << "},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << 5 << "},\"block\":\"parameters\"},{\"name\":\"sigma_a\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_b\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_c\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_d\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_e\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"a\",\"type\":{\"name\":\"vector\",\"length\":" << n_age << "},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" << n_edu << "},\"block\":\"parameters\"},{\"name\":\"c\",\"type\":{\"name\":\"vector\",\"length\":" << n_age_edu << "},\"block\":\"parameters\"},{\"name\":\"d\",\"type\":{\"name\":\"vector\",\"length\":" << n_state << "},\"block\":\"parameters\"},{\"name\":\"e\",\"type\":{\"name\":\"vector\",\"length\":" << n_region_full << "},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << 5 << "},\"block\":\"parameters\"},{\"name\":\"sigma_a\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_b\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_c\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_d\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_e\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef expr_prop_fail3_model_namespace::expr_prop_fail3_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-fail4.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace expr_prop_fail4_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'expr-prop-fail4.stan', line 12, column 2 to column 24)", + " (in 'expr-prop-fail4.stan', line 13, column 2 to column 28)", + " (in 'expr-prop-fail4.stan', line 16, column 2 to column 47)", + " (in 'expr-prop-fail4.stan', line 17, column 2 to column 16)", + " (in 'expr-prop-fail4.stan', line 18, column 2 to column 31)", + " (in 'expr-prop-fail4.stan', line 19, column 2 to column 29)", + " (in 'expr-prop-fail4.stan', line 20, column 2 to column 24)", + " (in 'expr-prop-fail4.stan', line 27, column 2 to column 13)", + " (in 'expr-prop-fail4.stan', line 28, column 2 to column 13)", + " (in 'expr-prop-fail4.stan', line 29, column 2 to column 26)", + " (in 'expr-prop-fail4.stan', line 30, column 2 to column 28)", + " (in 'expr-prop-fail4.stan', line 31, column 2 to column 18)", + " (in 'expr-prop-fail4.stan', line 32, column 2 to column 22)", + " (in 'expr-prop-fail4.stan', line 34, column 2 to column 14)", + " (in 'expr-prop-fail4.stan', line 35, column 2 to column 11)", + " (in 'expr-prop-fail4.stan', line 37, column 2 to column 27)", + " (in 'expr-prop-fail4.stan', line 38, column 2 to column 27)", + " (in 'expr-prop-fail4.stan', line 40, column 4 to column 36)", + " (in 'expr-prop-fail4.stan', line 39, column 17 to line 41, column 3)", + " (in 'expr-prop-fail4.stan', line 39, column 2 to line 41, column 3)", + " (in 'expr-prop-fail4.stan', line 42, column 2 to column 38)", + " (in 'expr-prop-fail4.stan', line 47, column 4 to column 28)", + " (in 'expr-prop-fail4.stan', line 48, column 4 to column 80)", + " (in 'expr-prop-fail4.stan', line 46, column 17 to line 49, column 3)", + " (in 'expr-prop-fail4.stan', line 46, column 2 to line 49, column 3)", + " (in 'expr-prop-fail4.stan', line 23, column 2 to column 53)", + " (in 'expr-prop-fail4.stan', line 24, column 2 to column 24)", + " (in 'expr-prop-fail4.stan', line 2, column 2 to column 17)", + " (in 'expr-prop-fail4.stan', line 3, column 2 to column 23)", + " (in 'expr-prop-fail4.stan', line 4, column 2 to column 39)", + " (in 'expr-prop-fail4.stan', line 5, column 2 to column 39)", + " (in 'expr-prop-fail4.stan', line 6, column 2 to column 23)", + " (in 'expr-prop-fail4.stan', line 9, column 2 to column 27)"}; + + + +class expr_prop_fail4_model : public model_base_crtp { + + private: + int lcm_sym53__; + int lcm_sym52__; + int lcm_sym51__; + int lcm_sym50__; + double lcm_sym49__; + double lcm_sym48__; + double lcm_sym47__; + Eigen::Matrix lcm_sym46__; + int lcm_sym45__; + int lcm_sym44__; + int lcm_sym43__; + int pos__; + int N; + int N_edges; + std::vector node1; + std::vector node2; + Eigen::Matrix E; + Eigen::Matrix log_E; + + public: + ~expr_prop_fail4_model() { } + + std::string model_name() const { return "expr_prop_fail4_model"; } + + expr_prop_fail4_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "expr_prop_fail4_model_namespace::expr_prop_fail4_model"; + (void) function__; // suppress unused var warning + + try { + + + + + + + + + + + + + pos__ = 1; + context__.validate_dims("data initialization","N","int", + context__.to_vec()); + + current_statement__ = 28; + N = context__.vals_i("N")[(1 - 1)]; + context__.validate_dims("data initialization","N_edges","int", + context__.to_vec()); + + current_statement__ = 29; + N_edges = context__.vals_i("N_edges")[(1 - 1)]; + current_statement__ = 30; + validate_non_negative_index("node1", "N_edges", N_edges); + context__.validate_dims("data initialization","node1","int", + context__.to_vec(N_edges)); + node1 = std::vector(N_edges, 0); + + current_statement__ = 30; + assign(node1, nil_index_list(), context__.vals_i("node1"), + "assigning variable node1"); + current_statement__ = 31; + validate_non_negative_index("node2", "N_edges", N_edges); + context__.validate_dims("data initialization","node2","int", + context__.to_vec(N_edges)); + node2 = std::vector(N_edges, 0); + + current_statement__ = 31; + assign(node2, nil_index_list(), context__.vals_i("node2"), + "assigning variable node2"); + current_statement__ = 32; + validate_non_negative_index("E", "N", N); + context__.validate_dims("data initialization","E","double", + context__.to_vec(N)); + E = Eigen::Matrix(N); + + { + std::vector E_flat__; + current_statement__ = 32; + assign(E_flat__, nil_index_list(), context__.vals_r("E"), + "assigning variable E_flat__"); + current_statement__ = 32; + pos__ = 1; + lcm_sym43__ = logical_gte(N, 1); + if (lcm_sym43__) { + current_statement__ = 32; + assign(E, cons_list(index_uni(1), nil_index_list()), + E_flat__[(1 - 1)], "assigning variable E"); + current_statement__ = 32; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 32; + assign(E, cons_list(index_uni(sym1__), nil_index_list()), + E_flat__[(pos__ - 1)], "assigning variable E"); + current_statement__ = 32; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 33; + validate_non_negative_index("log_E", "N", N); + log_E = Eigen::Matrix(N); + + current_statement__ = 33; + if (lcm_sym43__) { + lcm_sym47__ = std::numeric_limits::quiet_NaN(); + assign(log_E, cons_list(index_uni(1), nil_index_list()), lcm_sym47__, + "assigning variable log_E"); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 33; + assign(log_E, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym47__, "assigning variable log_E");} + } + current_statement__ = 33; + assign(log_E, nil_index_list(), stan::math::log(E), + "assigning variable log_E"); + current_statement__ = 28; + current_statement__ = 28; + check_greater_or_equal(function__, "N", N, 0); + current_statement__ = 29; + current_statement__ = 29; + check_greater_or_equal(function__, "N_edges", N_edges, 0); + lcm_sym44__ = logical_gte(N_edges, 1); + if (lcm_sym44__) { + current_statement__ = 30; + current_statement__ = 30; + check_greater_or_equal(function__, "node1[sym1__]", node1[(1 - 1)], 1); + for (size_t sym1__ = 2; sym1__ <= N_edges; ++sym1__) { + current_statement__ = 30; + current_statement__ = 30; + check_greater_or_equal(function__, "node1[sym1__]", + node1[(sym1__ - 1)], 1);} + } + current_statement__ = 30; + if (lcm_sym44__) { + current_statement__ = 30; + current_statement__ = 30; + check_less_or_equal(function__, "node1[sym1__]", node1[(1 - 1)], N); + for (size_t sym1__ = 2; sym1__ <= N_edges; ++sym1__) { + current_statement__ = 30; + current_statement__ = 30; + check_less_or_equal(function__, "node1[sym1__]", + node1[(sym1__ - 1)], N);} + } + current_statement__ = 31; + if (lcm_sym44__) { + current_statement__ = 31; + current_statement__ = 31; + check_greater_or_equal(function__, "node2[sym1__]", node2[(1 - 1)], 1); + for (size_t sym1__ = 2; sym1__ <= N_edges; ++sym1__) { + current_statement__ = 31; + current_statement__ = 31; + check_greater_or_equal(function__, "node2[sym1__]", + node2[(sym1__ - 1)], 1);} + } + current_statement__ = 31; + if (lcm_sym44__) { + current_statement__ = 31; + current_statement__ = 31; + check_less_or_equal(function__, "node2[sym1__]", node2[(1 - 1)], N); + for (size_t sym1__ = 2; sym1__ <= N_edges; ++sym1__) { + current_statement__ = 31; + current_statement__ = 31; + check_less_or_equal(function__, "node2[sym1__]", + node2[(sym1__ - 1)], N);} + } + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "E", E, 0); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + num_params_r__ += 1; + current_statement__ = 2; + validate_non_negative_index("phi_std_raw", "(N - 1)", (N - 1)); + num_params_r__ += (N - 1); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "expr_prop_fail4_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + double lcm_sym41__; + local_scalar_t__ lcm_sym40__; + double lcm_sym39__; + double lcm_sym38__; + Eigen::Matrix lcm_sym37__; + double lcm_sym36__; + int lcm_sym42__; + int lcm_sym34__; + local_scalar_t__ tau_phi; + + current_statement__ = 1; + tau_phi = in__.scalar(); + current_statement__ = 1; + if (jacobian__) { + current_statement__ = 1; + tau_phi = stan::math::lb_constrain(tau_phi, 0, lp__); + } else { + current_statement__ = 1; + tau_phi = stan::math::lb_constrain(tau_phi, 0); + } + lcm_sym42__ = (N - 1); + validate_non_negative_index("phi_std_raw", "(N - 1)", lcm_sym42__); + Eigen::Matrix phi_std_raw; + phi_std_raw = Eigen::Matrix(lcm_sym42__); + + current_statement__ = 2; + phi_std_raw = in__.vector(lcm_sym42__); + local_scalar_t__ sigma_phi; + + lcm_sym41__ = std::numeric_limits::quiet_NaN(); + sigma_phi = lcm_sym41__; + lcm_sym40__ = inv_sqrt(tau_phi); + sigma_phi = lcm_sym40__; + current_statement__ = 4; + validate_non_negative_index("phi", "N", N); + Eigen::Matrix phi; + phi = Eigen::Matrix(N); + + current_statement__ = 4; + if (logical_gte(N, 1)) { + current_statement__ = 4; + assign(phi, cons_list(index_uni(1), nil_index_list()), lcm_sym41__, + "assigning variable phi"); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 4; + assign(phi, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym41__, "assigning variable phi");} + } + current_statement__ = 5; + assign(phi, cons_list(index_min_max(1, lcm_sym42__), nil_index_list()), + phi_std_raw, "assigning variable phi"); + current_statement__ = 6; + assign(phi, cons_list(index_uni(N), nil_index_list()), + -sum(phi_std_raw), "assigning variable phi"); + current_statement__ = 7; + assign(phi, nil_index_list(), + multiply(stan::model::deep_copy(phi), lcm_sym40__), + "assigning variable phi"); + current_statement__ = 3; + current_statement__ = 3; + check_greater_or_equal(function__, "sigma_phi", lcm_sym40__, 0); + { + current_statement__ = 26; + lp_accum__.add( + (-0.5 * + dot_self( + subtract( + rvalue(phi, cons_list(index_multi(node1), nil_index_list()), + "phi"), + rvalue(phi, cons_list(index_multi(node2), nil_index_list()), + "phi"))))); + current_statement__ = 27; + lp_accum__.add(gamma_log(tau_phi, 1, 1)); + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "expr_prop_fail4_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + double lcm_sym33__; + double lcm_sym32__; + int lcm_sym31__; + int lcm_sym30__; + double lcm_sym29__; + double lcm_sym28__; + double lcm_sym27__; + double lcm_sym26__; + double lcm_sym25__; + double lcm_sym24__; + double lcm_sym23__; + double lcm_sym22__; + double lcm_sym20__; + double lcm_sym17__; + double lcm_sym16__; + Eigen::Matrix lcm_sym15__; + Eigen::Matrix lcm_sym14__; + double lcm_sym19__; + double lcm_sym18__; + int lcm_sym13__; + int lcm_sym12__; + double lcm_sym11__; + int lcm_sym21__; + int lcm_sym9__; + int lcm_sym8__; + double tau_phi; + + current_statement__ = 1; + tau_phi = in__.scalar(); + current_statement__ = 1; + tau_phi = stan::math::lb_constrain(tau_phi, 0); + lcm_sym21__ = (N - 1); + validate_non_negative_index("phi_std_raw", "(N - 1)", lcm_sym21__); + Eigen::Matrix phi_std_raw; + phi_std_raw = Eigen::Matrix(lcm_sym21__); + + current_statement__ = 2; + phi_std_raw = in__.vector(lcm_sym21__); + double sigma_phi; + + lcm_sym20__ = std::numeric_limits::quiet_NaN(); + sigma_phi = lcm_sym20__; + current_statement__ = 4; + validate_non_negative_index("phi", "N", N); + Eigen::Matrix phi; + phi = Eigen::Matrix(N); + + lcm_sym8__ = logical_gte(N, 1); + if (lcm_sym8__) { + current_statement__ = 4; + assign(phi, cons_list(index_uni(1), nil_index_list()), lcm_sym20__, + "assigning variable phi"); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 4; + assign(phi, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym20__, "assigning variable phi");} + } + vars__.push_back(tau_phi); + if (logical_gte(lcm_sym21__, 1)) { + vars__.push_back(phi_std_raw[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= lcm_sym21__; ++sym1__) { + vars__.push_back(phi_std_raw[(sym1__ - 1)]);} + } + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + lcm_sym16__ = inv_sqrt(tau_phi); + sigma_phi = lcm_sym16__; + current_statement__ = 5; + assign(phi, cons_list(index_min_max(1, lcm_sym21__), nil_index_list()), + phi_std_raw, "assigning variable phi"); + current_statement__ = 6; + assign(phi, cons_list(index_uni(N), nil_index_list()), + -sum(phi_std_raw), "assigning variable phi"); + current_statement__ = 7; + assign(phi, nil_index_list(), + multiply(stan::model::deep_copy(phi), lcm_sym16__), + "assigning variable phi"); + vars__.push_back(lcm_sym16__); + if (lcm_sym8__) { + vars__.push_back(phi[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + vars__.push_back(phi[(sym1__ - 1)]);} + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + double beta0; + + current_statement__ = 8; + beta0 = lcm_sym20__; + double beta1; + + current_statement__ = 9; + beta1 = lcm_sym20__; + double tau_theta; + + current_statement__ = 10; + tau_theta = lcm_sym20__; + double sigma_theta; + + current_statement__ = 11; + sigma_theta = lcm_sym20__; + current_statement__ = 12; + validate_non_negative_index("theta", "N", N); + Eigen::Matrix theta; + theta = Eigen::Matrix(N); + + current_statement__ = 12; + if (lcm_sym8__) { + current_statement__ = 12; + assign(theta, cons_list(index_uni(1), nil_index_list()), lcm_sym20__, + "assigning variable theta"); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 12; + assign(theta, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym20__, "assigning variable theta");} + } + current_statement__ = 13; + validate_non_negative_index("theta_std", "N", N); + Eigen::Matrix theta_std; + theta_std = Eigen::Matrix(N); + + current_statement__ = 13; + if (lcm_sym8__) { + current_statement__ = 13; + assign(theta_std, cons_list(index_uni(1), nil_index_list()), + lcm_sym20__, "assigning variable theta_std"); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 13; + assign(theta_std, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym20__, "assigning variable theta_std");} + } + current_statement__ = 14; + validate_non_negative_index("x", "N", N); + Eigen::Matrix x; + x = Eigen::Matrix(N); + + current_statement__ = 14; + if (lcm_sym8__) { + current_statement__ = 14; + assign(x, cons_list(index_uni(1), nil_index_list()), lcm_sym20__, + "assigning variable x"); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 14; + assign(x, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym20__, "assigning variable x");} + } + current_statement__ = 15; + validate_non_negative_index("y", "N", N); + std::vector y; + y = std::vector(N, 0); + + current_statement__ = 16; + beta0 = normal_rng(0, 1, base_rng__); + current_statement__ = 17; + beta1 = normal_rng(0, 1, base_rng__); + current_statement__ = 20; + if (lcm_sym8__) { + current_statement__ = 18; + assign(theta_std, cons_list(index_uni(1), nil_index_list()), + normal_rng(0, 1, base_rng__), "assigning variable theta_std"); + for (size_t i = 2; i <= N; ++i) { + current_statement__ = 18; + assign(theta_std, cons_list(index_uni(i), nil_index_list()), + normal_rng(0, 1, base_rng__), "assigning variable theta_std");} + } + current_statement__ = 21; + tau_theta = gamma_rng(3.2761, 1.81, base_rng__); + lcm_sym17__ = inv_sqrt(tau_theta); + sigma_theta = lcm_sym17__; + assign(lcm_sym15__, nil_index_list(), multiply(theta_std, lcm_sym17__), + "assigning variable lcm_sym15__"); + assign(theta, nil_index_list(), lcm_sym15__, "assigning variable theta"); + current_statement__ = 25; + if (lcm_sym8__) { + current_statement__ = 22; + assign(x, cons_list(index_uni(1), nil_index_list()), + normal_rng(0, 1, base_rng__), "assigning variable x"); + current_statement__ = 23; + assign(y, cons_list(index_uni(1), nil_index_list()), + poisson_log_rng( + ((stan::math::fma(beta1, x[(1 - 1)], + (stan::math::log(E)[(1 - 1)] + beta0)) + phi[(1 - 1)]) + + lcm_sym15__[(1 - 1)]), base_rng__), "assigning variable y"); + for (size_t i = 2; i <= N; ++i) { + current_statement__ = 22; + assign(x, cons_list(index_uni(i), nil_index_list()), + normal_rng(0, 1, base_rng__), "assigning variable x"); + current_statement__ = 23; + assign(y, cons_list(index_uni(i), nil_index_list()), + poisson_log_rng( + ((stan::math::fma(beta1, x[(i - 1)], + (stan::math::log(E)[(i - 1)] + beta0)) + phi[(i - 1)]) + + lcm_sym15__[(i - 1)]), base_rng__), "assigning variable y");} + } + current_statement__ = 10; + current_statement__ = 10; + check_greater_or_equal(function__, "tau_theta", tau_theta, 0); + current_statement__ = 11; + current_statement__ = 11; + check_greater_or_equal(function__, "sigma_theta", lcm_sym17__, 0); + vars__.push_back(beta0); + vars__.push_back(beta1); + vars__.push_back(tau_theta); + vars__.push_back(lcm_sym17__); + if (lcm_sym8__) { + vars__.push_back(lcm_sym15__[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + vars__.push_back(lcm_sym15__[(sym1__ - 1)]);} + } + if (lcm_sym8__) { + vars__.push_back(theta_std[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + vars__.push_back(theta_std[(sym1__ - 1)]);} + } + if (lcm_sym8__) { + vars__.push_back(x[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + vars__.push_back(x[(sym1__ - 1)]);} + } + if (lcm_sym8__) { + vars__.push_back(y[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + vars__.push_back(y[(sym1__ - 1)]);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + double lcm_sym7__; + double lcm_sym6__; + double lcm_sym5__; + double lcm_sym4__; + int lcm_sym3__; + int lcm_sym2__; + int lcm_sym1__; + int pos__; + + pos__ = 1; + double tau_phi; + + current_statement__ = 1; + tau_phi = context__.vals_r("tau_phi")[(1 - 1)]; + current_statement__ = 1; + tau_phi = stan::math::lb_free(tau_phi, 0); + lcm_sym2__ = (N - 1); + validate_non_negative_index("phi_std_raw", "(N - 1)", lcm_sym2__); + Eigen::Matrix phi_std_raw; + phi_std_raw = Eigen::Matrix(lcm_sym2__); + + { + std::vector phi_std_raw_flat__; + current_statement__ = 2; + assign(phi_std_raw_flat__, nil_index_list(), + context__.vals_r("phi_std_raw"), + "assigning variable phi_std_raw_flat__"); + current_statement__ = 2; + pos__ = 1; + lcm_sym1__ = logical_gte(lcm_sym2__, 1); + if (lcm_sym1__) { + current_statement__ = 2; + assign(phi_std_raw, cons_list(index_uni(1), nil_index_list()), + phi_std_raw_flat__[(1 - 1)], "assigning variable phi_std_raw"); + current_statement__ = 2; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= lcm_sym2__; ++sym1__) { + current_statement__ = 2; + assign(phi_std_raw, + cons_list(index_uni(sym1__), nil_index_list()), + phi_std_raw_flat__[(pos__ - 1)], + "assigning variable phi_std_raw"); + current_statement__ = 2; + pos__ = (pos__ + 1);} + } + } + vars__.push_back(tau_phi); + if (lcm_sym1__) { + vars__.push_back(phi_std_raw[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= lcm_sym2__; ++sym1__) { + vars__.push_back(phi_std_raw[(sym1__ - 1)]);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("tau_phi"); + names__.push_back("phi_std_raw"); + names__.push_back("sigma_phi"); + names__.push_back("phi"); + names__.push_back("beta0"); + names__.push_back("beta1"); + names__.push_back("tau_theta"); + names__.push_back("sigma_theta"); + names__.push_back("theta"); + names__.push_back("theta_std"); + names__.push_back("x"); + names__.push_back("y"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back((N - 1)); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(N); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(N); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(N); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(N); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(N); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "tau_phi"); + for (size_t sym54__ = 1; sym54__ <= (N - 1); ++sym54__) { + { + param_names__.push_back(std::string() + "phi_std_raw" + '.' + std::to_string(sym54__)); + }} + if (emit_transformed_parameters__) { + param_names__.push_back(std::string() + "sigma_phi"); + for (size_t sym54__ = 1; sym54__ <= N; ++sym54__) { + { + param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym54__)); + }} + } + + if (emit_generated_quantities__) { + param_names__.push_back(std::string() + "beta0"); + param_names__.push_back(std::string() + "beta1"); + param_names__.push_back(std::string() + "tau_theta"); + param_names__.push_back(std::string() + "sigma_theta"); + for (size_t sym54__ = 1; sym54__ <= N; ++sym54__) { + { + param_names__.push_back(std::string() + "theta" + '.' + std::to_string(sym54__)); + }} + for (size_t sym54__ = 1; sym54__ <= N; ++sym54__) { + { + param_names__.push_back(std::string() + "theta_std" + '.' + std::to_string(sym54__)); + }} + for (size_t sym54__ = 1; sym54__ <= N; ++sym54__) { + { + param_names__.push_back(std::string() + "x" + '.' + std::to_string(sym54__)); + }} + for (size_t sym54__ = 1; sym54__ <= N; ++sym54__) { + { + param_names__.push_back(std::string() + "y" + '.' + std::to_string(sym54__)); + }} + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "tau_phi"); + for (size_t sym54__ = 1; sym54__ <= (N - 1); ++sym54__) { + { + param_names__.push_back(std::string() + "phi_std_raw" + '.' + std::to_string(sym54__)); + }} + if (emit_transformed_parameters__) { + param_names__.push_back(std::string() + "sigma_phi"); + for (size_t sym54__ = 1; sym54__ <= N; ++sym54__) { + { + param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym54__)); + }} + } + + if (emit_generated_quantities__) { + param_names__.push_back(std::string() + "beta0"); + param_names__.push_back(std::string() + "beta1"); + param_names__.push_back(std::string() + "tau_theta"); + param_names__.push_back(std::string() + "sigma_theta"); + for (size_t sym54__ = 1; sym54__ <= N; ++sym54__) { + { + param_names__.push_back(std::string() + "theta" + '.' + std::to_string(sym54__)); + }} + for (size_t sym54__ = 1; sym54__ <= N; ++sym54__) { + { + param_names__.push_back(std::string() + "theta_std" + '.' + std::to_string(sym54__)); + }} + for (size_t sym54__ = 1; sym54__ <= N; ++sym54__) { + { + param_names__.push_back(std::string() + "x" + '.' + std::to_string(sym54__)); + }} + for (size_t sym54__ = 1; sym54__ <= N; ++sym54__) { + { + param_names__.push_back(std::string() + "y" + '.' + std::to_string(sym54__)); + }} + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"tau_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi_std_raw\",\"type\":{\"name\":\"vector\",\"length\":" << (N - 1) << "},\"block\":\"parameters\"},{\"name\":\"sigma_phi\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"},{\"name\":\"beta0\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"beta1\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"tau_theta\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"sigma_theta\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"theta\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"generated_quantities\"},{\"name\":\"theta_std\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"generated_quantities\"},{\"name\":\"x\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"generated_quantities\"},{\"name\":\"y\",\"type\":{\"name\":\"array\",\"length\":" << N << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"tau_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi_std_raw\",\"type\":{\"name\":\"vector\",\"length\":" << (N - 1) << "},\"block\":\"parameters\"},{\"name\":\"sigma_phi\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"},{\"name\":\"beta0\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"beta1\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"tau_theta\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"sigma_theta\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"theta\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"generated_quantities\"},{\"name\":\"theta_std\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"generated_quantities\"},{\"name\":\"x\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"generated_quantities\"},{\"name\":\"y\",\"type\":{\"name\":\"array\",\"length\":" << N << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef expr_prop_fail4_model_namespace::expr_prop_fail4_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-fail5.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace expr_prop_fail5_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'expr-prop-fail5.stan', line 71, column 2 to column 33)", + " (in 'expr-prop-fail5.stan', line 72, column 2 to column 31)", + " (in 'expr-prop-fail5.stan', line 73, column 2 to column 23)", + " (in 'expr-prop-fail5.stan', line 74, column 2 to column 30)", + " (in 'expr-prop-fail5.stan', line 80, column 2 to column 51)", + " (in 'expr-prop-fail5.stan', line 81, column 2 to column 49)", + " (in 'expr-prop-fail5.stan', line 82, column 2 to column 49)", + " (in 'expr-prop-fail5.stan', line 83, column 2 to column 10)", + " (in 'expr-prop-fail5.stan', line 89, column 6 to column 20)", + " (in 'expr-prop-fail5.stan', line 90, column 6 to column 18)", + " (in 'expr-prop-fail5.stan', line 88, column 32 to line 91, column 5)", + " (in 'expr-prop-fail5.stan', line 93, column 6 to column 45)", + " (in 'expr-prop-fail5.stan', line 94, column 6 to column 23)", + " (in 'expr-prop-fail5.stan', line 92, column 38 to line 95, column 5)", + " (in 'expr-prop-fail5.stan', line 92, column 4 to line 95, column 5)", + " (in 'expr-prop-fail5.stan', line 87, column 20 to line 96, column 3)", + " (in 'expr-prop-fail5.stan', line 87, column 2 to line 96, column 3)", + " (in 'expr-prop-fail5.stan', line 26, column 4 to column 34)", + " (in 'expr-prop-fail5.stan', line 29, column 6 to column 32)", + " (in 'expr-prop-fail5.stan', line 32, column 8 to column 37)", + " (in 'expr-prop-fail5.stan', line 33, column 8 to column 32)", + " (in 'expr-prop-fail5.stan', line 43, column 8 to line 44, column 83)", + " (in 'expr-prop-fail5.stan', line 30, column 37 to line 45, column 7)", + " (in 'expr-prop-fail5.stan', line 28, column 22 to line 46, column 5)", + " (in 'expr-prop-fail5.stan', line 25, column 47 to line 48, column 3)", + " (in 'expr-prop-fail5.stan', line 124, column 2 to column 23)", + " (in 'expr-prop-fail5.stan', line 109, column 2 to column 29)", + " (in 'expr-prop-fail5.stan', line 115, column 8 to column 37)", + " (in 'expr-prop-fail5.stan', line 116, column 8 to column 41)", + " (in 'expr-prop-fail5.stan', line 114, column 40 to line 117, column 7)", + " (in 'expr-prop-fail5.stan', line 118, column 6 to column 37)", + " (in 'expr-prop-fail5.stan', line 113, column 22 to line 119, column 5)", + " (in 'expr-prop-fail5.stan', line 112, column 20 to line 120, column 3)", + " (in 'expr-prop-fail5.stan', line 112, column 2 to line 120, column 3)", + " (in 'expr-prop-fail5.stan', line 52, column 2 to column 20)", + " (in 'expr-prop-fail5.stan', line 53, column 2 to column 27)", + " (in 'expr-prop-fail5.stan', line 54, column 2 to column 44)", + " (in 'expr-prop-fail5.stan', line 58, column 2 to column 38)", + " (in 'expr-prop-fail5.stan', line 60, column 2 to column 45)", + " (in 'expr-prop-fail5.stan', line 61, column 2 to column 44)", + " (in 'expr-prop-fail5.stan', line 8, column 8 to column 17)", + " (in 'expr-prop-fail5.stan', line 7, column 6 to line 8, column 17)", + " (in 'expr-prop-fail5.stan', line 5, column 31 to line 10, column 3)", + " (in 'expr-prop-fail5.stan', line 65, column 4 to column 35)", + " (in 'expr-prop-fail5.stan', line 64, column 2 to line 65, column 35)", + " (in 'expr-prop-fail5.stan', line 15, column 6 to column 32)", + " (in 'expr-prop-fail5.stan', line 19, column 8 to column 17)", + " (in 'expr-prop-fail5.stan', line 18, column 6 to line 19, column 17)", + " (in 'expr-prop-fail5.stan', line 13, column 37 to line 20, column 5)", + " (in 'expr-prop-fail5.stan', line 12, column 30 to line 22, column 3)", + " (in 'expr-prop-fail5.stan', line 67, column 4 to column 33)", + " (in 'expr-prop-fail5.stan', line 66, column 2 to line 67, column 33)", + " (in 'expr-prop-fail5.stan', line 9, column 4 to column 13)", + " (in 'expr-prop-fail5.stan', line 21, column 4 to column 13)", + " (in 'expr-prop-fail5.stan', line 30, column 6 to line 45, column 7)", + " (in 'expr-prop-fail5.stan', line 28, column 4 to line 46, column 5)", + " (in 'expr-prop-fail5.stan', line 47, column 4 to column 15)"}; + + +int +first_capture(const std::vector& y_i, std::ostream* pstream__) { + using local_scalar_t__ = double; + const static bool propto__ = true; + (void) propto__; + + try { + int lcm_sym33__; + int lcm_sym32__; + int lcm_sym31__; + int lcm_sym30__; + { + lcm_sym31__ = size(y_i); + if (logical_gte(lcm_sym31__, 1)) { + current_statement__ = 42; + if (y_i[(1 - 1)]) { + current_statement__ = 41; + return 1; + } + for (size_t k = 2; k <= lcm_sym31__; ++k) { + current_statement__ = 42; + if (y_i[(k - 1)]) { + current_statement__ = 41; + return k; + } } + } + current_statement__ = 53; + return 0; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct first_capture_functor__ { +int +operator()(const std::vector& y_i, std::ostream* pstream__) const +{ +return first_capture(y_i, pstream__); +} +}; + +int +last_capture(const std::vector& y_i, std::ostream* pstream__) { + using local_scalar_t__ = double; + const static bool propto__ = true; + (void) propto__; + + try { + int lcm_sym39__; + int lcm_sym38__; + int lcm_sym37__; + int lcm_sym36__; + int lcm_sym35__; + int lcm_sym34__; + { + lcm_sym37__ = (size(y_i) - 1); + if (logical_gte(lcm_sym37__, 0)) { + int k; + + lcm_sym36__ = (size(y_i) - 0); + current_statement__ = 48; + if (y_i[(lcm_sym36__ - 1)]) { + current_statement__ = 47; + return lcm_sym36__; + } + for (size_t k_rev = 1; k_rev <= lcm_sym37__; ++k_rev) { + int k; + + lcm_sym35__ = (size(y_i) - k_rev); + current_statement__ = 48; + if (y_i[(lcm_sym35__ - 1)]) { + current_statement__ = 47; + return lcm_sym35__; + } } + } + current_statement__ = 54; + return 0; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct last_capture_functor__ { +int +operator()(const std::vector& y_i, std::ostream* pstream__) const +{ +return last_capture(y_i, pstream__); +} +}; + +template +Eigen::Matrix::type, -1, -1> +prob_uncaptured(const int& nind, const int& n_occasions, + const Eigen::Matrix& p, + const Eigen::Matrix& phi, + std::ostream* pstream__) { + using local_scalar_t__ = typename boost::math::tools::promote_args::type; + const static bool propto__ = true; + (void) propto__; + + try { + double lcm_sym51__; + double lcm_sym50__; + double lcm_sym49__; + double lcm_sym48__; + double lcm_sym47__; + int lcm_sym46__; + int lcm_sym45__; + int lcm_sym44__; + int lcm_sym43__; + int lcm_sym42__; + int lcm_sym41__; + int lcm_sym40__; + { + current_statement__ = 18; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 18; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix chi; + chi = Eigen::Matrix(nind, n_occasions); + + lcm_sym41__ = logical_gte(nind, 1); + if (lcm_sym41__) { + lcm_sym40__ = logical_gte(n_occasions, 1); + if (lcm_sym40__) { + lcm_sym51__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym51__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 18; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), lcm_sym51__, + "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 18; + if (lcm_sym40__) { + lcm_sym51__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym51__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 18; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym51__, "assigning variable chi");} + } } + } + current_statement__ = 56; + if (lcm_sym41__) { + current_statement__ = 19; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(n_occasions), nil_index_list())), 1.0, + "assigning variable chi"); + lcm_sym44__ = (n_occasions - 1); + lcm_sym42__ = logical_gte(lcm_sym44__, 1); + if (lcm_sym42__) { + int t_curr; + + int t_next; + + lcm_sym46__ = (lcm_sym44__ + 1); + current_statement__ = 22; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym46__ - 1)), + nil_index_list())), "p"))), + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym46__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + "phi"))), "assigning variable chi"); + for (size_t t = 2; t <= lcm_sym44__; ++t) { + int t_curr; + + lcm_sym43__ = (n_occasions - t); + int t_next; + + lcm_sym45__ = (lcm_sym43__ + 1); + current_statement__ = 22; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym45__ - 1)), + nil_index_list())), "p"))), + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym45__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + "phi"))), "assigning variable chi");} + } + for (size_t i = 2; i <= nind; ++i) { + current_statement__ = 19; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(n_occasions), nil_index_list())), 1.0, + "assigning variable chi"); + current_statement__ = 55; + if (lcm_sym42__) { + int t_curr; + + int t_next; + + lcm_sym46__ = (lcm_sym44__ + 1); + current_statement__ = 22; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym46__ - 1)), + nil_index_list())), "p"))), + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym46__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + "phi"))), "assigning variable chi"); + for (size_t t = 2; t <= lcm_sym44__; ++t) { + int t_curr; + + lcm_sym43__ = (n_occasions - t); + int t_next; + + lcm_sym45__ = (lcm_sym43__ + 1); + current_statement__ = 22; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym45__ - 1)), + nil_index_list())), "p"))), + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym45__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + "phi"))), "assigning variable chi");} + } } + } + current_statement__ = 57; + return chi; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct prob_uncaptured_functor__ { +template +Eigen::Matrix::type, -1, -1> +operator()(const int& nind, const int& n_occasions, + const Eigen::Matrix& p, + const Eigen::Matrix& phi, std::ostream* pstream__) const +{ +return prob_uncaptured(nind, n_occasions, p, phi, pstream__); +} +}; + +class expr_prop_fail5_model : public model_base_crtp { + + private: + int lcm_sym163__; + int lcm_sym162__; + int lcm_sym161__; + int lcm_sym160__; + int lcm_sym159__; + int lcm_sym158__; + int lcm_sym157__; + int lcm_sym156__; + int lcm_sym155__; + int lcm_sym154__; + int lcm_sym153__; + int lcm_sym152__; + int lcm_sym151__; + int lcm_sym150__; + int lcm_sym149__; + int lcm_sym148__; + int lcm_sym147__; + int lcm_sym146__; + int lcm_sym145__; + int lcm_sym144__; + int lcm_sym143__; + int lcm_sym142__; + int lcm_sym141__; + int lcm_sym140__; + int pos__; + int nind; + int n_occasions; + std::vector> y; + int n_occ_minus_1; + std::vector first; + std::vector last; + + public: + ~expr_prop_fail5_model() { } + + std::string model_name() const { return "expr_prop_fail5_model"; } + + expr_prop_fail5_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "expr_prop_fail5_model_namespace::expr_prop_fail5_model"; + (void) function__; // suppress unused var warning + + try { + + + + + + + + + + + + + + + + + + + + + + + + + + pos__ = 1; + context__.validate_dims("data initialization","nind","int", + context__.to_vec()); + + current_statement__ = 35; + nind = context__.vals_i("nind")[(1 - 1)]; + context__.validate_dims("data initialization","n_occasions","int", + context__.to_vec()); + + current_statement__ = 36; + n_occasions = context__.vals_i("n_occasions")[(1 - 1)]; + current_statement__ = 37; + validate_non_negative_index("y", "nind", nind); + current_statement__ = 37; + validate_non_negative_index("y", "n_occasions", n_occasions); + context__.validate_dims("data initialization","y","int", + context__.to_vec(nind, n_occasions)); + y = std::vector>(nind, std::vector(n_occasions, 0)); + + { + std::vector y_flat__; + current_statement__ = 37; + assign(y_flat__, nil_index_list(), context__.vals_i("y"), + "assigning variable y_flat__"); + current_statement__ = 37; + pos__ = 1; + lcm_sym140__ = logical_gte(n_occasions, 1); + if (lcm_sym140__) { + { + lcm_sym141__ = logical_gte(nind, 1); + if (lcm_sym141__) { + current_statement__ = 37; + assign(y, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + y_flat__[(1 - 1)], "assigning variable y"); + current_statement__ = 37; + pos__ = 2; + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + current_statement__ = 37; + assign(y, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 37; + pos__ = (pos__ + 1);} + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 37; + if (lcm_sym141__) { + current_statement__ = 37; + assign(y, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 37; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + current_statement__ = 37; + assign(y, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 37; + pos__ = (pos__ + 1);} + } } + } + } else { + lcm_sym141__ = logical_gte(nind, 1); + } + } + + current_statement__ = 38; + n_occ_minus_1 = (n_occasions - 1); + current_statement__ = 39; + validate_non_negative_index("first", "nind", nind); + first = std::vector(nind, 0); + + current_statement__ = 40; + validate_non_negative_index("last", "nind", nind); + last = std::vector(nind, 0); + + current_statement__ = 45; + if (lcm_sym141__) { + int inline_sym21__; + int inline_sym23__; + + inline_sym23__ = 0; + for (size_t inline_sym24__ = 1; inline_sym24__ <= 1; ++inline_sym24__) { + lcm_sym149__ = size(y[(1 - 1)]); + for (size_t inline_sym22__ = 1; inline_sym22__ <= lcm_sym149__; + ++inline_sym22__) { + current_statement__ = 42; + if (y[(1 - 1)][(inline_sym22__ - 1)]) { + inline_sym23__ = 1; + inline_sym21__ = inline_sym22__; + break; + } } + if (inline_sym23__) { + break; + } + inline_sym23__ = 1; + inline_sym21__ = 0; + break;} + assign(first, cons_list(index_uni(1), nil_index_list()), + inline_sym21__, "assigning variable first"); + for (size_t i = 2; i <= nind; ++i) { + int inline_sym21__; + int inline_sym23__; + + inline_sym23__ = 0; + for (size_t inline_sym24__ = 1; inline_sym24__ <= 1; + ++inline_sym24__) { + lcm_sym148__ = size(y[(i - 1)]); + for (size_t inline_sym22__ = 1; inline_sym22__ <= lcm_sym148__; + ++inline_sym22__) { + current_statement__ = 42; + if (y[(i - 1)][(inline_sym22__ - 1)]) { + inline_sym23__ = 1; + inline_sym21__ = inline_sym22__; + break; + } } + if (inline_sym23__) { + break; + } + inline_sym23__ = 1; + inline_sym21__ = 0; + break;} + assign(first, cons_list(index_uni(i), nil_index_list()), + inline_sym21__, "assigning variable first");} + } + current_statement__ = 52; + if (lcm_sym141__) { + int inline_sym25__; + int inline_sym28__; + + inline_sym28__ = 0; + for (size_t inline_sym29__ = 1; inline_sym29__ <= 1; ++inline_sym29__) { + lcm_sym149__ = size(y[(1 - 1)]); + lcm_sym146__ = (lcm_sym149__ - 1); + for (size_t inline_sym27__ = 0; inline_sym27__ <= lcm_sym146__; + ++inline_sym27__) { + int inline_sym26__; + + lcm_sym145__ = (lcm_sym149__ - inline_sym27__); + inline_sym26__ = lcm_sym145__; + current_statement__ = 48; + if (y[(1 - 1)][(lcm_sym145__ - 1)]) { + inline_sym28__ = 1; + inline_sym25__ = lcm_sym145__; + break; + } } + if (inline_sym28__) { + break; + } + inline_sym28__ = 1; + inline_sym25__ = 0; + break;} + assign(last, cons_list(index_uni(1), nil_index_list()), + inline_sym25__, "assigning variable last"); + for (size_t i = 2; i <= nind; ++i) { + int inline_sym25__; + int inline_sym28__; + + inline_sym28__ = 0; + for (size_t inline_sym29__ = 1; inline_sym29__ <= 1; + ++inline_sym29__) { + lcm_sym148__ = size(y[(i - 1)]); + lcm_sym144__ = (lcm_sym148__ - 1); + for (size_t inline_sym27__ = 0; inline_sym27__ <= lcm_sym144__; + ++inline_sym27__) { + int inline_sym26__; + + lcm_sym143__ = (lcm_sym148__ - inline_sym27__); + inline_sym26__ = lcm_sym143__; + current_statement__ = 48; + if (y[(i - 1)][(lcm_sym143__ - 1)]) { + inline_sym28__ = 1; + inline_sym25__ = lcm_sym143__; + break; + } } + if (inline_sym28__) { + break; + } + inline_sym28__ = 1; + inline_sym25__ = 0; + break;} + assign(last, cons_list(index_uni(i), nil_index_list()), + inline_sym25__, "assigning variable last");} + } + current_statement__ = 35; + current_statement__ = 35; + check_greater_or_equal(function__, "nind", nind, 0); + current_statement__ = 36; + current_statement__ = 36; + check_greater_or_equal(function__, "n_occasions", n_occasions, 2); + current_statement__ = 37; + if (lcm_sym141__) { + current_statement__ = 37; + if (lcm_sym140__) { + current_statement__ = 37; + current_statement__ = 37; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 37; + current_statement__ = 37; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(sym2__ - 1)], 0);} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 37; + if (lcm_sym140__) { + current_statement__ = 37; + current_statement__ = 37; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 37; + current_statement__ = 37; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(sym2__ - 1)], 0);} + } } + } + current_statement__ = 37; + if (lcm_sym141__) { + current_statement__ = 37; + if (lcm_sym140__) { + current_statement__ = 37; + current_statement__ = 37; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 37; + current_statement__ = 37; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(sym2__ - 1)], 1);} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 37; + if (lcm_sym140__) { + current_statement__ = 37; + current_statement__ = 37; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 37; + current_statement__ = 37; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(sym2__ - 1)], 1);} + } } + } + current_statement__ = 39; + if (lcm_sym141__) { + current_statement__ = 39; + current_statement__ = 39; + check_greater_or_equal(function__, "first[sym1__]", first[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 39; + current_statement__ = 39; + check_greater_or_equal(function__, "first[sym1__]", + first[(sym1__ - 1)], 0);} + } + current_statement__ = 39; + if (lcm_sym141__) { + current_statement__ = 39; + current_statement__ = 39; + check_less_or_equal(function__, "first[sym1__]", first[(1 - 1)], + n_occasions); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 39; + current_statement__ = 39; + check_less_or_equal(function__, "first[sym1__]", + first[(sym1__ - 1)], n_occasions);} + } + current_statement__ = 40; + if (lcm_sym141__) { + current_statement__ = 40; + current_statement__ = 40; + check_greater_or_equal(function__, "last[sym1__]", last[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 40; + current_statement__ = 40; + check_greater_or_equal(function__, "last[sym1__]", + last[(sym1__ - 1)], 0);} + } + current_statement__ = 40; + if (lcm_sym141__) { + current_statement__ = 40; + current_statement__ = 40; + check_less_or_equal(function__, "last[sym1__]", last[(1 - 1)], + n_occasions); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 40; + current_statement__ = 40; + check_less_or_equal(function__, "last[sym1__]", last[(sym1__ - 1)], + n_occasions);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + num_params_r__ += 1; + num_params_r__ += 1; + current_statement__ = 3; + validate_non_negative_index("epsilon", "nind", nind); + num_params_r__ += nind; + num_params_r__ += 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "expr_prop_fail5_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + int lcm_sym139__; + int lcm_sym138__; + int lcm_sym137__; + int lcm_sym136__; + double lcm_sym135__; + double lcm_sym134__; + local_scalar_t__ lcm_sym133__; + local_scalar_t__ lcm_sym132__; + local_scalar_t__ lcm_sym131__; + double lcm_sym130__; + double lcm_sym129__; + double lcm_sym128__; + double lcm_sym127__; + double lcm_sym126__; + double lcm_sym125__; + double lcm_sym124__; + double lcm_sym123__; + double lcm_sym122__; + double lcm_sym121__; + double lcm_sym120__; + double lcm_sym119__; + int lcm_sym118__; + int lcm_sym117__; + int lcm_sym116__; + int lcm_sym115__; + int lcm_sym114__; + int lcm_sym113__; + int lcm_sym112__; + int lcm_sym111__; + int lcm_sym110__; + int lcm_sym109__; + int lcm_sym108__; + int lcm_sym107__; + int lcm_sym106__; + int lcm_sym105__; + int lcm_sym104__; + int lcm_sym103__; + int lcm_sym102__; + int lcm_sym101__; + int lcm_sym100__; + int lcm_sym99__; + int lcm_sym98__; + local_scalar_t__ mean_phi; + + current_statement__ = 1; + mean_phi = in__.scalar(); + current_statement__ = 1; + if (jacobian__) { + current_statement__ = 1; + mean_phi = stan::math::lub_constrain(mean_phi, 0, 1, lp__); + } else { + current_statement__ = 1; + mean_phi = stan::math::lub_constrain(mean_phi, 0, 1); + } + local_scalar_t__ mean_p; + + current_statement__ = 2; + mean_p = in__.scalar(); + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + mean_p = stan::math::lub_constrain(mean_p, 0, 1, lp__); + } else { + current_statement__ = 2; + mean_p = stan::math::lub_constrain(mean_p, 0, 1); + } + current_statement__ = 3; + validate_non_negative_index("epsilon", "nind", nind); + Eigen::Matrix epsilon; + epsilon = Eigen::Matrix(nind); + + current_statement__ = 3; + epsilon = in__.vector(nind); + local_scalar_t__ sigma; + + current_statement__ = 4; + sigma = in__.scalar(); + current_statement__ = 4; + if (jacobian__) { + current_statement__ = 4; + sigma = stan::math::lub_constrain(sigma, 0, 5, lp__); + } else { + current_statement__ = 4; + sigma = stan::math::lub_constrain(sigma, 0, 5); + } + current_statement__ = 5; + validate_non_negative_index("phi", "nind", nind); + lcm_sym110__ = (n_occasions - 1); + validate_non_negative_index("phi", "n_occ_minus_1", lcm_sym110__); + Eigen::Matrix phi; + phi = Eigen::Matrix(nind, lcm_sym110__); + + lcm_sym99__ = logical_gte(nind, 1); + if (lcm_sym99__) { + { + lcm_sym100__ = logical_gte(lcm_sym110__, 1); + if (lcm_sym100__) { + { + lcm_sym135__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym135__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym110__; ++sym2__) { + current_statement__ = 5; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym135__, "assigning variable phi");} + } + } else { + lcm_sym135__ = std::numeric_limits::quiet_NaN(); + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 5; + if (lcm_sym100__) { + current_statement__ = 5; + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym135__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym110__; ++sym2__) { + current_statement__ = 5; + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym135__, "assigning variable phi");} + } } + } + } else { + lcm_sym135__ = std::numeric_limits::quiet_NaN(); + } + current_statement__ = 6; + validate_non_negative_index("p", "nind", nind); + current_statement__ = 6; + validate_non_negative_index("p", "n_occ_minus_1", lcm_sym110__); + Eigen::Matrix p; + p = Eigen::Matrix(nind, lcm_sym110__); + + current_statement__ = 6; + if (lcm_sym99__) { + lcm_sym100__ = logical_gte(lcm_sym110__, 1); + if (lcm_sym100__) { + current_statement__ = 6; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym135__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym110__; ++sym2__) { + current_statement__ = 6; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym135__, "assigning variable p");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 6; + if (lcm_sym100__) { + current_statement__ = 6; + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym135__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym110__; ++sym2__) { + current_statement__ = 6; + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym135__, "assigning variable p");} + } } + } + current_statement__ = 7; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 7; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix chi; + chi = Eigen::Matrix(nind, n_occasions); + + current_statement__ = 7; + if (lcm_sym99__) { + lcm_sym98__ = logical_gte(n_occasions, 1); + if (lcm_sym98__) { + current_statement__ = 7; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym135__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 7; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym135__, "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 7; + if (lcm_sym98__) { + current_statement__ = 7; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym135__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 7; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym135__, "assigning variable chi");} + } } + } + local_scalar_t__ mu; + + current_statement__ = 8; + mu = lcm_sym135__; + lcm_sym133__ = logit(mean_phi); + mu = lcm_sym133__; + current_statement__ = 17; + if (lcm_sym99__) { + lcm_sym137__ = first[(1 - 1)]; + lcm_sym112__ = (lcm_sym137__ - 1); + if (logical_gte(lcm_sym112__, 1)) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable p"); + for (size_t t = 2; t <= lcm_sym112__; ++t) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable p");} + } + current_statement__ = 15; + if (logical_gte(lcm_sym110__, lcm_sym137__)) { + lcm_sym132__ = inv_logit((lcm_sym133__ + epsilon[(1 - 1)])); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym137__), nil_index_list())), + lcm_sym132__, "assigning variable phi"); + lcm_sym118__ = (lcm_sym137__ + 1); + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym137__), nil_index_list())), mean_p, + "assigning variable p"); + for (size_t t = lcm_sym118__; t <= lcm_sym110__; ++t) { + current_statement__ = 12; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), lcm_sym132__, + "assigning variable phi"); + current_statement__ = 13; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), mean_p, + "assigning variable p");} + } + for (size_t i = 2; i <= nind; ++i) { + lcm_sym136__ = first[(i - 1)]; + lcm_sym111__ = (lcm_sym136__ - 1); + if (logical_gte(lcm_sym111__, 1)) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable p"); + for (size_t t = 2; t <= lcm_sym111__; ++t) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable p");} + } + current_statement__ = 15; + if (logical_gte(lcm_sym110__, lcm_sym136__)) { + lcm_sym131__ = inv_logit((lcm_sym133__ + epsilon[(i - 1)])); + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym136__), nil_index_list())), + lcm_sym131__, "assigning variable phi"); + lcm_sym117__ = (lcm_sym136__ + 1); + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym136__), nil_index_list())), + mean_p, "assigning variable p"); + for (size_t t = lcm_sym117__; t <= lcm_sym110__; ++t) { + current_statement__ = 12; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), lcm_sym131__, + "assigning variable phi"); + current_statement__ = 13; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), mean_p, + "assigning variable p");} + } } + } + Eigen::Matrix inline_sym11__; + int inline_sym19__; + + inline_sym19__ = 0; + for (size_t inline_sym20__ = 1; inline_sym20__ <= 1; ++inline_sym20__) { + current_statement__ = 18; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 18; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix inline_sym12__; + inline_sym12__ = Eigen::Matrix(nind, n_occasions); + + for (size_t inline_sym14__ = 1; inline_sym14__ <= nind; + ++inline_sym14__) { + if (logical_gte(n_occasions, 1)) { + current_statement__ = 18; + assign(inline_sym12__, + cons_list(index_uni(inline_sym14__), + cons_list(index_uni(1), nil_index_list())), lcm_sym135__, + "assigning variable inline_sym12__"); + for (size_t inline_sym13__ = 2; inline_sym13__ <= n_occasions; + ++inline_sym13__) { + current_statement__ = 18; + assign(inline_sym12__, + cons_list(index_uni(inline_sym14__), + cons_list(index_uni(inline_sym13__), nil_index_list())), + lcm_sym135__, "assigning variable inline_sym12__");} + } + if (inline_sym19__) { + break; + } } + if (inline_sym19__) { + break; + } + for (size_t inline_sym18__ = 1; inline_sym18__ <= nind; + ++inline_sym18__) { + current_statement__ = 19; + assign(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(n_occasions), nil_index_list())), 1.0, + "assigning variable inline_sym12__"); + if (logical_gte(lcm_sym110__, 1)) { + int inline_sym15__; + + int inline_sym16__; + + lcm_sym114__ = (lcm_sym110__ + 1); + current_statement__ = 22; + assign(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym110__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym110__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni((lcm_sym114__ - 1)), + nil_index_list())), "p"))), + rvalue(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym114__), nil_index_list())), + "inline_sym12__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym110__), nil_index_list())), + "phi"))), "assigning variable inline_sym12__"); + for (size_t inline_sym17__ = 2; inline_sym17__ <= lcm_sym110__; + ++inline_sym17__) { + int inline_sym15__; + + int inline_sym16__; + + lcm_sym109__ = (n_occasions - inline_sym17__); + lcm_sym113__ = (lcm_sym109__ + 1); + current_statement__ = 22; + assign(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym109__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym109__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni((lcm_sym113__ - 1)), + nil_index_list())), "p"))), + rvalue(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym113__), nil_index_list())), + "inline_sym12__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym109__), nil_index_list())), + "phi"))), "assigning variable inline_sym12__");} + } + if (inline_sym19__) { + break; + } } + if (inline_sym19__) { + break; + } + inline_sym19__ = 1; + assign(inline_sym11__, nil_index_list(), inline_sym12__, + "assigning variable inline_sym11__"); + break;} + assign(chi, nil_index_list(), inline_sym11__, "assigning variable chi"); + current_statement__ = 5; + current_statement__ = 5; + check_greater_or_equal(function__, "phi", phi, 0); + current_statement__ = 5; + current_statement__ = 5; + check_less_or_equal(function__, "phi", phi, 1); + current_statement__ = 6; + current_statement__ = 6; + check_greater_or_equal(function__, "p", p, 0); + current_statement__ = 6; + current_statement__ = 6; + check_less_or_equal(function__, "p", p, 1); + current_statement__ = 7; + current_statement__ = 7; + check_greater_or_equal(function__, "chi", inline_sym11__, 0); + current_statement__ = 7; + current_statement__ = 7; + check_less_or_equal(function__, "chi", inline_sym11__, 1); + { + current_statement__ = 27; + lp_accum__.add(normal_log(epsilon, 0, sigma)); + current_statement__ = 34; + if (lcm_sym99__) { + lcm_sym137__ = first[(1 - 1)]; + if (logical_gt(lcm_sym137__, 0)) { + lcm_sym139__ = last[(1 - 1)]; + lcm_sym118__ = (lcm_sym137__ + 1); + if (logical_gte(lcm_sym139__, lcm_sym118__)) { + current_statement__ = 28; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym118__ - 1)), + nil_index_list())), "phi"))); + lcm_sym116__ = (lcm_sym118__ + 1); + lp_accum__.add( + bernoulli_log(y[(1 - 1)][(lcm_sym118__ - 1)], + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym118__ - 1)), + nil_index_list())), "p"))); + for (size_t t = lcm_sym116__; t <= lcm_sym139__; ++t) { + current_statement__ = 28; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni((t - 1)), nil_index_list())), + "phi"))); + current_statement__ = 29; + lp_accum__.add( + bernoulli_log(y[(1 - 1)][(t - 1)], + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((t - 1)), nil_index_list())), + "p")));} + } + current_statement__ = 31; + lp_accum__.add( + bernoulli_log(1, + rvalue(inline_sym11__, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym139__), nil_index_list())), + "inline_sym11__"))); + } + for (size_t i = 2; i <= nind; ++i) { + lcm_sym136__ = first[(i - 1)]; + if (logical_gt(lcm_sym136__, 0)) { + lcm_sym138__ = last[(i - 1)]; + lcm_sym117__ = (lcm_sym136__ + 1); + if (logical_gte(lcm_sym138__, lcm_sym117__)) { + current_statement__ = 28; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym117__ - 1)), + nil_index_list())), "phi"))); + lcm_sym115__ = (lcm_sym117__ + 1); + lp_accum__.add( + bernoulli_log(y[(i - 1)][(lcm_sym117__ - 1)], + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym117__ - 1)), + nil_index_list())), "p"))); + for (size_t t = lcm_sym115__; t <= lcm_sym138__; ++t) { + current_statement__ = 28; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni((t - 1)), nil_index_list())), + "phi"))); + current_statement__ = 29; + lp_accum__.add( + bernoulli_log(y[(i - 1)][(t - 1)], + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((t - 1)), nil_index_list())), + "p")));} + } + current_statement__ = 31; + lp_accum__.add( + bernoulli_log(1, + rvalue(inline_sym11__, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym138__), nil_index_list())), + "inline_sym11__"))); + } } + } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "expr_prop_fail5_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + double lcm_sym97__; + double lcm_sym96__; + double lcm_sym95__; + double lcm_sym94__; + double lcm_sym93__; + double lcm_sym92__; + double lcm_sym91__; + double lcm_sym90__; + double lcm_sym89__; + double lcm_sym88__; + double lcm_sym87__; + double lcm_sym86__; + int lcm_sym85__; + int lcm_sym84__; + double lcm_sym83__; + double lcm_sym82__; + double lcm_sym81__; + double lcm_sym80__; + double lcm_sym79__; + local_scalar_t__ lcm_sym78__; + local_scalar_t__ lcm_sym77__; + double lcm_sym76__; + double lcm_sym75__; + int lcm_sym74__; + int lcm_sym73__; + int lcm_sym72__; + int lcm_sym71__; + int lcm_sym70__; + int lcm_sym69__; + int lcm_sym68__; + int lcm_sym67__; + int lcm_sym66__; + int lcm_sym65__; + int lcm_sym64__; + int lcm_sym63__; + int lcm_sym62__; + int lcm_sym61__; + int lcm_sym60__; + int lcm_sym59__; + int lcm_sym58__; + double mean_phi; + + current_statement__ = 1; + mean_phi = in__.scalar(); + current_statement__ = 1; + mean_phi = stan::math::lub_constrain(mean_phi, 0, 1); + double mean_p; + + current_statement__ = 2; + mean_p = in__.scalar(); + current_statement__ = 2; + mean_p = stan::math::lub_constrain(mean_p, 0, 1); + current_statement__ = 3; + validate_non_negative_index("epsilon", "nind", nind); + Eigen::Matrix epsilon; + epsilon = Eigen::Matrix(nind); + + current_statement__ = 3; + epsilon = in__.vector(nind); + double sigma; + + current_statement__ = 4; + sigma = in__.scalar(); + current_statement__ = 4; + sigma = stan::math::lub_constrain(sigma, 0, 5); + current_statement__ = 5; + validate_non_negative_index("phi", "nind", nind); + lcm_sym66__ = (n_occasions - 1); + validate_non_negative_index("phi", "n_occ_minus_1", lcm_sym66__); + Eigen::Matrix phi; + phi = Eigen::Matrix(nind, lcm_sym66__); + + lcm_sym59__ = logical_gte(nind, 1); + if (lcm_sym59__) { + { + lcm_sym60__ = logical_gte(lcm_sym66__, 1); + if (lcm_sym60__) { + { + lcm_sym81__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym81__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym66__; ++sym2__) { + current_statement__ = 5; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym81__, "assigning variable phi");} + } + } else { + lcm_sym81__ = std::numeric_limits::quiet_NaN(); + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 5; + if (lcm_sym60__) { + current_statement__ = 5; + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym81__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym66__; ++sym2__) { + current_statement__ = 5; + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym81__, "assigning variable phi");} + } } + } + } else { + lcm_sym81__ = std::numeric_limits::quiet_NaN(); + lcm_sym60__ = logical_gte(lcm_sym66__, 1); + } + current_statement__ = 6; + validate_non_negative_index("p", "nind", nind); + current_statement__ = 6; + validate_non_negative_index("p", "n_occ_minus_1", lcm_sym66__); + Eigen::Matrix p; + p = Eigen::Matrix(nind, lcm_sym66__); + + current_statement__ = 6; + if (lcm_sym59__) { + current_statement__ = 6; + if (lcm_sym60__) { + current_statement__ = 6; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym81__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym66__; ++sym2__) { + current_statement__ = 6; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), lcm_sym81__, + "assigning variable p");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 6; + if (lcm_sym60__) { + current_statement__ = 6; + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym81__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym66__; ++sym2__) { + current_statement__ = 6; + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym81__, "assigning variable p");} + } } + } + current_statement__ = 7; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 7; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix chi; + chi = Eigen::Matrix(nind, n_occasions); + + current_statement__ = 7; + if (lcm_sym59__) { + { + lcm_sym58__ = logical_gte(n_occasions, 1); + if (lcm_sym58__) { + current_statement__ = 7; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym81__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 7; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym81__, "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 7; + if (lcm_sym58__) { + current_statement__ = 7; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym81__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 7; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym81__, "assigning variable chi");} + } } + } + } else { + lcm_sym58__ = logical_gte(n_occasions, 1); + } + double mu; + + current_statement__ = 8; + mu = lcm_sym81__; + vars__.push_back(mean_phi); + vars__.push_back(mean_p); + if (lcm_sym59__) { + vars__.push_back(epsilon[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + vars__.push_back(epsilon[(sym1__ - 1)]);} + } + vars__.push_back(sigma); + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + lcm_sym79__ = logit(mean_phi); + mu = lcm_sym79__; + current_statement__ = 17; + if (lcm_sym59__) { + lcm_sym85__ = first[(1 - 1)]; + lcm_sym68__ = (lcm_sym85__ - 1); + if (logical_gte(lcm_sym68__, 1)) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable p"); + for (size_t t = 2; t <= lcm_sym68__; ++t) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable p");} + } + current_statement__ = 15; + if (logical_gte(lcm_sym66__, lcm_sym85__)) { + lcm_sym78__ = inv_logit((lcm_sym79__ + epsilon[(1 - 1)])); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym85__), nil_index_list())), + lcm_sym78__, "assigning variable phi"); + lcm_sym74__ = (lcm_sym85__ + 1); + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym85__), nil_index_list())), mean_p, + "assigning variable p"); + for (size_t t = lcm_sym74__; t <= lcm_sym66__; ++t) { + current_statement__ = 12; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), lcm_sym78__, + "assigning variable phi"); + current_statement__ = 13; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), mean_p, + "assigning variable p");} + } + for (size_t i = 2; i <= nind; ++i) { + lcm_sym84__ = first[(i - 1)]; + lcm_sym67__ = (lcm_sym84__ - 1); + if (logical_gte(lcm_sym67__, 1)) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable p"); + for (size_t t = 2; t <= lcm_sym67__; ++t) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable p");} + } + current_statement__ = 15; + if (logical_gte(lcm_sym66__, lcm_sym84__)) { + lcm_sym77__ = inv_logit((lcm_sym79__ + epsilon[(i - 1)])); + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym84__), nil_index_list())), + lcm_sym77__, "assigning variable phi"); + lcm_sym73__ = (lcm_sym84__ + 1); + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym84__), nil_index_list())), mean_p, + "assigning variable p"); + for (size_t t = lcm_sym73__; t <= lcm_sym66__; ++t) { + current_statement__ = 12; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), lcm_sym77__, + "assigning variable phi"); + current_statement__ = 13; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), mean_p, + "assigning variable p");} + } } + } + Eigen::Matrix inline_sym1__; + int inline_sym9__; + + inline_sym9__ = 0; + for (size_t inline_sym10__ = 1; inline_sym10__ <= 1; ++inline_sym10__) { + current_statement__ = 18; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 18; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix inline_sym2__; + inline_sym2__ = Eigen::Matrix(nind, n_occasions); + + for (size_t inline_sym4__ = 1; inline_sym4__ <= nind; ++inline_sym4__) { + if (lcm_sym58__) { + current_statement__ = 18; + assign(inline_sym2__, + cons_list(index_uni(inline_sym4__), + cons_list(index_uni(1), nil_index_list())), lcm_sym81__, + "assigning variable inline_sym2__"); + for (size_t inline_sym3__ = 2; inline_sym3__ <= n_occasions; + ++inline_sym3__) { + current_statement__ = 18; + assign(inline_sym2__, + cons_list(index_uni(inline_sym4__), + cons_list(index_uni(inline_sym3__), nil_index_list())), + lcm_sym81__, "assigning variable inline_sym2__");} + } + if (inline_sym9__) { + break; + } } + if (inline_sym9__) { + break; + } + for (size_t inline_sym8__ = 1; inline_sym8__ <= nind; ++inline_sym8__) { + current_statement__ = 19; + assign(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(n_occasions), nil_index_list())), 1.0, + "assigning variable inline_sym2__"); + if (lcm_sym60__) { + int inline_sym5__; + + int inline_sym6__; + + lcm_sym72__ = (lcm_sym66__ + 1); + current_statement__ = 22; + assign(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym66__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym66__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni((lcm_sym72__ - 1)), + nil_index_list())), "p"))), + rvalue(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym72__), nil_index_list())), + "inline_sym2__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym66__), nil_index_list())), + "phi"))), "assigning variable inline_sym2__"); + for (size_t inline_sym7__ = 2; inline_sym7__ <= lcm_sym66__; + ++inline_sym7__) { + int inline_sym5__; + + int inline_sym6__; + + lcm_sym65__ = (n_occasions - inline_sym7__); + lcm_sym71__ = (lcm_sym65__ + 1); + current_statement__ = 22; + assign(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym65__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym65__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni((lcm_sym71__ - 1)), + nil_index_list())), "p"))), + rvalue(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym71__), nil_index_list())), + "inline_sym2__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym65__), nil_index_list())), + "phi"))), "assigning variable inline_sym2__");} + } + if (inline_sym9__) { + break; + } } + if (inline_sym9__) { + break; + } + inline_sym9__ = 1; + assign(inline_sym1__, nil_index_list(), inline_sym2__, + "assigning variable inline_sym1__"); + break;} + assign(chi, nil_index_list(), inline_sym1__, "assigning variable chi"); + if (lcm_sym60__) { + if (lcm_sym59__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "phi")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), "phi"));} + } + for (size_t sym1__ = 2; sym1__ <= lcm_sym66__; ++sym1__) { + if (lcm_sym59__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), "phi")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "phi")); + } + } } + } + if (lcm_sym60__) { + if (lcm_sym59__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "p")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), "p"));} + } + for (size_t sym1__ = 2; sym1__ <= lcm_sym66__; ++sym1__) { + if (lcm_sym59__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), "p")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "p"));} + } } + } + if (lcm_sym58__) { + if (lcm_sym59__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "inline_sym1__")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + "inline_sym1__"));} + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + if (lcm_sym59__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + "inline_sym1__")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "inline_sym1__"));} + } } + } + vars__.push_back(lcm_sym79__); + if (logical_negation(emit_generated_quantities__)) { + return ; + } + double sigma2; + + current_statement__ = 26; + sigma2 = lcm_sym81__; + lcm_sym80__ = square(sigma); + sigma2 = lcm_sym80__; + current_statement__ = 26; + current_statement__ = 26; + check_greater_or_equal(function__, "sigma2", lcm_sym80__, 0); + vars__.push_back(lcm_sym80__); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + double lcm_sym57__; + double lcm_sym56__; + double lcm_sym55__; + double lcm_sym54__; + int lcm_sym53__; + int lcm_sym52__; + int pos__; + + pos__ = 1; + double mean_phi; + + current_statement__ = 1; + mean_phi = context__.vals_r("mean_phi")[(1 - 1)]; + current_statement__ = 1; + mean_phi = stan::math::lub_free(mean_phi, 0, 1); + double mean_p; + + current_statement__ = 2; + mean_p = context__.vals_r("mean_p")[(1 - 1)]; + current_statement__ = 2; + mean_p = stan::math::lub_free(mean_p, 0, 1); + current_statement__ = 3; + validate_non_negative_index("epsilon", "nind", nind); + Eigen::Matrix epsilon; + epsilon = Eigen::Matrix(nind); + + { + std::vector epsilon_flat__; + current_statement__ = 3; + assign(epsilon_flat__, nil_index_list(), context__.vals_r("epsilon"), + "assigning variable epsilon_flat__"); + current_statement__ = 3; + pos__ = 1; + lcm_sym52__ = logical_gte(nind, 1); + if (lcm_sym52__) { + current_statement__ = 3; + assign(epsilon, cons_list(index_uni(1), nil_index_list()), + epsilon_flat__[(1 - 1)], "assigning variable epsilon"); + current_statement__ = 3; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 3; + assign(epsilon, cons_list(index_uni(sym1__), nil_index_list()), + epsilon_flat__[(pos__ - 1)], "assigning variable epsilon"); + current_statement__ = 3; + pos__ = (pos__ + 1);} + } + } + double sigma; + + current_statement__ = 4; + sigma = context__.vals_r("sigma")[(1 - 1)]; + current_statement__ = 4; + sigma = stan::math::lub_free(sigma, 0, 5); + vars__.push_back(mean_phi); + vars__.push_back(mean_p); + if (lcm_sym52__) { + vars__.push_back(epsilon[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + vars__.push_back(epsilon[(sym1__ - 1)]);} + } + vars__.push_back(sigma); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("mean_phi"); + names__.push_back("mean_p"); + names__.push_back("epsilon"); + names__.push_back("sigma"); + names__.push_back("phi"); + names__.push_back("p"); + names__.push_back("chi"); + names__.push_back("mu"); + names__.push_back("sigma2"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(nind); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(nind); + + dims__.push_back(n_occ_minus_1); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(nind); + + dims__.push_back(n_occ_minus_1); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(nind); + + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "mean_phi"); + param_names__.push_back(std::string() + "mean_p"); + for (size_t sym164__ = 1; sym164__ <= nind; ++sym164__) { + { + param_names__.push_back(std::string() + "epsilon" + '.' + std::to_string(sym164__)); + }} + param_names__.push_back(std::string() + "sigma"); + if (emit_transformed_parameters__) { + for (size_t sym164__ = 1; sym164__ <= n_occ_minus_1; ++sym164__) { + { + for (size_t sym165__ = 1; sym165__ <= nind; ++sym165__) { + { + param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym165__) + '.' + std::to_string(sym164__)); + }} + }} + for (size_t sym164__ = 1; sym164__ <= n_occ_minus_1; ++sym164__) { + { + for (size_t sym165__ = 1; sym165__ <= nind; ++sym165__) { + { + param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym165__) + '.' + std::to_string(sym164__)); + }} + }} + for (size_t sym164__ = 1; sym164__ <= n_occasions; ++sym164__) { + { + for (size_t sym165__ = 1; sym165__ <= nind; ++sym165__) { + { + param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym165__) + '.' + std::to_string(sym164__)); + }} + }} + param_names__.push_back(std::string() + "mu"); + } + + if (emit_generated_quantities__) { + param_names__.push_back(std::string() + "sigma2"); + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "mean_phi"); + param_names__.push_back(std::string() + "mean_p"); + for (size_t sym164__ = 1; sym164__ <= nind; ++sym164__) { + { + param_names__.push_back(std::string() + "epsilon" + '.' + std::to_string(sym164__)); + }} + param_names__.push_back(std::string() + "sigma"); + if (emit_transformed_parameters__) { + for (size_t sym164__ = 1; sym164__ <= n_occ_minus_1; ++sym164__) { + { + for (size_t sym165__ = 1; sym165__ <= nind; ++sym165__) { + { + param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym165__) + '.' + std::to_string(sym164__)); + }} + }} + for (size_t sym164__ = 1; sym164__ <= n_occ_minus_1; ++sym164__) { + { + for (size_t sym165__ = 1; sym165__ <= nind; ++sym165__) { + { + param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym165__) + '.' + std::to_string(sym164__)); + }} + }} + for (size_t sym164__ = 1; sym164__ <= n_occasions; ++sym164__) { + { + for (size_t sym165__ = 1; sym165__ <= nind; ++sym165__) { + { + param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym165__) + '.' + std::to_string(sym164__)); + }} + }} + param_names__.push_back(std::string() + "mu"); + } + + if (emit_generated_quantities__) { + param_names__.push_back(std::string() + "sigma2"); + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mean_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"epsilon\",\"type\":{\"name\":\"vector\",\"length\":" << nind << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"mu\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mean_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"epsilon\",\"type\":{\"name\":\"vector\",\"length\":" << nind << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"mu\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef expr_prop_fail5_model_namespace::expr_prop_fail5_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-fail6.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace expr_prop_fail6_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'expr-prop-fail6.stan', line 163, column 2 to column 33)", + " (in 'expr-prop-fail6.stan', line 164, column 2 to column 31)", + " (in 'expr-prop-fail6.stan', line 165, column 2 to column 28)", + " (in 'expr-prop-fail6.stan', line 166, column 2 to column 36)", + " (in 'expr-prop-fail6.stan', line 167, column 2 to column 20)", + " (in 'expr-prop-fail6.stan', line 168, column 2 to column 30)", + " (in 'expr-prop-fail6.stan', line 174, column 2 to column 50)", + " (in 'expr-prop-fail6.stan', line 175, column 2 to column 44)", + " (in 'expr-prop-fail6.stan', line 176, column 2 to column 25)", + " (in 'expr-prop-fail6.stan', line 177, column 2 to column 42)", + " (in 'expr-prop-fail6.stan', line 178, column 2 to column 46)", + " (in 'expr-prop-fail6.stan', line 183, column 4 to column 48)", + " (in 'expr-prop-fail6.stan', line 182, column 2 to line 183, column 48)", + " (in 'expr-prop-fail6.stan', line 192, column 4 to column 22)", + " (in 'expr-prop-fail6.stan', line 194, column 4 to column 17)", + " (in 'expr-prop-fail6.stan', line 196, column 6 to column 35)", + " (in 'expr-prop-fail6.stan', line 197, column 6 to column 27)", + " (in 'expr-prop-fail6.stan', line 195, column 35 to line 198, column 5)", + " (in 'expr-prop-fail6.stan', line 195, column 4 to line 198, column 5)", + " (in 'expr-prop-fail6.stan', line 199, column 4 to column 26)", + " (in 'expr-prop-fail6.stan', line 191, column 2 to line 200, column 3)", + " (in 'expr-prop-fail6.stan', line 49, column 4 to column 24)", + " (in 'expr-prop-fail6.stan', line 50, column 4 to column 30)", + " (in 'expr-prop-fail6.stan', line 51, column 4 to column 35)", + " (in 'expr-prop-fail6.stan', line 54, column 6 to column 32)", + " (in 'expr-prop-fail6.stan', line 56, column 8 to column 37)", + " (in 'expr-prop-fail6.stan', line 57, column 8 to column 32)", + " (in 'expr-prop-fail6.stan', line 59, column 8 to line 60, column 65)", + " (in 'expr-prop-fail6.stan', line 55, column 37 to line 61, column 7)", + " (in 'expr-prop-fail6.stan', line 53, column 23 to line 62, column 5)", + " (in 'expr-prop-fail6.stan', line 48, column 47 to line 64, column 3)", + " (in 'expr-prop-fail6.stan', line 219, column 2 to column 23)", + " (in 'expr-prop-fail6.stan', line 220, column 2 to column 22)", + " (in 'expr-prop-fail6.stan', line 221, column 2 to column 30)", + " (in 'expr-prop-fail6.stan', line 222, column 2 to column 30)", + " (in 'expr-prop-fail6.stan', line 223, column 2 to column 41)", + " (in 'expr-prop-fail6.stan', line 229, column 4 to column 14)", + " (in 'expr-prop-fail6.stan', line 238, column 6 to column 41)", + " (in 'expr-prop-fail6.stan', line 237, column 11 to line 239, column 5)", + " (in 'expr-prop-fail6.stan', line 231, column 6 to column 37)", + " (in 'expr-prop-fail6.stan', line 234, column 8 to line 235, column 46)", + " (in 'expr-prop-fail6.stan', line 233, column 8 to column 34)", + " (in 'expr-prop-fail6.stan', line 232, column 31 to line 236, column 7)", + " (in 'expr-prop-fail6.stan', line 232, column 6 to line 236, column 7)", + " (in 'expr-prop-fail6.stan', line 230, column 28 to line 237, column 5)", + " (in 'expr-prop-fail6.stan', line 230, column 4 to line 239, column 5)", + " (in 'expr-prop-fail6.stan', line 228, column 17 to line 240, column 3)", + " (in 'expr-prop-fail6.stan', line 228, column 2 to line 240, column 3)", + " (in 'expr-prop-fail6.stan', line 244, column 4 to column 63)", + " (in 'expr-prop-fail6.stan', line 245, column 4 to column 16)", + " (in 'expr-prop-fail6.stan', line 246, column 4 to column 18)", + " (in 'expr-prop-fail6.stan', line 249, column 6 to column 36)", + " (in 'expr-prop-fail6.stan', line 17, column 8 to column 17)", + " (in 'expr-prop-fail6.stan', line 16, column 6 to line 17, column 17)", + " (in 'expr-prop-fail6.stan', line 14, column 31 to line 19, column 3)", + " (in 'expr-prop-fail6.stan', line 252, column 8 to column 26)", + " (in 'expr-prop-fail6.stan', line 251, column 6 to line 252, column 26)", + " (in 'expr-prop-fail6.stan', line 248, column 19 to line 253, column 5)", + " (in 'expr-prop-fail6.stan', line 248, column 4 to line 253, column 5)", + " (in 'expr-prop-fail6.stan', line 255, column 6 to column 25)", + " (in 'expr-prop-fail6.stan', line 256, column 6 to column 31)", + " (in 'expr-prop-fail6.stan', line 254, column 29 to line 257, column 5)", + " (in 'expr-prop-fail6.stan', line 254, column 4 to line 257, column 5)", + " (in 'expr-prop-fail6.stan', line 259, column 6 to column 26)", + " (in 'expr-prop-fail6.stan', line 260, column 6 to column 32)", + " (in 'expr-prop-fail6.stan', line 258, column 19 to line 261, column 5)", + " (in 'expr-prop-fail6.stan', line 258, column 4 to line 261, column 5)", + " (in 'expr-prop-fail6.stan', line 262, column 4 to column 25)", + " (in 'expr-prop-fail6.stan', line 243, column 2 to line 263, column 3)", + " (in 'expr-prop-fail6.stan', line 211, column 2 to column 29)", + " (in 'expr-prop-fail6.stan', line 212, column 2 to column 21)", + " (in 'expr-prop-fail6.stan', line 82, column 4 to column 27)", + " (in 'expr-prop-fail6.stan', line 83, column 4 to column 33)", + " (in 'expr-prop-fail6.stan', line 84, column 4 to column 39)", + " (in 'expr-prop-fail6.stan', line 87, column 6 to column 43)", + " (in 'expr-prop-fail6.stan', line 124, column 8 to column 33)", + " (in 'expr-prop-fail6.stan', line 127, column 8 to line 130, column 47)", + " (in 'expr-prop-fail6.stan', line 133, column 10 to line 137, column 49)", + " (in 'expr-prop-fail6.stan', line 139, column 8 to column 54)", + " (in 'expr-prop-fail6.stan', line 140, column 8 to column 34)", + " (in 'expr-prop-fail6.stan', line 123, column 13 to line 141, column 7)", + " (in 'expr-prop-fail6.stan', line 91, column 8 to column 27)", + " (in 'expr-prop-fail6.stan', line 97, column 10 to column 30)", + " (in 'expr-prop-fail6.stan', line 106, column 12 to line 110, column 56)", + " (in 'expr-prop-fail6.stan', line 111, column 10 to line 113, column 61)", + " (in 'expr-prop-fail6.stan', line 114, column 10 to column 36)", + " (in 'expr-prop-fail6.stan', line 96, column 15 to line 115, column 9)", + " (in 'expr-prop-fail6.stan', line 95, column 10 to column 41)", + " (in 'expr-prop-fail6.stan', line 94, column 27 to line 96, column 9)", + " (in 'expr-prop-fail6.stan', line 94, column 8 to line 115, column 9)", + " (in 'expr-prop-fail6.stan', line 118, column 10 to column 39)", + " (in 'expr-prop-fail6.stan', line 119, column 10 to column 39)", + " (in 'expr-prop-fail6.stan', line 117, column 42 to line 120, column 9)", + " (in 'expr-prop-fail6.stan', line 122, column 8 to column 39)", + " (in 'expr-prop-fail6.stan', line 89, column 20 to line 123, column 7)", + " (in 'expr-prop-fail6.stan', line 86, column 23 to line 142, column 5)", + " (in 'expr-prop-fail6.stan', line 147, column 2 to column 17)", + " (in 'expr-prop-fail6.stan', line 148, column 2 to column 27)", + " (in 'expr-prop-fail6.stan', line 149, column 2 to column 41)", + " (in 'expr-prop-fail6.stan', line 153, column 2 to column 42)", + " (in 'expr-prop-fail6.stan', line 154, column 2 to column 41)", + " (in 'expr-prop-fail6.stan', line 157, column 4 to column 35)", + " (in 'expr-prop-fail6.stan', line 156, column 2 to line 157, column 35)", + " (in 'expr-prop-fail6.stan', line 30, column 6 to column 32)", + " (in 'expr-prop-fail6.stan', line 33, column 8 to column 17)", + " (in 'expr-prop-fail6.stan', line 32, column 6 to line 33, column 17)", + " (in 'expr-prop-fail6.stan', line 29, column 37 to line 34, column 5)", + " (in 'expr-prop-fail6.stan', line 28, column 30 to line 36, column 3)", + " (in 'expr-prop-fail6.stan', line 159, column 4 to column 33)", + " (in 'expr-prop-fail6.stan', line 158, column 2 to line 159, column 33)", + " (in 'expr-prop-fail6.stan', line 18, column 4 to column 13)", + " (in 'expr-prop-fail6.stan', line 35, column 4 to column 13)", + " (in 'expr-prop-fail6.stan', line 55, column 6 to line 61, column 7)", + " (in 'expr-prop-fail6.stan', line 53, column 4 to line 62, column 5)", + " (in 'expr-prop-fail6.stan', line 63, column 4 to column 15)", + " (in 'expr-prop-fail6.stan', line 132, column 8 to line 137, column 49)", + " (in 'expr-prop-fail6.stan', line 105, column 10 to line 110, column 56)", + " (in 'expr-prop-fail6.stan', line 86, column 4 to line 142, column 5)", + " (in 'expr-prop-fail6.stan', line 81, column 42 to line 143, column 3)"}; + + +int +first_capture(const std::vector& y_i, std::ostream* pstream__) { + using local_scalar_t__ = double; + const static bool propto__ = true; + (void) propto__; + + try { + int lcm_sym51__; + int lcm_sym50__; + int lcm_sym49__; + int lcm_sym48__; + { + lcm_sym49__ = size(y_i); + if (logical_gte(lcm_sym49__, 1)) { + current_statement__ = 54; + if (y_i[(1 - 1)]) { + current_statement__ = 53; + return 1; + } + for (size_t k = 2; k <= lcm_sym49__; ++k) { + current_statement__ = 54; + if (y_i[(k - 1)]) { + current_statement__ = 53; + return k; + } } + } + current_statement__ = 111; + return 0; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct first_capture_functor__ { +int +operator()(const std::vector& y_i, std::ostream* pstream__) const +{ +return first_capture(y_i, pstream__); +} +}; + +int +last_capture(const std::vector& y_i, std::ostream* pstream__) { + using local_scalar_t__ = double; + const static bool propto__ = true; + (void) propto__; + + try { + int lcm_sym57__; + int lcm_sym56__; + int lcm_sym55__; + int lcm_sym54__; + int lcm_sym53__; + int lcm_sym52__; + { + lcm_sym55__ = (size(y_i) - 1); + if (logical_gte(lcm_sym55__, 0)) { + int k; + + lcm_sym54__ = (size(y_i) - 0); + current_statement__ = 106; + if (y_i[(lcm_sym54__ - 1)]) { + current_statement__ = 105; + return lcm_sym54__; + } + for (size_t k_rev = 1; k_rev <= lcm_sym55__; ++k_rev) { + int k; + + lcm_sym53__ = (size(y_i) - k_rev); + current_statement__ = 106; + if (y_i[(lcm_sym53__ - 1)]) { + current_statement__ = 105; + return lcm_sym53__; + } } + } + current_statement__ = 112; + return 0; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct last_capture_functor__ { +int +operator()(const std::vector& y_i, std::ostream* pstream__) const +{ +return last_capture(y_i, pstream__); +} +}; + +template +Eigen::Matrix::type, -1, -1> +prob_uncaptured(const Eigen::Matrix& p, + const Eigen::Matrix& phi, + std::ostream* pstream__) { + using local_scalar_t__ = typename boost::math::tools::promote_args::type; + const static bool propto__ = true; + (void) propto__; + + try { + double lcm_sym71__; + int lcm_sym70__; + double lcm_sym69__; + double lcm_sym68__; + double lcm_sym67__; + double lcm_sym66__; + int lcm_sym65__; + int lcm_sym64__; + int lcm_sym63__; + int lcm_sym62__; + int lcm_sym61__; + int lcm_sym60__; + int lcm_sym59__; + int lcm_sym58__; + { + int n_ind; + + lcm_sym70__ = rows(p); + int n_occasions; + + lcm_sym65__ = cols(p); + n_occasions = lcm_sym65__; + current_statement__ = 24; + validate_non_negative_index("chi", "n_ind", lcm_sym70__); + current_statement__ = 24; + validate_non_negative_index("chi", "n_occasions", lcm_sym65__); + Eigen::Matrix chi; + chi = Eigen::Matrix(lcm_sym70__, lcm_sym65__); + + lcm_sym60__ = logical_gte(lcm_sym70__, 1); + if (lcm_sym60__) { + lcm_sym59__ = logical_gte(lcm_sym65__, 1); + if (lcm_sym59__) { + lcm_sym71__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym71__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym65__; ++sym2__) { + current_statement__ = 24; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), lcm_sym71__, + "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= lcm_sym70__; ++sym1__) { + current_statement__ = 24; + if (lcm_sym59__) { + lcm_sym71__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym71__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym65__; ++sym2__) { + current_statement__ = 24; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym71__, "assigning variable chi");} + } } + } + current_statement__ = 114; + if (lcm_sym60__) { + current_statement__ = 25; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym65__), nil_index_list())), 1.0, + "assigning variable chi"); + lcm_sym62__ = (lcm_sym65__ - 1); + lcm_sym58__ = logical_gte(lcm_sym62__, 1); + if (lcm_sym58__) { + int t_curr; + + int t_next; + + lcm_sym64__ = (lcm_sym62__ + 1); + current_statement__ = 28; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym62__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym62__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym64__), nil_index_list())), + "p"))), + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym64__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym62__), nil_index_list())), + "phi"))), "assigning variable chi"); + for (size_t t = 2; t <= lcm_sym62__; ++t) { + int t_curr; + + lcm_sym61__ = (lcm_sym65__ - t); + int t_next; + + lcm_sym63__ = (lcm_sym61__ + 1); + current_statement__ = 28; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym61__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym61__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym63__), nil_index_list())), + "p"))), + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym63__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym61__), nil_index_list())), + "phi"))), "assigning variable chi");} + } + for (size_t i = 2; i <= lcm_sym70__; ++i) { + current_statement__ = 25; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym65__), nil_index_list())), 1.0, + "assigning variable chi"); + current_statement__ = 113; + if (lcm_sym58__) { + int t_curr; + + int t_next; + + lcm_sym64__ = (lcm_sym62__ + 1); + current_statement__ = 28; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym62__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym62__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym64__), nil_index_list())), + "p"))), + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym64__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym62__), nil_index_list())), + "phi"))), "assigning variable chi"); + for (size_t t = 2; t <= lcm_sym62__; ++t) { + int t_curr; + + lcm_sym61__ = (lcm_sym65__ - t); + int t_next; + + lcm_sym63__ = (lcm_sym61__ + 1); + current_statement__ = 28; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym61__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym61__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym63__), nil_index_list())), + "p"))), + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym63__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym61__), nil_index_list())), + "phi"))), "assigning variable chi");} + } } + } + current_statement__ = 115; + return chi; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct prob_uncaptured_functor__ { +template +Eigen::Matrix::type, -1, -1> +operator()(const Eigen::Matrix& p, + const Eigen::Matrix& phi, std::ostream* pstream__) const +{ +return prob_uncaptured(p, phi, pstream__); +} +}; + +template +void +js_super_lp(const std::vector>& y, + const std::vector& first, const std::vector& last, + const Eigen::Matrix& p, + const Eigen::Matrix& phi, const T5__& psi, + const Eigen::Matrix& nu, + const Eigen::Matrix& chi, T_lp__& lp__, + T_lp_accum__& lp_accum__, std::ostream* pstream__) { + using local_scalar_t__ = typename boost::math::tools::promote_args::type; + + try { + int lcm_sym126__; + int lcm_sym125__; + int lcm_sym124__; + int lcm_sym123__; + int lcm_sym122__; + int lcm_sym121__; + double lcm_sym120__; + double lcm_sym119__; + double lcm_sym118__; + double lcm_sym117__; + double lcm_sym116__; + double lcm_sym115__; + double lcm_sym114__; + double lcm_sym113__; + double lcm_sym112__; + double lcm_sym111__; + double lcm_sym110__; + double lcm_sym109__; + double lcm_sym108__; + double lcm_sym107__; + double lcm_sym106__; + double lcm_sym105__; + int lcm_sym104__; + int lcm_sym103__; + int lcm_sym102__; + double lcm_sym101__; + double lcm_sym100__; + double lcm_sym99__; + double lcm_sym98__; + double lcm_sym97__; + double lcm_sym96__; + double lcm_sym95__; + double lcm_sym94__; + double lcm_sym93__; + double lcm_sym92__; + double lcm_sym91__; + double lcm_sym90__; + double lcm_sym89__; + double lcm_sym88__; + int lcm_sym87__; + int lcm_sym86__; + Eigen::Matrix lcm_sym85__; + Eigen::Matrix lcm_sym84__; + Eigen::Matrix lcm_sym83__; + int lcm_sym82__; + int lcm_sym81__; + int lcm_sym80__; + int lcm_sym79__; + int lcm_sym78__; + int lcm_sym77__; + int lcm_sym76__; + int lcm_sym75__; + int lcm_sym74__; + int lcm_sym73__; + int lcm_sym72__; + { + int n_ind; + + lcm_sym125__ = dims(y)[(1 - 1)]; + int n_occasions; + + lcm_sym126__ = dims(y)[(2 - 1)]; + n_occasions = lcm_sym126__; + current_statement__ = 74; + validate_non_negative_index("qnu", "n_occasions", lcm_sym126__); + Eigen::Matrix qnu; + qnu = Eigen::Matrix(lcm_sym126__); + + assign(lcm_sym83__, nil_index_list(), subtract(1.0, nu), + "assigning variable lcm_sym83__"); + current_statement__ = 118; + if (logical_gte(lcm_sym125__, 1)) { + current_statement__ = 75; + validate_non_negative_index("qp", "n_occasions", lcm_sym126__); + Eigen::Matrix qp; + qp = Eigen::Matrix(lcm_sym126__); + + assign(lcm_sym85__, nil_index_list(), + subtract(1.0, + transpose( + rvalue(p, cons_list(index_uni(1), nil_index_list()), "p"))), + "assigning variable lcm_sym85__"); + lcm_sym122__ = first[(1 - 1)]; + if (lcm_sym122__) { + current_statement__ = 82; + lp_accum__.add(bernoulli_log(1, psi)); + current_statement__ = 90; + if (logical_eq(lcm_sym122__, 1)) { + current_statement__ = 88; + lp_accum__.add( + bernoulli_log(1, + (nu[(1 - 1)] * + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "p")))); + } else { + current_statement__ = 83; + validate_non_negative_index("lp", "first[(i - 1)]", lcm_sym122__); + Eigen::Matrix lp; + lp = Eigen::Matrix(lcm_sym122__); + + current_statement__ = 83; + if (logical_gte(lcm_sym122__, 1)) { + lcm_sym120__ = std::numeric_limits::quiet_NaN(); + assign(lp, cons_list(index_uni(1), nil_index_list()), + lcm_sym120__, "assigning variable lp"); + for (size_t sym1__ = 2; sym1__ <= lcm_sym122__; ++sym1__) { + current_statement__ = 83; + assign(lp, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym120__, "assigning variable lp");} + } + lcm_sym87__ = (lcm_sym122__ - 1); + assign(lp, cons_list(index_uni(1), nil_index_list()), + (((bernoulli_lpmf(1, nu[(1 - 1)]) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym85__, + cons_list(index_min_max(1, lcm_sym87__), + nil_index_list()), "lcm_sym85__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_min_max(1, lcm_sym87__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym122__), nil_index_list())), + "p"))), "assigning variable lp"); + current_statement__ = 117; + if (logical_gte(lcm_sym87__, 2)) { + current_statement__ = 84; + assign(lp, cons_list(index_uni(2), nil_index_list()), + ((((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym83__, + cons_list(index_min_max(1, 1), nil_index_list()), + "lcm_sym83__"))) + + bernoulli_lpmf(1, nu[(2 - 1)])) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym85__, + cons_list(index_min_max(2, lcm_sym87__), + nil_index_list()), "lcm_sym85__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_min_max(2, lcm_sym87__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym122__), nil_index_list())), + "p"))), "assigning variable lp"); + for (size_t t = 3; t <= lcm_sym87__; ++t) { + current_statement__ = 84; + assign(lp, cons_list(index_uni(t), nil_index_list()), + ((((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym83__, + cons_list(index_min_max(1, (t - 1)), + nil_index_list()), "lcm_sym83__"))) + + bernoulli_lpmf(1, nu[(t - 1)])) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym85__, + cons_list(index_min_max(t, lcm_sym87__), + nil_index_list()), "lcm_sym85__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_min_max(t, lcm_sym87__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym122__), + nil_index_list())), "p"))), + "assigning variable lp");} + } + current_statement__ = 85; + assign(lp, cons_list(index_uni(lcm_sym122__), nil_index_list()), + ((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym83__, + cons_list(index_min_max(1, lcm_sym87__), + nil_index_list()), "lcm_sym83__"))) + + bernoulli_lpmf(1, nu[(lcm_sym122__ - 1)])) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym122__), nil_index_list())), + "p"))), "assigning variable lp"); + current_statement__ = 86; + lp_accum__.add(log_sum_exp(lp)); + } + lcm_sym124__ = last[(1 - 1)]; + if (logical_gte(lcm_sym124__, (lcm_sym122__ + 1))) { + current_statement__ = 91; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(((lcm_sym122__ + 1) - 1)), + nil_index_list())), "phi"))); + lcm_sym103__ = ((lcm_sym122__ + 1) + 1); + lp_accum__.add( + bernoulli_log(y[(1 - 1)][((lcm_sym122__ + 1) - 1)], + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym122__ + 1)), + nil_index_list())), "p"))); + for (size_t t = lcm_sym103__; t <= lcm_sym124__; ++t) { + current_statement__ = 91; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni((t - 1)), nil_index_list())), + "phi"))); + current_statement__ = 92; + lp_accum__.add( + bernoulli_log(y[(1 - 1)][(t - 1)], + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), "p")));} + } + current_statement__ = 94; + lp_accum__.add( + bernoulli_log(1, + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym124__), nil_index_list())), + "chi"))); + } else { + lcm_sym104__ = (lcm_sym126__ + 1); + validate_non_negative_index("lp", "(n_occasions + 1)", lcm_sym104__); + Eigen::Matrix lp; + lp = Eigen::Matrix(lcm_sym104__); + + current_statement__ = 76; + if (logical_gte(lcm_sym104__, 1)) { + lcm_sym120__ = std::numeric_limits::quiet_NaN(); + assign(lp, cons_list(index_uni(1), nil_index_list()), + lcm_sym120__, "assigning variable lp"); + for (size_t sym1__ = 2; sym1__ <= lcm_sym104__; ++sym1__) { + current_statement__ = 76; + assign(lp, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym120__, "assigning variable lp");} + } + current_statement__ = 77; + assign(lp, cons_list(index_uni(1), nil_index_list()), + (((bernoulli_lpmf(1, psi) + + bernoulli_lpmf(1, nu[(1 - 1)])) + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "p"))) + + bernoulli_lpmf(1, + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "chi"))), + "assigning variable lp"); + current_statement__ = 116; + if (logical_gte(lcm_sym126__, 2)) { + current_statement__ = 78; + assign(lp, cons_list(index_uni(2), nil_index_list()), + ((((bernoulli_lpmf(1, psi) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym83__, + cons_list(index_min_max(1, 1), nil_index_list()), + "lcm_sym83__")))) + + bernoulli_lpmf(1, nu[(2 - 1)])) + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), "p"))) + + bernoulli_lpmf(1, + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), "chi"))), + "assigning variable lp"); + for (size_t t = 3; t <= lcm_sym126__; ++t) { + current_statement__ = 78; + assign(lp, cons_list(index_uni(t), nil_index_list()), + ((((bernoulli_lpmf(1, psi) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym83__, + cons_list(index_min_max(1, (t - 1)), + nil_index_list()), "lcm_sym83__")))) + + bernoulli_lpmf(1, nu[(t - 1)])) + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), "p"))) + + bernoulli_lpmf(1, + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), "chi"))), + "assigning variable lp");} + } + current_statement__ = 79; + assign(lp, cons_list(index_uni(lcm_sym104__), nil_index_list()), + bernoulli_lpmf(0, psi), "assigning variable lp"); + current_statement__ = 80; + lp_accum__.add(log_sum_exp(lp)); + } + for (size_t i = 2; i <= lcm_sym125__; ++i) { + current_statement__ = 75; + validate_non_negative_index("qp", "n_occasions", lcm_sym126__); + Eigen::Matrix qp; + qp = Eigen::Matrix(lcm_sym126__); + + assign(lcm_sym84__, nil_index_list(), + subtract(1.0, + transpose( + rvalue(p, cons_list(index_uni(i), nil_index_list()), "p"))), + "assigning variable lcm_sym84__"); + lcm_sym121__ = first[(i - 1)]; + if (lcm_sym121__) { + current_statement__ = 82; + lp_accum__.add(bernoulli_log(1, psi)); + current_statement__ = 90; + if (logical_eq(lcm_sym121__, 1)) { + current_statement__ = 88; + lp_accum__.add( + bernoulli_log(1, + (nu[(1 - 1)] * + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), "p")))); + } else { + current_statement__ = 83; + validate_non_negative_index("lp", "first[(i - 1)]", + lcm_sym121__); + Eigen::Matrix lp; + lp = Eigen::Matrix(lcm_sym121__); + + current_statement__ = 83; + if (logical_gte(lcm_sym121__, 1)) { + lcm_sym120__ = std::numeric_limits::quiet_NaN(); + assign(lp, cons_list(index_uni(1), nil_index_list()), + lcm_sym120__, "assigning variable lp"); + for (size_t sym1__ = 2; sym1__ <= lcm_sym121__; ++sym1__) { + current_statement__ = 83; + assign(lp, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym120__, "assigning variable lp");} + } + lcm_sym86__ = (lcm_sym121__ - 1); + assign(lp, cons_list(index_uni(1), nil_index_list()), + (((bernoulli_lpmf(1, nu[(1 - 1)]) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym84__, + cons_list(index_min_max(1, lcm_sym86__), + nil_index_list()), "lcm_sym84__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_min_max(1, lcm_sym86__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym121__), nil_index_list())), + "p"))), "assigning variable lp"); + current_statement__ = 117; + if (logical_gte(lcm_sym86__, 2)) { + current_statement__ = 84; + assign(lp, cons_list(index_uni(2), nil_index_list()), + ((((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym83__, + cons_list(index_min_max(1, 1), nil_index_list()), + "lcm_sym83__"))) + + bernoulli_lpmf(1, nu[(2 - 1)])) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym84__, + cons_list(index_min_max(2, lcm_sym86__), + nil_index_list()), "lcm_sym84__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_min_max(2, lcm_sym86__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym121__), + nil_index_list())), "p"))), + "assigning variable lp"); + for (size_t t = 3; t <= lcm_sym86__; ++t) { + current_statement__ = 84; + assign(lp, cons_list(index_uni(t), nil_index_list()), + ((((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym83__, + cons_list(index_min_max(1, (t - 1)), + nil_index_list()), "lcm_sym83__"))) + + bernoulli_lpmf(1, nu[(t - 1)])) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym84__, + cons_list(index_min_max(t, lcm_sym86__), + nil_index_list()), "lcm_sym84__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_min_max(t, lcm_sym86__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym121__), + nil_index_list())), "p"))), + "assigning variable lp");} + } + current_statement__ = 85; + assign(lp, + cons_list(index_uni(lcm_sym121__), nil_index_list()), + ((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym83__, + cons_list(index_min_max(1, lcm_sym86__), + nil_index_list()), "lcm_sym83__"))) + + bernoulli_lpmf(1, nu[(lcm_sym121__ - 1)])) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym121__), nil_index_list())), + "p"))), "assigning variable lp"); + current_statement__ = 86; + lp_accum__.add(log_sum_exp(lp)); + } + lcm_sym123__ = last[(i - 1)]; + if (logical_gte(lcm_sym123__, (lcm_sym121__ + 1))) { + current_statement__ = 91; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(((lcm_sym121__ + 1) - 1)), + nil_index_list())), "phi"))); + lcm_sym102__ = ((lcm_sym121__ + 1) + 1); + lp_accum__.add( + bernoulli_log(y[(i - 1)][((lcm_sym121__ + 1) - 1)], + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym121__ + 1)), + nil_index_list())), "p"))); + for (size_t t = lcm_sym102__; t <= lcm_sym123__; ++t) { + current_statement__ = 91; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni((t - 1)), nil_index_list())), + "phi"))); + current_statement__ = 92; + lp_accum__.add( + bernoulli_log(y[(i - 1)][(t - 1)], + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), "p")));} + } + current_statement__ = 94; + lp_accum__.add( + bernoulli_log(1, + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym123__), nil_index_list())), + "chi"))); + } else { + lcm_sym104__ = (lcm_sym126__ + 1); + validate_non_negative_index("lp", "(n_occasions + 1)", + lcm_sym104__); + Eigen::Matrix lp; + lp = Eigen::Matrix(lcm_sym104__); + + current_statement__ = 76; + if (logical_gte(lcm_sym104__, 1)) { + lcm_sym120__ = std::numeric_limits::quiet_NaN(); + assign(lp, cons_list(index_uni(1), nil_index_list()), + lcm_sym120__, "assigning variable lp"); + for (size_t sym1__ = 2; sym1__ <= lcm_sym104__; ++sym1__) { + current_statement__ = 76; + assign(lp, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym120__, "assigning variable lp");} + } + current_statement__ = 77; + assign(lp, cons_list(index_uni(1), nil_index_list()), + (((bernoulli_lpmf(1, psi) + + bernoulli_lpmf(1, nu[(1 - 1)])) + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), "p"))) + + bernoulli_lpmf(1, + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), "chi"))), + "assigning variable lp"); + current_statement__ = 116; + if (logical_gte(lcm_sym126__, 2)) { + current_statement__ = 78; + assign(lp, cons_list(index_uni(2), nil_index_list()), + ((((bernoulli_lpmf(1, psi) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym83__, + cons_list(index_min_max(1, 1), nil_index_list()), + "lcm_sym83__")))) + + bernoulli_lpmf(1, nu[(2 - 1)])) + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(2), nil_index_list())), "p"))) + + bernoulli_lpmf(1, + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(2), nil_index_list())), "chi"))), + "assigning variable lp"); + for (size_t t = 3; t <= lcm_sym126__; ++t) { + current_statement__ = 78; + assign(lp, cons_list(index_uni(t), nil_index_list()), + ((((bernoulli_lpmf(1, psi) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym83__, + cons_list(index_min_max(1, (t - 1)), + nil_index_list()), "lcm_sym83__")))) + + bernoulli_lpmf(1, nu[(t - 1)])) + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), "p"))) + + + bernoulli_lpmf(1, + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), "chi"))), + "assigning variable lp");} + } + current_statement__ = 79; + assign(lp, cons_list(index_uni(lcm_sym104__), nil_index_list()), + bernoulli_lpmf(0, psi), "assigning variable lp"); + current_statement__ = 80; + lp_accum__.add(log_sum_exp(lp)); + }} + } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct js_super_lp_functor__ { +template +void +operator()(const std::vector>& y, + const std::vector& first, const std::vector& last, + const Eigen::Matrix& p, + const Eigen::Matrix& phi, const T5__& psi, + const Eigen::Matrix& nu, + const Eigen::Matrix& chi, T_lp__& lp__, + T_lp_accum__& lp_accum__, std::ostream* pstream__) const +{ +return js_super_lp(y, first, last, p, phi, psi, nu, chi, lp__, lp_accum__, + pstream__); +} +}; + +class expr_prop_fail6_model : public model_base_crtp { + + private: + int lcm_sym332__; + int lcm_sym331__; + int lcm_sym330__; + int lcm_sym329__; + int lcm_sym328__; + int lcm_sym327__; + int lcm_sym326__; + int lcm_sym325__; + int lcm_sym324__; + int lcm_sym323__; + int lcm_sym322__; + int lcm_sym321__; + int lcm_sym320__; + int lcm_sym319__; + int lcm_sym318__; + int lcm_sym317__; + int lcm_sym316__; + int lcm_sym315__; + int lcm_sym314__; + int lcm_sym313__; + int lcm_sym312__; + int lcm_sym311__; + int lcm_sym310__; + int pos__; + int M; + int n_occasions; + std::vector> y; + std::vector first; + std::vector last; + + public: + ~expr_prop_fail6_model() { } + + std::string model_name() const { return "expr_prop_fail6_model"; } + + expr_prop_fail6_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "expr_prop_fail6_model_namespace::expr_prop_fail6_model"; + (void) function__; // suppress unused var warning + + try { + + + + + + + + + + + + + + + + + + + + + + + + + pos__ = 1; + context__.validate_dims("data initialization","M","int", + context__.to_vec()); + + current_statement__ = 97; + M = context__.vals_i("M")[(1 - 1)]; + context__.validate_dims("data initialization","n_occasions","int", + context__.to_vec()); + + current_statement__ = 98; + n_occasions = context__.vals_i("n_occasions")[(1 - 1)]; + current_statement__ = 99; + validate_non_negative_index("y", "M", M); + current_statement__ = 99; + validate_non_negative_index("y", "n_occasions", n_occasions); + context__.validate_dims("data initialization","y","int", + context__.to_vec(M, n_occasions)); + y = std::vector>(M, std::vector(n_occasions, 0)); + + { + std::vector y_flat__; + current_statement__ = 99; + assign(y_flat__, nil_index_list(), context__.vals_i("y"), + "assigning variable y_flat__"); + current_statement__ = 99; + pos__ = 1; + lcm_sym311__ = logical_gte(n_occasions, 1); + if (lcm_sym311__) { + { + lcm_sym310__ = logical_gte(M, 1); + if (lcm_sym310__) { + current_statement__ = 99; + assign(y, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + y_flat__[(1 - 1)], "assigning variable y"); + current_statement__ = 99; + pos__ = 2; + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + current_statement__ = 99; + assign(y, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 99; + pos__ = (pos__ + 1);} + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 99; + if (lcm_sym310__) { + current_statement__ = 99; + assign(y, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 99; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + current_statement__ = 99; + assign(y, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 99; + pos__ = (pos__ + 1);} + } } + } + } else { + lcm_sym310__ = logical_gte(M, 1); + } + } + current_statement__ = 100; + validate_non_negative_index("first", "M", M); + first = std::vector(M, 0); + + current_statement__ = 101; + validate_non_negative_index("last", "M", M); + last = std::vector(M, 0); + + current_statement__ = 103; + if (lcm_sym310__) { + int inline_sym39__; + int inline_sym41__; + + inline_sym41__ = 0; + for (size_t inline_sym42__ = 1; inline_sym42__ <= 1; ++inline_sym42__) { + lcm_sym318__ = size(y[(1 - 1)]); + for (size_t inline_sym40__ = 1; inline_sym40__ <= lcm_sym318__; + ++inline_sym40__) { + current_statement__ = 54; + if (y[(1 - 1)][(inline_sym40__ - 1)]) { + inline_sym41__ = 1; + inline_sym39__ = inline_sym40__; + break; + } } + if (inline_sym41__) { + break; + } + inline_sym41__ = 1; + inline_sym39__ = 0; + break;} + assign(first, cons_list(index_uni(1), nil_index_list()), + inline_sym39__, "assigning variable first"); + for (size_t i = 2; i <= M; ++i) { + int inline_sym39__; + int inline_sym41__; + + inline_sym41__ = 0; + for (size_t inline_sym42__ = 1; inline_sym42__ <= 1; + ++inline_sym42__) { + lcm_sym317__ = size(y[(i - 1)]); + for (size_t inline_sym40__ = 1; inline_sym40__ <= lcm_sym317__; + ++inline_sym40__) { + current_statement__ = 54; + if (y[(i - 1)][(inline_sym40__ - 1)]) { + inline_sym41__ = 1; + inline_sym39__ = inline_sym40__; + break; + } } + if (inline_sym41__) { + break; + } + inline_sym41__ = 1; + inline_sym39__ = 0; + break;} + assign(first, cons_list(index_uni(i), nil_index_list()), + inline_sym39__, "assigning variable first");} + } + current_statement__ = 110; + if (lcm_sym310__) { + int inline_sym43__; + int inline_sym46__; + + inline_sym46__ = 0; + for (size_t inline_sym47__ = 1; inline_sym47__ <= 1; ++inline_sym47__) { + lcm_sym318__ = size(y[(1 - 1)]); + lcm_sym315__ = (lcm_sym318__ - 1); + for (size_t inline_sym45__ = 0; inline_sym45__ <= lcm_sym315__; + ++inline_sym45__) { + int inline_sym44__; + + lcm_sym314__ = (lcm_sym318__ - inline_sym45__); + inline_sym44__ = lcm_sym314__; + current_statement__ = 106; + if (y[(1 - 1)][(lcm_sym314__ - 1)]) { + inline_sym46__ = 1; + inline_sym43__ = lcm_sym314__; + break; + } } + if (inline_sym46__) { + break; + } + inline_sym46__ = 1; + inline_sym43__ = 0; + break;} + assign(last, cons_list(index_uni(1), nil_index_list()), + inline_sym43__, "assigning variable last"); + for (size_t i = 2; i <= M; ++i) { + int inline_sym43__; + int inline_sym46__; + + inline_sym46__ = 0; + for (size_t inline_sym47__ = 1; inline_sym47__ <= 1; + ++inline_sym47__) { + lcm_sym317__ = size(y[(i - 1)]); + lcm_sym313__ = (lcm_sym317__ - 1); + for (size_t inline_sym45__ = 0; inline_sym45__ <= lcm_sym313__; + ++inline_sym45__) { + int inline_sym44__; + + lcm_sym312__ = (lcm_sym317__ - inline_sym45__); + inline_sym44__ = lcm_sym312__; + current_statement__ = 106; + if (y[(i - 1)][(lcm_sym312__ - 1)]) { + inline_sym46__ = 1; + inline_sym43__ = lcm_sym312__; + break; + } } + if (inline_sym46__) { + break; + } + inline_sym46__ = 1; + inline_sym43__ = 0; + break;} + assign(last, cons_list(index_uni(i), nil_index_list()), + inline_sym43__, "assigning variable last");} + } + current_statement__ = 97; + current_statement__ = 97; + check_greater_or_equal(function__, "M", M, 0); + current_statement__ = 98; + current_statement__ = 98; + check_greater_or_equal(function__, "n_occasions", n_occasions, 0); + current_statement__ = 99; + if (lcm_sym310__) { + current_statement__ = 99; + if (lcm_sym311__) { + current_statement__ = 99; + current_statement__ = 99; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 99; + current_statement__ = 99; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(sym2__ - 1)], 0);} + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 99; + if (lcm_sym311__) { + current_statement__ = 99; + current_statement__ = 99; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 99; + current_statement__ = 99; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(sym2__ - 1)], 0);} + } } + } + current_statement__ = 99; + if (lcm_sym310__) { + current_statement__ = 99; + if (lcm_sym311__) { + current_statement__ = 99; + current_statement__ = 99; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 99; + current_statement__ = 99; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(sym2__ - 1)], 1);} + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 99; + if (lcm_sym311__) { + current_statement__ = 99; + current_statement__ = 99; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 99; + current_statement__ = 99; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(sym2__ - 1)], 1);} + } } + } + current_statement__ = 100; + if (lcm_sym310__) { + current_statement__ = 100; + current_statement__ = 100; + check_greater_or_equal(function__, "first[sym1__]", first[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 100; + current_statement__ = 100; + check_greater_or_equal(function__, "first[sym1__]", + first[(sym1__ - 1)], 0);} + } + current_statement__ = 100; + if (lcm_sym310__) { + current_statement__ = 100; + current_statement__ = 100; + check_less_or_equal(function__, "first[sym1__]", first[(1 - 1)], + n_occasions); + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 100; + current_statement__ = 100; + check_less_or_equal(function__, "first[sym1__]", + first[(sym1__ - 1)], n_occasions);} + } + current_statement__ = 101; + if (lcm_sym310__) { + current_statement__ = 101; + current_statement__ = 101; + check_greater_or_equal(function__, "last[sym1__]", last[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 101; + current_statement__ = 101; + check_greater_or_equal(function__, "last[sym1__]", + last[(sym1__ - 1)], 0);} + } + current_statement__ = 101; + if (lcm_sym310__) { + current_statement__ = 101; + current_statement__ = 101; + check_less_or_equal(function__, "last[sym1__]", last[(1 - 1)], + n_occasions); + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 101; + current_statement__ = 101; + check_less_or_equal(function__, "last[sym1__]", last[(sym1__ - 1)], + n_occasions);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + current_statement__ = 4; + validate_non_negative_index("beta", "n_occasions", n_occasions); + num_params_r__ += n_occasions; + current_statement__ = 5; + validate_non_negative_index("epsilon", "M", M); + num_params_r__ += M; + num_params_r__ += 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "expr_prop_fail6_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + int lcm_sym309__; + int lcm_sym308__; + local_scalar_t__ lcm_sym307__; + int lcm_sym306__; + int lcm_sym305__; + int lcm_sym304__; + int lcm_sym303__; + double lcm_sym301__; + double lcm_sym299__; + double lcm_sym302__; + int lcm_sym297__; + Eigen::Matrix lcm_sym296__; + double lcm_sym295__; + double lcm_sym294__; + Eigen::Matrix lcm_sym293__; + double lcm_sym292__; + double lcm_sym291__; + double lcm_sym290__; + int lcm_sym289__; + double lcm_sym288__; + double lcm_sym287__; + double lcm_sym286__; + double lcm_sym285__; + double lcm_sym284__; + double lcm_sym283__; + double lcm_sym282__; + double lcm_sym281__; + double lcm_sym280__; + double lcm_sym279__; + double lcm_sym278__; + double lcm_sym277__; + double lcm_sym276__; + double lcm_sym275__; + int lcm_sym274__; + double lcm_sym273__; + int lcm_sym272__; + int lcm_sym271__; + double lcm_sym270__; + double lcm_sym269__; + double lcm_sym268__; + double lcm_sym267__; + double lcm_sym266__; + double lcm_sym265__; + double lcm_sym264__; + double lcm_sym263__; + double lcm_sym262__; + double lcm_sym261__; + double lcm_sym260__; + double lcm_sym259__; + double lcm_sym258__; + double lcm_sym257__; + int lcm_sym256__; + int lcm_sym255__; + double lcm_sym254__; + int lcm_sym253__; + int lcm_sym252__; + int lcm_sym251__; + int lcm_sym250__; + Eigen::Matrix lcm_sym249__; + Eigen::Matrix lcm_sym248__; + Eigen::Matrix lcm_sym247__; + int lcm_sym246__; + int lcm_sym245__; + int lcm_sym244__; + int lcm_sym243__; + int lcm_sym242__; + int lcm_sym241__; + int lcm_sym240__; + int lcm_sym239__; + int lcm_sym238__; + int lcm_sym237__; + int lcm_sym236__; + int lcm_sym235__; + int lcm_sym234__; + int lcm_sym233__; + int lcm_sym232__; + int lcm_sym231__; + int lcm_sym230__; + int lcm_sym229__; + double lcm_sym228__; + double lcm_sym227__; + Eigen::Matrix lcm_sym226__; + local_scalar_t__ mean_phi; + + current_statement__ = 1; + mean_phi = in__.scalar(); + current_statement__ = 1; + if (jacobian__) { + current_statement__ = 1; + mean_phi = stan::math::lub_constrain(mean_phi, 0, 1, lp__); + } else { + current_statement__ = 1; + mean_phi = stan::math::lub_constrain(mean_phi, 0, 1); + } + local_scalar_t__ mean_p; + + current_statement__ = 2; + mean_p = in__.scalar(); + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + mean_p = stan::math::lub_constrain(mean_p, 0, 1, lp__); + } else { + current_statement__ = 2; + mean_p = stan::math::lub_constrain(mean_p, 0, 1); + } + local_scalar_t__ psi; + + current_statement__ = 3; + psi = in__.scalar(); + current_statement__ = 3; + if (jacobian__) { + current_statement__ = 3; + psi = stan::math::lub_constrain(psi, 0, 1, lp__); + } else { + current_statement__ = 3; + psi = stan::math::lub_constrain(psi, 0, 1); + } + current_statement__ = 4; + validate_non_negative_index("beta", "n_occasions", n_occasions); + Eigen::Matrix beta; + beta = Eigen::Matrix(n_occasions); + + current_statement__ = 4; + beta = in__.vector(n_occasions); + lcm_sym232__ = logical_gte(n_occasions, 1); + if (lcm_sym232__) { + current_statement__ = 4; + if (jacobian__) { + current_statement__ = 4; + assign(beta, cons_list(index_uni(1), nil_index_list()), + stan::math::lb_constrain(beta[(1 - 1)], 0, lp__), + "assigning variable beta"); + } else { + current_statement__ = 4; + assign(beta, cons_list(index_uni(1), nil_index_list()), + stan::math::lb_constrain(beta[(1 - 1)], 0), + "assigning variable beta"); + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 4; + if (jacobian__) { + current_statement__ = 4; + assign(beta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(beta[(sym1__ - 1)], 0, lp__), + "assigning variable beta"); + } else { + current_statement__ = 4; + assign(beta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(beta[(sym1__ - 1)], 0), + "assigning variable beta"); + }} + } + current_statement__ = 5; + validate_non_negative_index("epsilon", "M", M); + Eigen::Matrix epsilon; + epsilon = Eigen::Matrix(M); + + current_statement__ = 5; + epsilon = in__.vector(M); + local_scalar_t__ sigma; + + current_statement__ = 6; + sigma = in__.scalar(); + current_statement__ = 6; + if (jacobian__) { + current_statement__ = 6; + sigma = stan::math::lub_constrain(sigma, 0, 5, lp__); + } else { + current_statement__ = 6; + sigma = stan::math::lub_constrain(sigma, 0, 5); + } + current_statement__ = 7; + validate_non_negative_index("phi", "M", M); + lcm_sym246__ = (n_occasions - 1); + validate_non_negative_index("phi", "(n_occasions - 1)", lcm_sym246__); + Eigen::Matrix phi; + phi = Eigen::Matrix(M, lcm_sym246__); + + lcm_sym231__ = logical_gte(M, 1); + if (lcm_sym231__) { + lcm_sym233__ = logical_gte(lcm_sym246__, 1); + if (lcm_sym233__) { + lcm_sym302__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym302__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym246__; ++sym2__) { + current_statement__ = 7; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym302__, "assigning variable phi");} + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 7; + if (lcm_sym233__) { + lcm_sym302__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym302__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym246__; ++sym2__) { + current_statement__ = 7; + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym302__, "assigning variable phi");} + } } + } + current_statement__ = 8; + validate_non_negative_index("p", "M", M); + current_statement__ = 8; + validate_non_negative_index("p", "n_occasions", n_occasions); + Eigen::Matrix p; + p = Eigen::Matrix(M, n_occasions); + + current_statement__ = 8; + if (lcm_sym231__) { + current_statement__ = 8; + if (lcm_sym232__) { + lcm_sym302__ = std::numeric_limits::quiet_NaN(); + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym302__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 8; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym302__, "assigning variable p");} + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 8; + if (lcm_sym232__) { + lcm_sym302__ = std::numeric_limits::quiet_NaN(); + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym302__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 8; + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym302__, "assigning variable p");} + } } + } + current_statement__ = 9; + validate_non_negative_index("b", "n_occasions", n_occasions); + Eigen::Matrix b; + b = Eigen::Matrix(n_occasions); + + current_statement__ = 9; + if (lcm_sym232__) { + lcm_sym302__ = std::numeric_limits::quiet_NaN(); + assign(b, cons_list(index_uni(1), nil_index_list()), lcm_sym302__, + "assigning variable b"); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 9; + assign(b, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym302__, "assigning variable b");} + } + current_statement__ = 10; + validate_non_negative_index("nu", "n_occasions", n_occasions); + Eigen::Matrix nu; + nu = Eigen::Matrix(n_occasions); + + current_statement__ = 10; + if (lcm_sym232__) { + lcm_sym302__ = std::numeric_limits::quiet_NaN(); + assign(nu, cons_list(index_uni(1), nil_index_list()), lcm_sym302__, + "assigning variable nu"); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 10; + assign(nu, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym302__, "assigning variable nu");} + } + current_statement__ = 11; + validate_non_negative_index("chi", "M", M); + current_statement__ = 11; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix chi; + chi = Eigen::Matrix(M, n_occasions); + + current_statement__ = 11; + if (lcm_sym231__) { + current_statement__ = 11; + if (lcm_sym232__) { + lcm_sym302__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym302__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 11; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym302__, "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 11; + if (lcm_sym232__) { + lcm_sym302__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym302__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 11; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym302__, "assigning variable chi");} + } } + } + assign(lcm_sym296__, nil_index_list(), + rep_matrix(mean_phi, M, lcm_sym246__), + "assigning variable lcm_sym296__"); + assign(phi, nil_index_list(), lcm_sym296__, "assigning variable phi"); + current_statement__ = 13; + if (lcm_sym232__) { + assign(lcm_sym293__, nil_index_list(), + inv_logit(add(logit(mean_p), epsilon)), + "assigning variable lcm_sym293__"); + assign(p, + cons_list(index_omni(), cons_list(index_uni(1), nil_index_list())), + lcm_sym293__, "assigning variable p"); + for (size_t t = 2; t <= n_occasions; ++t) { + current_statement__ = 12; + assign(p, + cons_list(index_omni(), + cons_list(index_uni(t), nil_index_list())), lcm_sym293__, + "assigning variable p");} + } + assign(lcm_sym226__, nil_index_list(), divide(beta, sum(beta)), + "assigning variable lcm_sym226__"); + assign(b, nil_index_list(), lcm_sym226__, "assigning variable b"); + { + local_scalar_t__ cum_b; + + lcm_sym307__ = lcm_sym226__[(1 - 1)]; + current_statement__ = 15; + assign(nu, cons_list(index_uni(1), nil_index_list()), lcm_sym307__, + "assigning variable nu"); + current_statement__ = 19; + if (logical_gte(lcm_sym246__, 2)) { + current_statement__ = 16; + assign(nu, cons_list(index_uni(2), nil_index_list()), + (lcm_sym226__[(2 - 1)] / (1.0 - lcm_sym307__)), + "assigning variable nu"); + current_statement__ = 17; + cum_b = (lcm_sym307__ + lcm_sym226__[(2 - 1)]); + for (size_t t = 3; t <= lcm_sym246__; ++t) { + current_statement__ = 16; + assign(nu, cons_list(index_uni(t), nil_index_list()), + (lcm_sym226__[(t - 1)] / (1.0 - cum_b)), + "assigning variable nu"); + current_statement__ = 17; + cum_b = (cum_b + lcm_sym226__[(t - 1)]);} + } + current_statement__ = 20; + assign(nu, cons_list(index_uni(n_occasions), nil_index_list()), 1.0, + "assigning variable nu"); + } + Eigen::Matrix inline_sym17__; + int inline_sym27__; + + inline_sym27__ = 0; + for (size_t inline_sym28__ = 1; inline_sym28__ <= 1; ++inline_sym28__) { + int inline_sym18__; + + lcm_sym297__ = rows(p); + int inline_sym19__; + + lcm_sym289__ = cols(p); + current_statement__ = 24; + validate_non_negative_index("chi", "n_ind", lcm_sym297__); + current_statement__ = 24; + validate_non_negative_index("chi", "n_occasions", lcm_sym289__); + Eigen::Matrix inline_sym20__; + inline_sym20__ = Eigen::Matrix(lcm_sym297__, lcm_sym289__); + + for (size_t inline_sym22__ = 1; inline_sym22__ <= lcm_sym297__; + ++inline_sym22__) { + if (logical_gte(lcm_sym289__, 1)) { + lcm_sym302__ = std::numeric_limits::quiet_NaN(); + assign(inline_sym20__, + cons_list(index_uni(inline_sym22__), + cons_list(index_uni(1), nil_index_list())), lcm_sym302__, + "assigning variable inline_sym20__"); + for (size_t inline_sym21__ = 2; inline_sym21__ <= lcm_sym289__; + ++inline_sym21__) { + current_statement__ = 24; + assign(inline_sym20__, + cons_list(index_uni(inline_sym22__), + cons_list(index_uni(inline_sym21__), nil_index_list())), + lcm_sym302__, "assigning variable inline_sym20__");} + } + if (inline_sym27__) { + break; + } } + if (inline_sym27__) { + break; + } + for (size_t inline_sym26__ = 1; inline_sym26__ <= lcm_sym297__; + ++inline_sym26__) { + current_statement__ = 25; + assign(inline_sym20__, + cons_list(index_uni(inline_sym26__), + cons_list(index_uni(lcm_sym289__), nil_index_list())), 1.0, + "assigning variable inline_sym20__"); + lcm_sym251__ = (lcm_sym289__ - 1); + if (logical_gte(lcm_sym251__, 1)) { + int inline_sym23__; + + int inline_sym24__; + + lcm_sym256__ = (lcm_sym251__ + 1); + current_statement__ = 28; + assign(inline_sym20__, + cons_list(index_uni(inline_sym26__), + cons_list(index_uni(lcm_sym251__), nil_index_list())), + stan::math::fma( + (rvalue(lcm_sym296__, + cons_list(index_uni(inline_sym26__), + cons_list(index_uni(lcm_sym251__), nil_index_list())), + "lcm_sym296__") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym26__), + cons_list(index_uni(lcm_sym256__), nil_index_list())), + "p"))), + rvalue(inline_sym20__, + cons_list(index_uni(inline_sym26__), + cons_list(index_uni(lcm_sym256__), nil_index_list())), + "inline_sym20__"), + (1 - + rvalue(lcm_sym296__, + cons_list(index_uni(inline_sym26__), + cons_list(index_uni(lcm_sym251__), nil_index_list())), + "lcm_sym296__"))), "assigning variable inline_sym20__"); + for (size_t inline_sym25__ = 2; inline_sym25__ <= lcm_sym251__; + ++inline_sym25__) { + int inline_sym23__; + + lcm_sym250__ = (lcm_sym289__ - inline_sym25__); + int inline_sym24__; + + lcm_sym255__ = (lcm_sym250__ + 1); + current_statement__ = 28; + assign(inline_sym20__, + cons_list(index_uni(inline_sym26__), + cons_list(index_uni(lcm_sym250__), nil_index_list())), + stan::math::fma( + (rvalue(lcm_sym296__, + cons_list(index_uni(inline_sym26__), + cons_list(index_uni(lcm_sym250__), nil_index_list())), + "lcm_sym296__") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym26__), + cons_list(index_uni(lcm_sym255__), + nil_index_list())), "p"))), + rvalue(inline_sym20__, + cons_list(index_uni(inline_sym26__), + cons_list(index_uni(lcm_sym255__), nil_index_list())), + "inline_sym20__"), + (1 - + rvalue(lcm_sym296__, + cons_list(index_uni(inline_sym26__), + cons_list(index_uni(lcm_sym250__), nil_index_list())), + "lcm_sym296__"))), "assigning variable inline_sym20__"); + } + } + if (inline_sym27__) { + break; + } } + if (inline_sym27__) { + break; + } + inline_sym27__ = 1; + assign(inline_sym17__, nil_index_list(), inline_sym20__, + "assigning variable inline_sym17__"); + break;} + assign(chi, nil_index_list(), inline_sym17__, "assigning variable chi"); + current_statement__ = 7; + current_statement__ = 7; + check_greater_or_equal(function__, "phi", lcm_sym296__, 0); + current_statement__ = 7; + current_statement__ = 7; + check_less_or_equal(function__, "phi", lcm_sym296__, 1); + current_statement__ = 8; + current_statement__ = 8; + check_greater_or_equal(function__, "p", p, 0); + current_statement__ = 8; + current_statement__ = 8; + check_less_or_equal(function__, "p", p, 1); + current_statement__ = 9; + current_statement__ = 9; + check_simplex(function__, "b", lcm_sym226__); + current_statement__ = 10; + current_statement__ = 10; + check_greater_or_equal(function__, "nu", nu, 0); + current_statement__ = 10; + current_statement__ = 10; + check_less_or_equal(function__, "nu", nu, 1); + current_statement__ = 11; + current_statement__ = 11; + check_greater_or_equal(function__, "chi", inline_sym17__, 0); + current_statement__ = 11; + current_statement__ = 11; + check_less_or_equal(function__, "chi", inline_sym17__, 1); + { + current_statement__ = 70; + lp_accum__.add(normal_log(epsilon, 0, sigma)); + current_statement__ = 71; + lp_accum__.add(gamma_log(beta, 1, 1)); + int inline_sym37__; + + { + int inline_sym29__; + + lcm_sym308__ = dims(y)[(1 - 1)]; + int inline_sym30__; + + lcm_sym309__ = dims(y)[(2 - 1)]; + current_statement__ = 74; + validate_non_negative_index("qnu", "n_occasions", lcm_sym309__); + Eigen::Matrix inline_sym31__; + inline_sym31__ = Eigen::Matrix(lcm_sym309__); + + assign(lcm_sym247__, nil_index_list(), subtract(1.0, nu), + "assigning variable lcm_sym247__"); + lcm_sym244__ = logical_gte(lcm_sym308__, 1); + if (lcm_sym244__) { + current_statement__ = 75; + validate_non_negative_index("qp", "n_occasions", lcm_sym309__); + Eigen::Matrix inline_sym33__; + inline_sym33__ = Eigen::Matrix(lcm_sym309__); + + assign(lcm_sym249__, nil_index_list(), + subtract(1.0, + transpose( + rvalue(p, cons_list(index_uni(1), nil_index_list()), "p"))), + "assigning variable lcm_sym249__"); + lcm_sym304__ = first[(1 - 1)]; + if (lcm_sym304__) { + current_statement__ = 82; + lp_accum__.add(bernoulli_log(1, psi)); + current_statement__ = 90; + if (logical_eq(lcm_sym304__, 1)) { + current_statement__ = 88; + lp_accum__.add( + bernoulli_log(1, + (nu[(1 - 1)] * + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "p")))); + } else { + current_statement__ = 83; + validate_non_negative_index("lp", "first[(i - 1)]", + lcm_sym304__); + Eigen::Matrix inline_sym34__; + inline_sym34__ = Eigen::Matrix(lcm_sym304__); + + if (logical_gte(lcm_sym304__, 1)) { + lcm_sym302__ = std::numeric_limits::quiet_NaN(); + assign(inline_sym34__, + cons_list(index_uni(1), nil_index_list()), lcm_sym302__, + "assigning variable inline_sym34__"); + for (size_t inline_sym32__ = 2; + inline_sym32__ <= lcm_sym304__; ++inline_sym32__) { + current_statement__ = 83; + assign(inline_sym34__, + cons_list(index_uni(inline_sym32__), nil_index_list()), + lcm_sym302__, "assigning variable inline_sym34__");} + } + lcm_sym253__ = (lcm_sym304__ - 1); + assign(inline_sym34__, + cons_list(index_uni(1), nil_index_list()), + (((bernoulli_lpmf(1, nu[(1 - 1)]) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym249__, + cons_list(index_min_max(1, lcm_sym253__), + nil_index_list()), "lcm_sym249__")))) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym296__, + cons_list(index_uni(1), + cons_list(index_min_max(1, lcm_sym253__), + nil_index_list())), "lcm_sym296__")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym304__), + nil_index_list())), "p"))), + "assigning variable inline_sym34__"); + if (logical_gte(lcm_sym253__, 2)) { + current_statement__ = 84; + assign(inline_sym34__, + cons_list(index_uni(2), nil_index_list()), + ((((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym247__, + cons_list(index_min_max(1, 1), + nil_index_list()), "lcm_sym247__"))) + + bernoulli_lpmf(1, nu[(2 - 1)])) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym249__, + cons_list(index_min_max(2, lcm_sym253__), + nil_index_list()), "lcm_sym249__")))) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym296__, + cons_list(index_uni(1), + cons_list(index_min_max(2, lcm_sym253__), + nil_index_list())), "lcm_sym296__")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym304__), + nil_index_list())), "p"))), + "assigning variable inline_sym34__"); + for (size_t inline_sym35__ = 3; + inline_sym35__ <= lcm_sym253__; ++inline_sym35__) { + current_statement__ = 84; + assign(inline_sym34__, + cons_list(index_uni(inline_sym35__), nil_index_list()), + ((((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym247__, + cons_list( + index_min_max(1, (inline_sym35__ - 1)), + nil_index_list()), "lcm_sym247__"))) + + bernoulli_lpmf(1, nu[(inline_sym35__ - 1)])) + + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym249__, + cons_list( + index_min_max(inline_sym35__, lcm_sym253__), + nil_index_list()), "lcm_sym249__")))) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym296__, + cons_list(index_uni(1), + cons_list( + index_min_max(inline_sym35__, lcm_sym253__), + nil_index_list())), "lcm_sym296__")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym304__), + nil_index_list())), "p"))), + "assigning variable inline_sym34__");} + } + current_statement__ = 85; + assign(inline_sym34__, + cons_list(index_uni(lcm_sym304__), nil_index_list()), + ((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym247__, + cons_list(index_min_max(1, lcm_sym253__), + nil_index_list()), "lcm_sym247__"))) + + bernoulli_lpmf(1, nu[(lcm_sym304__ - 1)])) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym304__), + nil_index_list())), "p"))), + "assigning variable inline_sym34__"); + current_statement__ = 86; + lp_accum__.add(log_sum_exp(inline_sym34__)); + } + lcm_sym306__ = last[(1 - 1)]; + if (logical_gte(lcm_sym306__, (lcm_sym304__ + 1))) { + current_statement__ = 91; + lp_accum__.add( + bernoulli_log(1, + rvalue(lcm_sym296__, + cons_list(index_uni(1), + cons_list(index_uni(((lcm_sym304__ + 1) - 1)), + nil_index_list())), "lcm_sym296__"))); + lcm_sym272__ = ((lcm_sym304__ + 1) + 1); + lp_accum__.add( + bernoulli_log( + y[(1 - 1)][((lcm_sym304__ + 1) - 1)], + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym304__ + 1)), + nil_index_list())), "p"))); + for (size_t inline_sym35__ = lcm_sym272__; + inline_sym35__ <= lcm_sym306__; ++inline_sym35__) { + current_statement__ = 91; + lp_accum__.add( + bernoulli_log(1, + rvalue(lcm_sym296__, + cons_list(index_uni(1), + cons_list(index_uni((inline_sym35__ - 1)), + nil_index_list())), "lcm_sym296__"))); + current_statement__ = 92; + lp_accum__.add( + bernoulli_log(y[(1 - 1)][(inline_sym35__ - 1)], + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(inline_sym35__), + nil_index_list())), "p")));} + } + current_statement__ = 94; + lp_accum__.add( + bernoulli_log(1, + rvalue(inline_sym17__, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym306__), nil_index_list())), + "inline_sym17__"))); + } else { + lcm_sym274__ = (lcm_sym309__ + 1); + validate_non_negative_index("lp", "(n_occasions + 1)", + lcm_sym274__); + Eigen::Matrix inline_sym34__; + inline_sym34__ = Eigen::Matrix(lcm_sym274__); + + if (logical_gte(lcm_sym274__, 1)) { + lcm_sym302__ = std::numeric_limits::quiet_NaN(); + assign(inline_sym34__, + cons_list(index_uni(1), nil_index_list()), lcm_sym302__, + "assigning variable inline_sym34__"); + for (size_t inline_sym32__ = 2; + inline_sym32__ <= lcm_sym274__; ++inline_sym32__) { + current_statement__ = 76; + assign(inline_sym34__, + cons_list(index_uni(inline_sym32__), nil_index_list()), + lcm_sym302__, "assigning variable inline_sym34__");} + } + current_statement__ = 77; + assign(inline_sym34__, + cons_list(index_uni(1), nil_index_list()), + (((bernoulli_lpmf(1, psi) + + bernoulli_lpmf(1, nu[(1 - 1)])) + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "p"))) + + bernoulli_lpmf(1, + rvalue(inline_sym17__, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + "inline_sym17__"))), + "assigning variable inline_sym34__"); + if (logical_gte(lcm_sym309__, 2)) { + current_statement__ = 78; + assign(inline_sym34__, + cons_list(index_uni(2), nil_index_list()), + ((((bernoulli_lpmf(1, psi) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym247__, + cons_list(index_min_max(1, 1), nil_index_list()), + "lcm_sym247__")))) + + bernoulli_lpmf(1, nu[(2 - 1)])) + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), "p"))) + + + bernoulli_lpmf(1, + rvalue(inline_sym17__, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), + "inline_sym17__"))), + "assigning variable inline_sym34__"); + for (size_t inline_sym35__ = 3; + inline_sym35__ <= lcm_sym309__; ++inline_sym35__) { + current_statement__ = 78; + assign(inline_sym34__, + cons_list(index_uni(inline_sym35__), nil_index_list()), + ((((bernoulli_lpmf(1, psi) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym247__, + cons_list( + index_min_max(1, (inline_sym35__ - 1)), + nil_index_list()), "lcm_sym247__")))) + + bernoulli_lpmf(1, nu[(inline_sym35__ - 1)])) + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(inline_sym35__), + nil_index_list())), "p"))) + + bernoulli_lpmf(1, + rvalue(inline_sym17__, + cons_list(index_uni(1), + cons_list(index_uni(inline_sym35__), + nil_index_list())), "inline_sym17__"))), + "assigning variable inline_sym34__");} + } + current_statement__ = 79; + assign(inline_sym34__, + cons_list(index_uni(lcm_sym274__), nil_index_list()), + bernoulli_lpmf(0, psi), + "assigning variable inline_sym34__"); + current_statement__ = 80; + lp_accum__.add(log_sum_exp(inline_sym34__)); + } + for (size_t inline_sym36__ = 2; inline_sym36__ <= lcm_sym308__; + ++inline_sym36__) { + current_statement__ = 75; + validate_non_negative_index("qp", "n_occasions", lcm_sym309__); + Eigen::Matrix inline_sym33__; + inline_sym33__ = Eigen::Matrix(lcm_sym309__); + + assign(lcm_sym248__, nil_index_list(), + subtract(1.0, + transpose( + rvalue(p, + cons_list(index_uni(inline_sym36__), nil_index_list()), + "p"))), "assigning variable lcm_sym248__"); + lcm_sym303__ = first[(inline_sym36__ - 1)]; + if (lcm_sym303__) { + current_statement__ = 82; + lp_accum__.add(bernoulli_log(1, psi)); + current_statement__ = 90; + if (logical_eq(lcm_sym303__, 1)) { + current_statement__ = 88; + lp_accum__.add( + bernoulli_log(1, + (nu[(1 - 1)] * + rvalue(p, + cons_list(index_uni(inline_sym36__), + cons_list(index_uni(1), nil_index_list())), "p")))); + } else { + current_statement__ = 83; + validate_non_negative_index("lp", "first[(i - 1)]", + lcm_sym303__); + Eigen::Matrix inline_sym34__; + inline_sym34__ = Eigen::Matrix(lcm_sym303__); + + if (logical_gte(lcm_sym303__, 1)) { + lcm_sym302__ = std::numeric_limits::quiet_NaN(); + assign(inline_sym34__, + cons_list(index_uni(1), nil_index_list()), + lcm_sym302__, "assigning variable inline_sym34__"); + for (size_t inline_sym32__ = 2; + inline_sym32__ <= lcm_sym303__; ++inline_sym32__) { + current_statement__ = 83; + assign(inline_sym34__, + cons_list(index_uni(inline_sym32__), + nil_index_list()), lcm_sym302__, + "assigning variable inline_sym34__");} + } + lcm_sym252__ = (lcm_sym303__ - 1); + assign(inline_sym34__, + cons_list(index_uni(1), nil_index_list()), + (((bernoulli_lpmf(1, nu[(1 - 1)]) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym248__, + cons_list(index_min_max(1, lcm_sym252__), + nil_index_list()), "lcm_sym248__")))) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym296__, + cons_list(index_uni(inline_sym36__), + cons_list(index_min_max(1, lcm_sym252__), + nil_index_list())), "lcm_sym296__")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(inline_sym36__), + cons_list(index_uni(lcm_sym303__), + nil_index_list())), "p"))), + "assigning variable inline_sym34__"); + if (logical_gte(lcm_sym252__, 2)) { + current_statement__ = 84; + assign(inline_sym34__, + cons_list(index_uni(2), nil_index_list()), + ((((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym247__, + cons_list(index_min_max(1, 1), + nil_index_list()), "lcm_sym247__"))) + + bernoulli_lpmf(1, nu[(2 - 1)])) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym248__, + cons_list(index_min_max(2, lcm_sym252__), + nil_index_list()), "lcm_sym248__")))) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym296__, + cons_list(index_uni(inline_sym36__), + cons_list(index_min_max(2, lcm_sym252__), + nil_index_list())), "lcm_sym296__")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(inline_sym36__), + cons_list(index_uni(lcm_sym303__), + nil_index_list())), "p"))), + "assigning variable inline_sym34__"); + for (size_t inline_sym35__ = 3; + inline_sym35__ <= lcm_sym252__; ++inline_sym35__) { + current_statement__ = 84; + assign(inline_sym34__, + cons_list(index_uni(inline_sym35__), + nil_index_list()), + ((((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym247__, + cons_list( + index_min_max(1, (inline_sym35__ - 1)), + nil_index_list()), "lcm_sym247__"))) + + bernoulli_lpmf(1, + nu[(inline_sym35__ - 1)])) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym248__, + cons_list( + index_min_max(inline_sym35__, lcm_sym252__), + nil_index_list()), "lcm_sym248__")))) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym296__, + cons_list(index_uni(inline_sym36__), + cons_list( + index_min_max(inline_sym35__, lcm_sym252__), + nil_index_list())), "lcm_sym296__")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(inline_sym36__), + cons_list(index_uni(lcm_sym303__), + nil_index_list())), "p"))), + "assigning variable inline_sym34__");} + } + current_statement__ = 85; + assign(inline_sym34__, + cons_list(index_uni(lcm_sym303__), nil_index_list()), + ((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym247__, + cons_list(index_min_max(1, lcm_sym252__), + nil_index_list()), "lcm_sym247__"))) + + bernoulli_lpmf(1, nu[(lcm_sym303__ - 1)])) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(inline_sym36__), + cons_list(index_uni(lcm_sym303__), + nil_index_list())), "p"))), + "assigning variable inline_sym34__"); + current_statement__ = 86; + lp_accum__.add(log_sum_exp(inline_sym34__)); + } + lcm_sym305__ = last[(inline_sym36__ - 1)]; + if (logical_gte(lcm_sym305__, (lcm_sym303__ + 1))) { + current_statement__ = 91; + lp_accum__.add( + bernoulli_log(1, + rvalue(lcm_sym296__, + cons_list(index_uni(inline_sym36__), + cons_list(index_uni(((lcm_sym303__ + 1) - 1)), + nil_index_list())), "lcm_sym296__"))); + lcm_sym271__ = ((lcm_sym303__ + 1) + 1); + lp_accum__.add( + bernoulli_log( + y[(inline_sym36__ - 1)][((lcm_sym303__ + 1) - 1)], + rvalue(p, + cons_list(index_uni(inline_sym36__), + cons_list(index_uni((lcm_sym303__ + 1)), + nil_index_list())), "p"))); + for (size_t inline_sym35__ = lcm_sym271__; + inline_sym35__ <= lcm_sym305__; ++inline_sym35__) { + current_statement__ = 91; + lp_accum__.add( + bernoulli_log(1, + rvalue(lcm_sym296__, + cons_list(index_uni(inline_sym36__), + cons_list(index_uni((inline_sym35__ - 1)), + nil_index_list())), "lcm_sym296__"))); + current_statement__ = 92; + lp_accum__.add( + bernoulli_log( + y[(inline_sym36__ - 1)][(inline_sym35__ - 1)], + rvalue(p, + cons_list(index_uni(inline_sym36__), + cons_list(index_uni(inline_sym35__), + nil_index_list())), "p")));} + } + current_statement__ = 94; + lp_accum__.add( + bernoulli_log(1, + rvalue(inline_sym17__, + cons_list(index_uni(inline_sym36__), + cons_list(index_uni(lcm_sym305__), nil_index_list())), + "inline_sym17__"))); + } else { + lcm_sym274__ = (lcm_sym309__ + 1); + validate_non_negative_index("lp", "(n_occasions + 1)", + lcm_sym274__); + Eigen::Matrix inline_sym34__; + inline_sym34__ = Eigen::Matrix(lcm_sym274__); + + if (logical_gte(lcm_sym274__, 1)) { + lcm_sym302__ = std::numeric_limits::quiet_NaN(); + assign(inline_sym34__, + cons_list(index_uni(1), nil_index_list()), lcm_sym302__, + "assigning variable inline_sym34__"); + for (size_t inline_sym32__ = 2; + inline_sym32__ <= lcm_sym274__; ++inline_sym32__) { + current_statement__ = 76; + assign(inline_sym34__, + cons_list(index_uni(inline_sym32__), nil_index_list()), + lcm_sym302__, "assigning variable inline_sym34__");} + } + current_statement__ = 77; + assign(inline_sym34__, + cons_list(index_uni(1), nil_index_list()), + (((bernoulli_lpmf(1, psi) + + bernoulli_lpmf(1, nu[(1 - 1)])) + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(inline_sym36__), + cons_list(index_uni(1), nil_index_list())), "p"))) + + + bernoulli_lpmf(1, + rvalue(inline_sym17__, + cons_list(index_uni(inline_sym36__), + cons_list(index_uni(1), nil_index_list())), + "inline_sym17__"))), + "assigning variable inline_sym34__"); + if (logical_gte(lcm_sym309__, 2)) { + current_statement__ = 78; + assign(inline_sym34__, + cons_list(index_uni(2), nil_index_list()), + ((((bernoulli_lpmf(1, psi) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym247__, + cons_list(index_min_max(1, 1), + nil_index_list()), "lcm_sym247__")))) + + bernoulli_lpmf(1, nu[(2 - 1)])) + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(inline_sym36__), + cons_list(index_uni(2), nil_index_list())), "p"))) + + + bernoulli_lpmf(1, + rvalue(inline_sym17__, + cons_list(index_uni(inline_sym36__), + cons_list(index_uni(2), nil_index_list())), + "inline_sym17__"))), + "assigning variable inline_sym34__"); + for (size_t inline_sym35__ = 3; + inline_sym35__ <= lcm_sym309__; ++inline_sym35__) { + current_statement__ = 78; + assign(inline_sym34__, + cons_list(index_uni(inline_sym35__), nil_index_list()), + ((((bernoulli_lpmf(1, psi) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym247__, + cons_list( + index_min_max(1, (inline_sym35__ - 1)), + nil_index_list()), "lcm_sym247__")))) + + bernoulli_lpmf(1, nu[(inline_sym35__ - 1)])) + + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(inline_sym36__), + cons_list(index_uni(inline_sym35__), + nil_index_list())), "p"))) + + bernoulli_lpmf(1, + rvalue(inline_sym17__, + cons_list(index_uni(inline_sym36__), + cons_list(index_uni(inline_sym35__), + nil_index_list())), "inline_sym17__"))), + "assigning variable inline_sym34__");} + } + current_statement__ = 79; + assign(inline_sym34__, + cons_list(index_uni(lcm_sym274__), nil_index_list()), + bernoulli_lpmf(0, psi), + "assigning variable inline_sym34__"); + current_statement__ = 80; + lp_accum__.add(log_sum_exp(inline_sym34__)); + }} + } + } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "expr_prop_fail6_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + int lcm_sym225__; + int lcm_sym224__; + double lcm_sym223__; + double lcm_sym222__; + double lcm_sym221__; + double lcm_sym220__; + local_scalar_t__ lcm_sym219__; + double lcm_sym218__; + double lcm_sym217__; + int lcm_sym216__; + int lcm_sym215__; + int lcm_sym214__; + int lcm_sym213__; + int lcm_sym212__; + int lcm_sym211__; + int lcm_sym210__; + double lcm_sym209__; + double lcm_sym208__; + double lcm_sym207__; + double lcm_sym206__; + double lcm_sym170__; + double lcm_sym205__; + double lcm_sym204__; + double lcm_sym203__; + double lcm_sym202__; + double lcm_sym201__; + double lcm_sym200__; + double lcm_sym199__; + double lcm_sym198__; + double lcm_sym197__; + double lcm_sym196__; + int lcm_sym195__; + int lcm_sym194__; + int lcm_sym193__; + int lcm_sym192__; + double lcm_sym191__; + int lcm_sym188__; + int lcm_sym187__; + int lcm_sym186__; + int lcm_sym185__; + int lcm_sym184__; + int lcm_sym183__; + int lcm_sym182__; + double lcm_sym181__; + int lcm_sym180__; + int lcm_sym179__; + int lcm_sym178__; + Eigen::Matrix lcm_sym177__; + std::vector lcm_sym176__; + std::vector> lcm_sym175__; + Eigen::Matrix lcm_sym174__; + double lcm_sym169__; + double lcm_sym168__; + double lcm_sym167__; + double lcm_sym166__; + double lcm_sym173__; + double lcm_sym172__; + int lcm_sym171__; + int lcm_sym165__; + int lcm_sym164__; + int lcm_sym163__; + int lcm_sym162__; + double lcm_sym161__; + int lcm_sym160__; + int lcm_sym159__; + double lcm_sym158__; + int lcm_sym157__; + int lcm_sym156__; + int lcm_sym155__; + int lcm_sym154__; + int lcm_sym153__; + int lcm_sym152__; + int lcm_sym151__; + int lcm_sym150__; + int lcm_sym149__; + int lcm_sym148__; + int lcm_sym147__; + int lcm_sym146__; + int lcm_sym145__; + int lcm_sym144__; + int lcm_sym143__; + double lcm_sym142__; + double lcm_sym141__; + Eigen::Matrix lcm_sym140__; + double mean_phi; + + current_statement__ = 1; + mean_phi = in__.scalar(); + current_statement__ = 1; + mean_phi = stan::math::lub_constrain(mean_phi, 0, 1); + double mean_p; + + current_statement__ = 2; + mean_p = in__.scalar(); + current_statement__ = 2; + mean_p = stan::math::lub_constrain(mean_p, 0, 1); + double psi; + + current_statement__ = 3; + psi = in__.scalar(); + current_statement__ = 3; + psi = stan::math::lub_constrain(psi, 0, 1); + current_statement__ = 4; + validate_non_negative_index("beta", "n_occasions", n_occasions); + Eigen::Matrix beta; + beta = Eigen::Matrix(n_occasions); + + current_statement__ = 4; + beta = in__.vector(n_occasions); + lcm_sym144__ = logical_gte(n_occasions, 1); + if (lcm_sym144__) { + current_statement__ = 4; + assign(beta, cons_list(index_uni(1), nil_index_list()), + stan::math::lb_constrain(beta[(1 - 1)], 0), + "assigning variable beta"); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 4; + assign(beta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(beta[(sym1__ - 1)], 0), + "assigning variable beta");} + } + current_statement__ = 5; + validate_non_negative_index("epsilon", "M", M); + Eigen::Matrix epsilon; + epsilon = Eigen::Matrix(M); + + current_statement__ = 5; + epsilon = in__.vector(M); + double sigma; + + current_statement__ = 6; + sigma = in__.scalar(); + current_statement__ = 6; + sigma = stan::math::lub_constrain(sigma, 0, 5); + current_statement__ = 7; + validate_non_negative_index("phi", "M", M); + lcm_sym153__ = (n_occasions - 1); + validate_non_negative_index("phi", "(n_occasions - 1)", lcm_sym153__); + Eigen::Matrix phi; + phi = Eigen::Matrix(M, lcm_sym153__); + + lcm_sym143__ = logical_gte(M, 1); + if (lcm_sym143__) { + { + lcm_sym146__ = logical_gte(lcm_sym153__, 1); + if (lcm_sym146__) { + { + lcm_sym191__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym191__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym153__; ++sym2__) { + current_statement__ = 7; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym191__, "assigning variable phi");} + } + } else { + lcm_sym191__ = std::numeric_limits::quiet_NaN(); + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 7; + if (lcm_sym146__) { + current_statement__ = 7; + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym191__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym153__; ++sym2__) { + current_statement__ = 7; + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym191__, "assigning variable phi");} + } } + } + } else { + lcm_sym191__ = std::numeric_limits::quiet_NaN(); + lcm_sym146__ = logical_gte(lcm_sym153__, 1); + } + current_statement__ = 8; + validate_non_negative_index("p", "M", M); + current_statement__ = 8; + validate_non_negative_index("p", "n_occasions", n_occasions); + Eigen::Matrix p; + p = Eigen::Matrix(M, n_occasions); + + current_statement__ = 8; + if (lcm_sym143__) { + current_statement__ = 8; + if (lcm_sym144__) { + current_statement__ = 8; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym191__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 8; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym191__, "assigning variable p");} + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 8; + if (lcm_sym144__) { + current_statement__ = 8; + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym191__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 8; + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym191__, "assigning variable p");} + } } + } + current_statement__ = 9; + validate_non_negative_index("b", "n_occasions", n_occasions); + Eigen::Matrix b; + b = Eigen::Matrix(n_occasions); + + current_statement__ = 9; + if (lcm_sym144__) { + current_statement__ = 9; + assign(b, cons_list(index_uni(1), nil_index_list()), lcm_sym191__, + "assigning variable b"); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 9; + assign(b, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym191__, "assigning variable b");} + } + current_statement__ = 10; + validate_non_negative_index("nu", "n_occasions", n_occasions); + Eigen::Matrix nu; + nu = Eigen::Matrix(n_occasions); + + current_statement__ = 10; + if (lcm_sym144__) { + current_statement__ = 10; + assign(nu, cons_list(index_uni(1), nil_index_list()), lcm_sym191__, + "assigning variable nu"); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 10; + assign(nu, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym191__, "assigning variable nu");} + } + current_statement__ = 11; + validate_non_negative_index("chi", "M", M); + current_statement__ = 11; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix chi; + chi = Eigen::Matrix(M, n_occasions); + + current_statement__ = 11; + if (lcm_sym143__) { + current_statement__ = 11; + if (lcm_sym144__) { + current_statement__ = 11; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym191__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 11; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym191__, "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 11; + if (lcm_sym144__) { + current_statement__ = 11; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym191__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 11; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym191__, "assigning variable chi");} + } } + } + vars__.push_back(mean_phi); + vars__.push_back(mean_p); + vars__.push_back(psi); + if (lcm_sym144__) { + vars__.push_back(beta[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + vars__.push_back(beta[(sym1__ - 1)]);} + } + if (lcm_sym143__) { + vars__.push_back(epsilon[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + vars__.push_back(epsilon[(sym1__ - 1)]);} + } + vars__.push_back(sigma); + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + assign(lcm_sym177__, nil_index_list(), + rep_matrix(mean_phi, M, lcm_sym153__), + "assigning variable lcm_sym177__"); + assign(phi, nil_index_list(), lcm_sym177__, "assigning variable phi"); + current_statement__ = 13; + if (lcm_sym144__) { + assign(lcm_sym174__, nil_index_list(), + inv_logit(add(logit(mean_p), epsilon)), + "assigning variable lcm_sym174__"); + assign(p, + cons_list(index_omni(), cons_list(index_uni(1), nil_index_list())), + lcm_sym174__, "assigning variable p"); + for (size_t t = 2; t <= n_occasions; ++t) { + current_statement__ = 12; + assign(p, + cons_list(index_omni(), + cons_list(index_uni(t), nil_index_list())), lcm_sym174__, + "assigning variable p");} + } + assign(lcm_sym140__, nil_index_list(), divide(beta, sum(beta)), + "assigning variable lcm_sym140__"); + assign(b, nil_index_list(), lcm_sym140__, "assigning variable b"); + { + local_scalar_t__ cum_b; + + lcm_sym219__ = lcm_sym140__[(1 - 1)]; + current_statement__ = 15; + assign(nu, cons_list(index_uni(1), nil_index_list()), lcm_sym219__, + "assigning variable nu"); + current_statement__ = 19; + if (logical_gte(lcm_sym153__, 2)) { + current_statement__ = 16; + assign(nu, cons_list(index_uni(2), nil_index_list()), + (lcm_sym140__[(2 - 1)] / (1.0 - lcm_sym219__)), + "assigning variable nu"); + current_statement__ = 17; + cum_b = (lcm_sym219__ + lcm_sym140__[(2 - 1)]); + for (size_t t = 3; t <= lcm_sym153__; ++t) { + current_statement__ = 16; + assign(nu, cons_list(index_uni(t), nil_index_list()), + (lcm_sym140__[(t - 1)] / (1.0 - cum_b)), + "assigning variable nu"); + current_statement__ = 17; + cum_b = (cum_b + lcm_sym140__[(t - 1)]);} + } + current_statement__ = 20; + assign(nu, cons_list(index_uni(n_occasions), nil_index_list()), 1.0, + "assigning variable nu"); + } + Eigen::Matrix inline_sym1__; + int inline_sym11__; + + inline_sym11__ = 0; + for (size_t inline_sym12__ = 1; inline_sym12__ <= 1; ++inline_sym12__) { + int inline_sym2__; + + lcm_sym178__ = rows(p); + int inline_sym3__; + + lcm_sym171__ = cols(p); + current_statement__ = 24; + validate_non_negative_index("chi", "n_ind", lcm_sym178__); + current_statement__ = 24; + validate_non_negative_index("chi", "n_occasions", lcm_sym171__); + Eigen::Matrix inline_sym4__; + inline_sym4__ = Eigen::Matrix(lcm_sym178__, lcm_sym171__); + + for (size_t inline_sym6__ = 1; inline_sym6__ <= lcm_sym178__; + ++inline_sym6__) { + if (logical_gte(lcm_sym171__, 1)) { + current_statement__ = 24; + assign(inline_sym4__, + cons_list(index_uni(inline_sym6__), + cons_list(index_uni(1), nil_index_list())), lcm_sym191__, + "assigning variable inline_sym4__"); + for (size_t inline_sym5__ = 2; inline_sym5__ <= lcm_sym171__; + ++inline_sym5__) { + current_statement__ = 24; + assign(inline_sym4__, + cons_list(index_uni(inline_sym6__), + cons_list(index_uni(inline_sym5__), nil_index_list())), + lcm_sym191__, "assigning variable inline_sym4__");} + } + if (inline_sym11__) { + break; + } } + if (inline_sym11__) { + break; + } + for (size_t inline_sym10__ = 1; inline_sym10__ <= lcm_sym178__; + ++inline_sym10__) { + current_statement__ = 25; + assign(inline_sym4__, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym171__), nil_index_list())), 1.0, + "assigning variable inline_sym4__"); + lcm_sym155__ = (lcm_sym171__ - 1); + if (logical_gte(lcm_sym155__, 1)) { + int inline_sym7__; + + int inline_sym8__; + + lcm_sym160__ = (lcm_sym155__ + 1); + current_statement__ = 28; + assign(inline_sym4__, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym155__), nil_index_list())), + stan::math::fma( + (rvalue(lcm_sym177__, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym155__), nil_index_list())), + "lcm_sym177__") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym160__), nil_index_list())), + "p"))), + rvalue(inline_sym4__, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym160__), nil_index_list())), + "inline_sym4__"), + (1 - + rvalue(lcm_sym177__, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym155__), nil_index_list())), + "lcm_sym177__"))), "assigning variable inline_sym4__"); + for (size_t inline_sym9__ = 2; inline_sym9__ <= lcm_sym155__; + ++inline_sym9__) { + int inline_sym7__; + + lcm_sym154__ = (lcm_sym171__ - inline_sym9__); + int inline_sym8__; + + lcm_sym159__ = (lcm_sym154__ + 1); + current_statement__ = 28; + assign(inline_sym4__, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym154__), nil_index_list())), + stan::math::fma( + (rvalue(lcm_sym177__, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym154__), nil_index_list())), + "lcm_sym177__") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym159__), + nil_index_list())), "p"))), + rvalue(inline_sym4__, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym159__), nil_index_list())), + "inline_sym4__"), + (1 - + rvalue(lcm_sym177__, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym154__), nil_index_list())), + "lcm_sym177__"))), "assigning variable inline_sym4__"); + } + } + if (inline_sym11__) { + break; + } } + if (inline_sym11__) { + break; + } + inline_sym11__ = 1; + assign(inline_sym1__, nil_index_list(), inline_sym4__, + "assigning variable inline_sym1__"); + break;} + assign(chi, nil_index_list(), inline_sym1__, "assigning variable chi"); + if (lcm_sym146__) { + if (lcm_sym143__) { + vars__.push_back( + rvalue(lcm_sym177__, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "lcm_sym177__")); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + vars__.push_back( + rvalue(lcm_sym177__, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), "lcm_sym177__")); + } + } + for (size_t sym1__ = 2; sym1__ <= lcm_sym153__; ++sym1__) { + if (lcm_sym143__) { + vars__.push_back( + rvalue(lcm_sym177__, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + "lcm_sym177__")); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + vars__.push_back( + rvalue(lcm_sym177__, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "lcm_sym177__"));} + } } + } + if (lcm_sym144__) { + if (lcm_sym143__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "p")); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), "p"));} + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + if (lcm_sym143__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), "p")); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "p"));} + } } + } + if (lcm_sym144__) { + vars__.push_back(lcm_sym140__[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + vars__.push_back(lcm_sym140__[(sym1__ - 1)]);} + } + if (lcm_sym144__) { + vars__.push_back(nu[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + vars__.push_back(nu[(sym1__ - 1)]);} + } + if (lcm_sym144__) { + if (lcm_sym143__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "inline_sym1__")); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + "inline_sym1__"));} + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + if (lcm_sym143__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + "inline_sym1__")); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "inline_sym1__"));} + } } + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + double sigma2; + + current_statement__ = 32; + sigma2 = lcm_sym191__; + int Nsuper; + + current_statement__ = 34; + validate_non_negative_index("N", "n_occasions", n_occasions); + std::vector N; + N = std::vector(n_occasions, 0); + + current_statement__ = 35; + validate_non_negative_index("B", "n_occasions", n_occasions); + std::vector B; + B = std::vector(n_occasions, 0); + + current_statement__ = 36; + validate_non_negative_index("z", "M", M); + current_statement__ = 36; + validate_non_negative_index("z", "n_occasions", n_occasions); + std::vector> z; + z = std::vector>(M, std::vector(n_occasions, 0)); + + lcm_sym181__ = square(sigma); + sigma2 = lcm_sym181__; + current_statement__ = 48; + if (lcm_sym143__) { + int q; + + current_statement__ = 46; + if (bernoulli_rng(psi, base_rng__)) { + current_statement__ = 40; + assign(z, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + bernoulli_rng(nu[(1 - 1)], base_rng__), "assigning variable z"); + current_statement__ = 44; + if (logical_gte(n_occasions, 2)) { + lcm_sym216__ = z[(1 - 1)][(1 - 1)]; + lcm_sym165__ = (1 * (1 - lcm_sym216__)); + q = lcm_sym165__; + current_statement__ = 41; + assign(z, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), + bernoulli_rng( + stan::math::fma(lcm_sym216__, + rvalue(lcm_sym177__, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + "lcm_sym177__"), (lcm_sym165__ * nu[(2 - 1)])), + base_rng__), "assigning variable z"); + for (size_t t = 3; t <= n_occasions; ++t) { + current_statement__ = 42; + q = (q * (1 - z[(1 - 1)][((t - 1) - 1)])); + current_statement__ = 41; + assign(z, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), + bernoulli_rng( + stan::math::fma(z[(1 - 1)][((t - 1) - 1)], + rvalue(lcm_sym177__, + cons_list(index_uni(1), + cons_list(index_uni((t - 1)), nil_index_list())), + "lcm_sym177__"), (q * nu[(t - 1)])), base_rng__), + "assigning variable z");} + } + } else { + current_statement__ = 38; + assign(z, + cons_list(index_uni(1), + cons_list(index_omni(), nil_index_list())), + rep_array(0, n_occasions), "assigning variable z"); + } + for (size_t i = 2; i <= M; ++i) { + int q; + + current_statement__ = 46; + if (bernoulli_rng(psi, base_rng__)) { + current_statement__ = 40; + assign(z, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), + bernoulli_rng(nu[(1 - 1)], base_rng__), "assigning variable z"); + current_statement__ = 44; + if (logical_gte(n_occasions, 2)) { + lcm_sym164__ = (1 * (1 - z[(i - 1)][(1 - 1)])); + q = lcm_sym164__; + current_statement__ = 41; + assign(z, + cons_list(index_uni(i), + cons_list(index_uni(2), nil_index_list())), + bernoulli_rng( + stan::math::fma(z[(i - 1)][(1 - 1)], + rvalue(lcm_sym177__, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), + "lcm_sym177__"), (lcm_sym164__ * nu[(2 - 1)])), + base_rng__), "assigning variable z"); + for (size_t t = 3; t <= n_occasions; ++t) { + current_statement__ = 42; + q = (q * (1 - z[(i - 1)][((t - 1) - 1)])); + current_statement__ = 41; + assign(z, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), + bernoulli_rng( + stan::math::fma(z[(i - 1)][((t - 1) - 1)], + rvalue(lcm_sym177__, + cons_list(index_uni(i), + cons_list(index_uni((t - 1)), nil_index_list())), + "lcm_sym177__"), (q * nu[(t - 1)])), base_rng__), + "assigning variable z");} + } + } else { + current_statement__ = 38; + assign(z, + cons_list(index_uni(i), + cons_list(index_omni(), nil_index_list())), + rep_array(0, n_occasions), "assigning variable z"); + }} + } + { + current_statement__ = 49; + validate_non_negative_index("recruit", "M", M); + current_statement__ = 49; + validate_non_negative_index("recruit", "n_occasions", n_occasions); + std::vector> recruit; + recruit = std::vector>(M, std::vector(n_occasions, 0)); + + current_statement__ = 49; + assign(recruit, nil_index_list(), rep_array(0, M, n_occasions), + "assigning variable recruit"); + current_statement__ = 50; + validate_non_negative_index("Nind", "M", M); + std::vector Nind; + Nind = std::vector(M, 0); + + current_statement__ = 51; + validate_non_negative_index("Nalive", "M", M); + std::vector Nalive; + Nalive = std::vector(M, 0); + + current_statement__ = 59; + if (lcm_sym143__) { + int f; + + int inline_sym13__; + int inline_sym15__; + + inline_sym15__ = 0; + for (size_t inline_sym16__ = 1; inline_sym16__ <= 1; + ++inline_sym16__) { + lcm_sym180__ = size(z[(1 - 1)]); + for (size_t inline_sym14__ = 1; inline_sym14__ <= lcm_sym180__; + ++inline_sym14__) { + current_statement__ = 54; + if (z[(1 - 1)][(inline_sym14__ - 1)]) { + inline_sym15__ = 1; + inline_sym13__ = inline_sym14__; + break; + } } + if (inline_sym15__) { + break; + } + inline_sym15__ = 1; + inline_sym13__ = 0; + break;} + current_statement__ = 57; + if (logical_gt(inline_sym13__, 0)) { + current_statement__ = 56; + assign(recruit, + cons_list(index_uni(1), + cons_list(index_uni(inline_sym13__), nil_index_list())), 1, + "assigning variable recruit"); + } + for (size_t i = 2; i <= M; ++i) { + int f; + + int inline_sym13__; + int inline_sym15__; + + inline_sym15__ = 0; + for (size_t inline_sym16__ = 1; inline_sym16__ <= 1; + ++inline_sym16__) { + lcm_sym179__ = size(z[(i - 1)]); + for (size_t inline_sym14__ = 1; inline_sym14__ <= lcm_sym179__; + ++inline_sym14__) { + current_statement__ = 54; + if (z[(i - 1)][(inline_sym14__ - 1)]) { + inline_sym15__ = 1; + inline_sym13__ = inline_sym14__; + break; + } } + if (inline_sym15__) { + break; + } + inline_sym15__ = 1; + inline_sym13__ = 0; + break;} + current_statement__ = 57; + if (logical_gt(inline_sym13__, 0)) { + current_statement__ = 56; + assign(recruit, + cons_list(index_uni(i), + cons_list(index_uni(inline_sym13__), nil_index_list())), 1, + "assigning variable recruit"); + } } + } + current_statement__ = 63; + if (lcm_sym144__) { + current_statement__ = 60; + assign(N, cons_list(index_uni(1), nil_index_list()), + sum( + rvalue(z, + cons_list(index_omni(), + cons_list(index_uni(1), nil_index_list())), "z")), + "assigning variable N"); + current_statement__ = 61; + assign(B, cons_list(index_uni(1), nil_index_list()), + sum( + rvalue(recruit, + cons_list(index_omni(), + cons_list(index_uni(1), nil_index_list())), "recruit")), + "assigning variable B"); + for (size_t t = 2; t <= n_occasions; ++t) { + current_statement__ = 60; + assign(N, cons_list(index_uni(t), nil_index_list()), + sum( + rvalue(z, + cons_list(index_omni(), + cons_list(index_uni(t), nil_index_list())), "z")), + "assigning variable N"); + current_statement__ = 61; + assign(B, cons_list(index_uni(t), nil_index_list()), + sum( + rvalue(recruit, + cons_list(index_omni(), + cons_list(index_uni(t), nil_index_list())), "recruit")), + "assigning variable B");} + } + current_statement__ = 67; + if (lcm_sym143__) { + current_statement__ = 64; + assign(Nind, cons_list(index_uni(1), nil_index_list()), + sum(z[(1 - 1)]), "assigning variable Nind"); + current_statement__ = 65; + assign(Nalive, cons_list(index_uni(1), nil_index_list()), + logical_gt(Nind[(1 - 1)], 0), "assigning variable Nalive"); + for (size_t i = 2; i <= M; ++i) { + current_statement__ = 64; + assign(Nind, cons_list(index_uni(i), nil_index_list()), + sum(z[(i - 1)]), "assigning variable Nind"); + current_statement__ = 65; + assign(Nalive, cons_list(index_uni(i), nil_index_list()), + logical_gt(Nind[(i - 1)], 0), "assigning variable Nalive");} + } + current_statement__ = 68; + Nsuper = sum(Nalive); + } + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "sigma2", lcm_sym181__, 0); + current_statement__ = 33; + current_statement__ = 33; + check_greater_or_equal(function__, "Nsuper", Nsuper, 0); + current_statement__ = 34; + if (lcm_sym144__) { + current_statement__ = 34; + current_statement__ = 34; + check_greater_or_equal(function__, "N[sym1__]", N[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 34; + current_statement__ = 34; + check_greater_or_equal(function__, "N[sym1__]", N[(sym1__ - 1)], 0); + } + } + current_statement__ = 35; + if (lcm_sym144__) { + current_statement__ = 35; + current_statement__ = 35; + check_greater_or_equal(function__, "B[sym1__]", B[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 35; + current_statement__ = 35; + check_greater_or_equal(function__, "B[sym1__]", B[(sym1__ - 1)], 0); + } + } + current_statement__ = 36; + if (lcm_sym143__) { + current_statement__ = 36; + if (lcm_sym144__) { + current_statement__ = 36; + current_statement__ = 36; + check_greater_or_equal(function__, "z[sym1__, sym2__]", + z[(1 - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 36; + current_statement__ = 36; + check_greater_or_equal(function__, "z[sym1__, sym2__]", + z[(1 - 1)][(sym2__ - 1)], 0);} + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 36; + if (lcm_sym144__) { + current_statement__ = 36; + current_statement__ = 36; + check_greater_or_equal(function__, "z[sym1__, sym2__]", + z[(sym1__ - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 36; + current_statement__ = 36; + check_greater_or_equal(function__, "z[sym1__, sym2__]", + z[(sym1__ - 1)][(sym2__ - 1)], 0);} + } } + } + current_statement__ = 36; + if (lcm_sym143__) { + current_statement__ = 36; + if (lcm_sym144__) { + current_statement__ = 36; + current_statement__ = 36; + check_less_or_equal(function__, "z[sym1__, sym2__]", + z[(1 - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 36; + current_statement__ = 36; + check_less_or_equal(function__, "z[sym1__, sym2__]", + z[(1 - 1)][(sym2__ - 1)], 1);} + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 36; + if (lcm_sym144__) { + current_statement__ = 36; + current_statement__ = 36; + check_less_or_equal(function__, "z[sym1__, sym2__]", + z[(sym1__ - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 36; + current_statement__ = 36; + check_less_or_equal(function__, "z[sym1__, sym2__]", + z[(sym1__ - 1)][(sym2__ - 1)], 1);} + } } + } + vars__.push_back(lcm_sym181__); + vars__.push_back(Nsuper); + if (lcm_sym144__) { + vars__.push_back(N[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + vars__.push_back(N[(sym1__ - 1)]);} + } + if (lcm_sym144__) { + vars__.push_back(B[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + vars__.push_back(B[(sym1__ - 1)]);} + } + if (lcm_sym144__) { + if (lcm_sym143__) { + vars__.push_back(z[(1 - 1)][(1 - 1)]); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + vars__.push_back(z[(sym2__ - 1)][(1 - 1)]);} + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + if (lcm_sym143__) { + vars__.push_back(z[(1 - 1)][(sym1__ - 1)]); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + vars__.push_back(z[(sym2__ - 1)][(sym1__ - 1)]);} + } } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + double lcm_sym139__; + double lcm_sym138__; + double lcm_sym137__; + double lcm_sym136__; + double lcm_sym135__; + double lcm_sym134__; + double lcm_sym133__; + double lcm_sym132__; + int lcm_sym129__; + int lcm_sym128__; + int lcm_sym127__; + int pos__; + + pos__ = 1; + double mean_phi; + + current_statement__ = 1; + mean_phi = context__.vals_r("mean_phi")[(1 - 1)]; + current_statement__ = 1; + mean_phi = stan::math::lub_free(mean_phi, 0, 1); + double mean_p; + + current_statement__ = 2; + mean_p = context__.vals_r("mean_p")[(1 - 1)]; + current_statement__ = 2; + mean_p = stan::math::lub_free(mean_p, 0, 1); + double psi; + + current_statement__ = 3; + psi = context__.vals_r("psi")[(1 - 1)]; + current_statement__ = 3; + psi = stan::math::lub_free(psi, 0, 1); + current_statement__ = 4; + validate_non_negative_index("beta", "n_occasions", n_occasions); + Eigen::Matrix beta; + beta = Eigen::Matrix(n_occasions); + + { + std::vector beta_flat__; + current_statement__ = 4; + assign(beta_flat__, nil_index_list(), context__.vals_r("beta"), + "assigning variable beta_flat__"); + current_statement__ = 4; + pos__ = 1; + lcm_sym128__ = logical_gte(n_occasions, 1); + if (lcm_sym128__) { + current_statement__ = 4; + assign(beta, cons_list(index_uni(1), nil_index_list()), + beta_flat__[(1 - 1)], "assigning variable beta"); + current_statement__ = 4; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 4; + assign(beta, cons_list(index_uni(sym1__), nil_index_list()), + beta_flat__[(pos__ - 1)], "assigning variable beta"); + current_statement__ = 4; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 4; + if (lcm_sym128__) { + current_statement__ = 4; + assign(beta, cons_list(index_uni(1), nil_index_list()), + stan::math::lb_free(beta[(1 - 1)], 0), "assigning variable beta"); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 4; + assign(beta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_free(beta[(sym1__ - 1)], 0), + "assigning variable beta");} + } + current_statement__ = 5; + validate_non_negative_index("epsilon", "M", M); + Eigen::Matrix epsilon; + epsilon = Eigen::Matrix(M); + + { + std::vector epsilon_flat__; + current_statement__ = 5; + assign(epsilon_flat__, nil_index_list(), context__.vals_r("epsilon"), + "assigning variable epsilon_flat__"); + current_statement__ = 5; + pos__ = 1; + lcm_sym127__ = logical_gte(M, 1); + if (lcm_sym127__) { + current_statement__ = 5; + assign(epsilon, cons_list(index_uni(1), nil_index_list()), + epsilon_flat__[(1 - 1)], "assigning variable epsilon"); + current_statement__ = 5; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 5; + assign(epsilon, cons_list(index_uni(sym1__), nil_index_list()), + epsilon_flat__[(pos__ - 1)], "assigning variable epsilon"); + current_statement__ = 5; + pos__ = (pos__ + 1);} + } + } + double sigma; + + current_statement__ = 6; + sigma = context__.vals_r("sigma")[(1 - 1)]; + current_statement__ = 6; + sigma = stan::math::lub_free(sigma, 0, 5); + vars__.push_back(mean_phi); + vars__.push_back(mean_p); + vars__.push_back(psi); + if (lcm_sym128__) { + vars__.push_back(beta[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + vars__.push_back(beta[(sym1__ - 1)]);} + } + if (lcm_sym127__) { + vars__.push_back(epsilon[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + vars__.push_back(epsilon[(sym1__ - 1)]);} + } + vars__.push_back(sigma); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("mean_phi"); + names__.push_back("mean_p"); + names__.push_back("psi"); + names__.push_back("beta"); + names__.push_back("epsilon"); + names__.push_back("sigma"); + names__.push_back("phi"); + names__.push_back("p"); + names__.push_back("b"); + names__.push_back("nu"); + names__.push_back("chi"); + names__.push_back("sigma2"); + names__.push_back("Nsuper"); + names__.push_back("N"); + names__.push_back("B"); + names__.push_back("z"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(M); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(M); + + dims__.push_back((n_occasions - 1)); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(M); + + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(M); + + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(M); + + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "mean_phi"); + param_names__.push_back(std::string() + "mean_p"); + param_names__.push_back(std::string() + "psi"); + for (size_t sym333__ = 1; sym333__ <= n_occasions; ++sym333__) { + { + param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym333__)); + }} + for (size_t sym333__ = 1; sym333__ <= M; ++sym333__) { + { + param_names__.push_back(std::string() + "epsilon" + '.' + std::to_string(sym333__)); + }} + param_names__.push_back(std::string() + "sigma"); + if (emit_transformed_parameters__) { + for (size_t sym333__ = 1; sym333__ <= (n_occasions - 1); ++sym333__) { + { + for (size_t sym334__ = 1; sym334__ <= M; ++sym334__) { + { + param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym334__) + '.' + std::to_string(sym333__)); + }} + }} + for (size_t sym333__ = 1; sym333__ <= n_occasions; ++sym333__) { + { + for (size_t sym334__ = 1; sym334__ <= M; ++sym334__) { + { + param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym334__) + '.' + std::to_string(sym333__)); + }} + }} + for (size_t sym333__ = 1; sym333__ <= n_occasions; ++sym333__) { + { + param_names__.push_back(std::string() + "b" + '.' + std::to_string(sym333__)); + }} + for (size_t sym333__ = 1; sym333__ <= n_occasions; ++sym333__) { + { + param_names__.push_back(std::string() + "nu" + '.' + std::to_string(sym333__)); + }} + for (size_t sym333__ = 1; sym333__ <= n_occasions; ++sym333__) { + { + for (size_t sym334__ = 1; sym334__ <= M; ++sym334__) { + { + param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym334__) + '.' + std::to_string(sym333__)); + }} + }} + } + + if (emit_generated_quantities__) { + param_names__.push_back(std::string() + "sigma2"); + param_names__.push_back(std::string() + "Nsuper"); + for (size_t sym333__ = 1; sym333__ <= n_occasions; ++sym333__) { + { + param_names__.push_back(std::string() + "N" + '.' + std::to_string(sym333__)); + }} + for (size_t sym333__ = 1; sym333__ <= n_occasions; ++sym333__) { + { + param_names__.push_back(std::string() + "B" + '.' + std::to_string(sym333__)); + }} + for (size_t sym333__ = 1; sym333__ <= n_occasions; ++sym333__) { + { + for (size_t sym334__ = 1; sym334__ <= M; ++sym334__) { + { + param_names__.push_back(std::string() + "z" + '.' + std::to_string(sym334__) + '.' + std::to_string(sym333__)); + }} + }} + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "mean_phi"); + param_names__.push_back(std::string() + "mean_p"); + param_names__.push_back(std::string() + "psi"); + for (size_t sym333__ = 1; sym333__ <= n_occasions; ++sym333__) { + { + param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym333__)); + }} + for (size_t sym333__ = 1; sym333__ <= M; ++sym333__) { + { + param_names__.push_back(std::string() + "epsilon" + '.' + std::to_string(sym333__)); + }} + param_names__.push_back(std::string() + "sigma"); + if (emit_transformed_parameters__) { + for (size_t sym333__ = 1; sym333__ <= (n_occasions - 1); ++sym333__) { + { + for (size_t sym334__ = 1; sym334__ <= M; ++sym334__) { + { + param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym334__) + '.' + std::to_string(sym333__)); + }} + }} + for (size_t sym333__ = 1; sym333__ <= n_occasions; ++sym333__) { + { + for (size_t sym334__ = 1; sym334__ <= M; ++sym334__) { + { + param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym334__) + '.' + std::to_string(sym333__)); + }} + }} + for (size_t sym333__ = 1; sym333__ <= (n_occasions - 1); ++sym333__) { + { + param_names__.push_back(std::string() + "b" + '.' + std::to_string(sym333__)); + }} + for (size_t sym333__ = 1; sym333__ <= n_occasions; ++sym333__) { + { + param_names__.push_back(std::string() + "nu" + '.' + std::to_string(sym333__)); + }} + for (size_t sym333__ = 1; sym333__ <= n_occasions; ++sym333__) { + { + for (size_t sym334__ = 1; sym334__ <= M; ++sym334__) { + { + param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym334__) + '.' + std::to_string(sym333__)); + }} + }} + } + + if (emit_generated_quantities__) { + param_names__.push_back(std::string() + "sigma2"); + param_names__.push_back(std::string() + "Nsuper"); + for (size_t sym333__ = 1; sym333__ <= n_occasions; ++sym333__) { + { + param_names__.push_back(std::string() + "N" + '.' + std::to_string(sym333__)); + }} + for (size_t sym333__ = 1; sym333__ <= n_occasions; ++sym333__) { + { + param_names__.push_back(std::string() + "B" + '.' + std::to_string(sym333__)); + }} + for (size_t sym333__ = 1; sym333__ <= n_occasions; ++sym333__) { + { + for (size_t sym334__ = 1; sym334__ <= M; ++sym334__) { + { + param_names__.push_back(std::string() + "z" + '.' + std::to_string(sym334__) + '.' + std::to_string(sym333__)); + }} + }} + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mean_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"psi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"parameters\"},{\"name\":\"epsilon\",\"type\":{\"name\":\"vector\",\"length\":" << M << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << (n_occasions - 1) << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"nu\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"Nsuper\",\"type\":{\"name\":\"int\"},\"block\":\"generated_quantities\"},{\"name\":\"N\",\"type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"B\",\"type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"z\",\"type\":{\"name\":\"array\",\"length\":" << M << ",\"element_type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}}},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mean_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"psi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"parameters\"},{\"name\":\"epsilon\",\"type\":{\"name\":\"vector\",\"length\":" << M << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << (n_occasions - 1) << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" << (n_occasions - 1) << "},\"block\":\"transformed_parameters\"},{\"name\":\"nu\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"Nsuper\",\"type\":{\"name\":\"int\"},\"block\":\"generated_quantities\"},{\"name\":\"N\",\"type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"B\",\"type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"z\",\"type\":{\"name\":\"array\",\"length\":" << M << ",\"element_type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}}},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef expr_prop_fail6_model_namespace::expr_prop_fail6_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-fail7.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace expr_prop_fail7_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'expr-prop-fail7.stan', line 20, column 2 to column 16)", + " (in 'expr-prop-fail7.stan', line 21, column 2 to column 24)", + " (in 'expr-prop-fail7.stan', line 40, column 2 to column 24)", + " (in 'expr-prop-fail7.stan', line 42, column 4 to column 30)", + " (in 'expr-prop-fail7.stan', line 44, column 6 to column 51)", + " (in 'expr-prop-fail7.stan', line 43, column 4 to line 44, column 51)", + " (in 'expr-prop-fail7.stan', line 45, column 4 to column 45)", + " (in 'expr-prop-fail7.stan', line 41, column 17 to line 46, column 3)", + " (in 'expr-prop-fail7.stan', line 41, column 2 to line 46, column 3)", + " (in 'expr-prop-fail7.stan', line 25, column 2 to column 24)", + " (in 'expr-prop-fail7.stan', line 28, column 6 to column 39)", + " (in 'expr-prop-fail7.stan', line 27, column 4 to line 28, column 39)", + " (in 'expr-prop-fail7.stan', line 26, column 2 to line 28, column 39)", + " (in 'expr-prop-fail7.stan', line 32, column 4 to column 30)", + " (in 'expr-prop-fail7.stan', line 34, column 6 to column 51)", + " (in 'expr-prop-fail7.stan', line 33, column 4 to line 34, column 51)", + " (in 'expr-prop-fail7.stan', line 35, column 4 to column 33)", + " (in 'expr-prop-fail7.stan', line 31, column 17 to line 36, column 3)", + " (in 'expr-prop-fail7.stan', line 31, column 2 to line 36, column 3)", + " (in 'expr-prop-fail7.stan', line 12, column 2 to column 17)", + " (in 'expr-prop-fail7.stan', line 13, column 2 to column 17)", + " (in 'expr-prop-fail7.stan', line 14, column 2 to column 17)", + " (in 'expr-prop-fail7.stan', line 15, column 2 to column 30)", + " (in 'expr-prop-fail7.stan', line 16, column 2 to column 27)", + " (in 'expr-prop-fail7.stan', line 17, column 2 to column 29)"}; + + + +class expr_prop_fail7_model : public model_base_crtp { + + private: + int lcm_sym93__; + int lcm_sym92__; + int lcm_sym91__; + int lcm_sym90__; + int lcm_sym89__; + int lcm_sym88__; + double lcm_sym87__; + double lcm_sym86__; + Eigen::Matrix lcm_sym85__; + Eigen::Matrix lcm_sym84__; + double lcm_sym83__; + double lcm_sym82__; + int lcm_sym81__; + int lcm_sym80__; + int lcm_sym79__; + int lcm_sym78__; + int pos__; + int K; + int I; + int J; + std::vector> y; + Eigen::Matrix alpha; + std::vector> beta; + + public: + ~expr_prop_fail7_model() { } + + std::string model_name() const { return "expr_prop_fail7_model"; } + + expr_prop_fail7_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "expr_prop_fail7_model_namespace::expr_prop_fail7_model"; + (void) function__; // suppress unused var warning + + try { + + + + + + + + + + + + + + + + + + pos__ = 1; + context__.validate_dims("data initialization","K","int", + context__.to_vec()); + + current_statement__ = 20; + K = context__.vals_i("K")[(1 - 1)]; + context__.validate_dims("data initialization","I","int", + context__.to_vec()); + + current_statement__ = 21; + I = context__.vals_i("I")[(1 - 1)]; + context__.validate_dims("data initialization","J","int", + context__.to_vec()); + + current_statement__ = 22; + J = context__.vals_i("J")[(1 - 1)]; + current_statement__ = 23; + validate_non_negative_index("y", "I", I); + current_statement__ = 23; + validate_non_negative_index("y", "J", J); + context__.validate_dims("data initialization","y","int", + context__.to_vec(I, J)); + y = std::vector>(I, std::vector(J, 0)); + + { + std::vector y_flat__; + current_statement__ = 23; + assign(y_flat__, nil_index_list(), context__.vals_i("y"), + "assigning variable y_flat__"); + current_statement__ = 23; + pos__ = 1; + lcm_sym79__ = logical_gte(J, 1); + if (lcm_sym79__) { + { + lcm_sym78__ = logical_gte(I, 1); + if (lcm_sym78__) { + current_statement__ = 23; + assign(y, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + y_flat__[(1 - 1)], "assigning variable y"); + current_statement__ = 23; + pos__ = 2; + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + current_statement__ = 23; + assign(y, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 23; + pos__ = (pos__ + 1);} + } + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + current_statement__ = 23; + if (lcm_sym78__) { + current_statement__ = 23; + assign(y, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 23; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + current_statement__ = 23; + assign(y, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 23; + pos__ = (pos__ + 1);} + } } + } + } else { + lcm_sym78__ = logical_gte(I, 1); + } + } + current_statement__ = 24; + validate_non_negative_index("alpha", "K", K); + context__.validate_dims("data initialization","alpha","double", + context__.to_vec(K)); + alpha = Eigen::Matrix(K); + + { + std::vector alpha_flat__; + current_statement__ = 24; + assign(alpha_flat__, nil_index_list(), context__.vals_r("alpha"), + "assigning variable alpha_flat__"); + current_statement__ = 24; + pos__ = 1; + lcm_sym80__ = logical_gte(K, 1); + if (lcm_sym80__) { + current_statement__ = 24; + assign(alpha, cons_list(index_uni(1), nil_index_list()), + alpha_flat__[(1 - 1)], "assigning variable alpha"); + current_statement__ = 24; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= K; ++sym1__) { + current_statement__ = 24; + assign(alpha, cons_list(index_uni(sym1__), nil_index_list()), + alpha_flat__[(pos__ - 1)], "assigning variable alpha"); + current_statement__ = 24; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 25; + validate_non_negative_index("beta", "K", K); + current_statement__ = 25; + validate_non_negative_index("beta", "K", K); + context__.validate_dims("data initialization","beta","double", + context__.to_vec(K, K)); + beta = std::vector>(K, Eigen::Matrix(K)); + + { + std::vector beta_flat__; + current_statement__ = 25; + assign(beta_flat__, nil_index_list(), context__.vals_r("beta"), + "assigning variable beta_flat__"); + current_statement__ = 25; + pos__ = 1; + current_statement__ = 25; + if (lcm_sym80__) { + current_statement__ = 25; + if (lcm_sym80__) { + current_statement__ = 25; + assign(beta, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + beta_flat__[(1 - 1)], "assigning variable beta"); + current_statement__ = 25; + pos__ = 2; + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + current_statement__ = 25; + assign(beta, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + beta_flat__[(pos__ - 1)], "assigning variable beta"); + current_statement__ = 25; + pos__ = (pos__ + 1);} + } + for (size_t sym1__ = 2; sym1__ <= K; ++sym1__) { + current_statement__ = 25; + if (lcm_sym80__) { + current_statement__ = 25; + assign(beta, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + beta_flat__[(pos__ - 1)], "assigning variable beta"); + current_statement__ = 25; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + current_statement__ = 25; + assign(beta, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + beta_flat__[(pos__ - 1)], "assigning variable beta"); + current_statement__ = 25; + pos__ = (pos__ + 1);} + } } + } + } + current_statement__ = 20; + current_statement__ = 20; + check_greater_or_equal(function__, "K", K, 2); + current_statement__ = 21; + current_statement__ = 21; + check_greater_or_equal(function__, "I", I, 1); + current_statement__ = 22; + current_statement__ = 22; + check_greater_or_equal(function__, "J", J, 1); + current_statement__ = 23; + if (lcm_sym78__) { + current_statement__ = 23; + if (lcm_sym79__) { + current_statement__ = 23; + current_statement__ = 23; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= J; ++sym2__) { + current_statement__ = 23; + current_statement__ = 23; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(sym2__ - 1)], 1);} + } + for (size_t sym1__ = 2; sym1__ <= I; ++sym1__) { + current_statement__ = 23; + if (lcm_sym79__) { + current_statement__ = 23; + current_statement__ = 23; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= J; ++sym2__) { + current_statement__ = 23; + current_statement__ = 23; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(sym2__ - 1)], 1);} + } } + } + current_statement__ = 23; + if (lcm_sym78__) { + current_statement__ = 23; + if (lcm_sym79__) { + current_statement__ = 23; + current_statement__ = 23; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(1 - 1)], K); + for (size_t sym2__ = 2; sym2__ <= J; ++sym2__) { + current_statement__ = 23; + current_statement__ = 23; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(sym2__ - 1)], K);} + } + for (size_t sym1__ = 2; sym1__ <= I; ++sym1__) { + current_statement__ = 23; + if (lcm_sym79__) { + current_statement__ = 23; + current_statement__ = 23; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(1 - 1)], K); + for (size_t sym2__ = 2; sym2__ <= J; ++sym2__) { + current_statement__ = 23; + current_statement__ = 23; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(sym2__ - 1)], K);} + } } + } + current_statement__ = 24; + current_statement__ = 24; + check_greater_or_equal(function__, "alpha", alpha, 0); + current_statement__ = 25; + if (lcm_sym80__) { + current_statement__ = 25; + current_statement__ = 25; + check_greater_or_equal(function__, "beta[sym1__]", beta[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= K; ++sym1__) { + current_statement__ = 25; + current_statement__ = 25; + check_greater_or_equal(function__, "beta[sym1__]", + beta[(sym1__ - 1)], 0);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + current_statement__ = 1; + validate_positive_index("pi", "K", K); + num_params_r__ += (K - 1); + current_statement__ = 2; + validate_non_negative_index("theta", "J", J); + current_statement__ = 2; + validate_non_negative_index("theta", "K", K); + current_statement__ = 2; + validate_positive_index("theta", "K", K); + num_params_r__ += J * K * (K - 1); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "expr_prop_fail7_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + Eigen::Matrix lcm_sym76__; + Eigen::Matrix lcm_sym74__; + Eigen::Matrix lcm_sym72__; + Eigen::Matrix lcm_sym70__; + double lcm_sym68__; + Eigen::Matrix lcm_sym67__; + double lcm_sym66__; + double lcm_sym65__; + double lcm_sym64__; + double lcm_sym63__; + double lcm_sym62__; + Eigen::Matrix lcm_sym61__; + Eigen::Matrix lcm_sym60__; + Eigen::Matrix lcm_sym59__; + Eigen::Matrix lcm_sym58__; + int lcm_sym77__; + int lcm_sym57__; + int lcm_sym56__; + int lcm_sym55__; + current_statement__ = 1; + validate_positive_index("pi", "K", K); + Eigen::Matrix pi; + pi = Eigen::Matrix(K); + + Eigen::Matrix pi_in__; + pi_in__ = Eigen::Matrix((K - 1)); + + lcm_sym77__ = (K - 1); + pi_in__ = in__.vector(lcm_sym77__); + current_statement__ = 1; + if (jacobian__) { + current_statement__ = 1; + assign(pi, nil_index_list(), + stan::math::simplex_constrain(pi_in__, lp__), + "assigning variable pi"); + } else { + current_statement__ = 1; + assign(pi, nil_index_list(), stan::math::simplex_constrain(pi_in__), + "assigning variable pi"); + } + current_statement__ = 2; + validate_non_negative_index("theta", "J", J); + current_statement__ = 2; + validate_non_negative_index("theta", "K", K); + current_statement__ = 2; + validate_positive_index("theta", "K", K); + std::vector>> theta; + theta = std::vector>>(J, std::vector>(K, Eigen::Matrix(K))); + + std::vector>> theta_in__; + theta_in__ = std::vector>>(J, std::vector>(K, Eigen::Matrix(lcm_sym77__))); + + lcm_sym56__ = logical_gte(J, 1); + if (lcm_sym56__) { + lcm_sym57__ = logical_gte(K, 1); + if (lcm_sym57__) { + current_statement__ = 2; + assign(theta_in__, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + in__.vector(lcm_sym77__), "assigning variable theta_in__"); + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + current_statement__ = 2; + assign(theta_in__, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + in__.vector(lcm_sym77__), "assigning variable theta_in__");} + } + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + current_statement__ = 2; + if (lcm_sym57__) { + current_statement__ = 2; + assign(theta_in__, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), + in__.vector(lcm_sym77__), "assigning variable theta_in__"); + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + current_statement__ = 2; + assign(theta_in__, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + in__.vector(lcm_sym77__), "assigning variable theta_in__");} + } } + } + current_statement__ = 2; + if (lcm_sym56__) { + lcm_sym57__ = logical_gte(K, 1); + if (lcm_sym57__) { + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + stan::math::simplex_constrain(theta_in__[(1 - 1)][(1 - 1)], + lp__), "assigning variable theta"); + } else { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + stan::math::simplex_constrain(theta_in__[(1 - 1)][(1 - 1)]), + "assigning variable theta"); + } + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + stan::math::simplex_constrain( + theta_in__[(1 - 1)][(sym2__ - 1)], lp__), + "assigning variable theta"); + } else { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + stan::math::simplex_constrain( + theta_in__[(1 - 1)][(sym2__ - 1)]), + "assigning variable theta"); + }} + } + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + current_statement__ = 2; + if (lcm_sym57__) { + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), + stan::math::simplex_constrain( + theta_in__[(sym1__ - 1)][(1 - 1)], lp__), + "assigning variable theta"); + } else { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), + stan::math::simplex_constrain( + theta_in__[(sym1__ - 1)][(1 - 1)]), + "assigning variable theta"); + } + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + stan::math::simplex_constrain( + theta_in__[(sym1__ - 1)][(sym2__ - 1)], lp__), + "assigning variable theta"); + } else { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + stan::math::simplex_constrain( + theta_in__[(sym1__ - 1)][(sym2__ - 1)]), + "assigning variable theta"); + }} + } } + } + { + current_statement__ = 10; + lp_accum__.add(dirichlet_log(pi, alpha)); + current_statement__ = 13; + if (lcm_sym56__) { + lcm_sym57__ = logical_gte(K, 1); + if (lcm_sym57__) { + current_statement__ = 11; + lp_accum__.add( + dirichlet_log(theta[(1 - 1)][(1 - 1)], beta[(1 - 1)])); + for (size_t k = 2; k <= K; ++k) { + current_statement__ = 11; + lp_accum__.add( + dirichlet_log(theta[(1 - 1)][(k - 1)], + beta[(k - 1)]));} + } + for (size_t j = 2; j <= J; ++j) { + current_statement__ = 12; + if (lcm_sym57__) { + current_statement__ = 11; + lp_accum__.add( + dirichlet_log(theta[(j - 1)][(1 - 1)], + beta[(1 - 1)])); + for (size_t k = 2; k <= K; ++k) { + current_statement__ = 11; + lp_accum__.add( + dirichlet_log(theta[(j - 1)][(k - 1)], + beta[(k - 1)]));} + } } + } + current_statement__ = 19; + if (logical_gte(I, 1)) { + current_statement__ = 14; + validate_non_negative_index("log_q", "K", K); + Eigen::Matrix log_q; + log_q = Eigen::Matrix(K); + + assign(lcm_sym67__, nil_index_list(), stan::math::log(pi), + "assigning variable lcm_sym67__"); + assign(log_q, nil_index_list(), lcm_sym67__, + "assigning variable log_q"); + current_statement__ = 16; + if (lcm_sym56__) { + current_statement__ = 15; + assign(log_q, nil_index_list(), + add(lcm_sym67__, + to_vector( + stan::math::log( + rvalue(theta, + cons_list(index_uni(1), + cons_list(index_omni(), + cons_list(index_uni(y[(1 - 1)][(1 - 1)]), + nil_index_list()))), "theta")))), + "assigning variable log_q"); + for (size_t j = 2; j <= J; ++j) { + current_statement__ = 15; + assign(log_q, nil_index_list(), + add(stan::model::deep_copy(log_q), + to_vector( + stan::math::log( + rvalue(theta, + cons_list(index_uni(j), + cons_list(index_omni(), + cons_list(index_uni(y[(1 - 1)][(j - 1)]), + nil_index_list()))), "theta")))), + "assigning variable log_q");} + } + current_statement__ = 17; + lp_accum__.add(log_sum_exp(log_q)); + for (size_t i = 2; i <= I; ++i) { + current_statement__ = 14; + validate_non_negative_index("log_q", "K", K); + Eigen::Matrix log_q; + log_q = Eigen::Matrix(K); + + current_statement__ = 14; + assign(log_q, nil_index_list(), lcm_sym67__, + "assigning variable log_q"); + current_statement__ = 16; + if (lcm_sym56__) { + current_statement__ = 15; + assign(log_q, nil_index_list(), + add(lcm_sym67__, + to_vector( + stan::math::log( + rvalue(theta, + cons_list(index_uni(1), + cons_list(index_omni(), + cons_list(index_uni(y[(i - 1)][(1 - 1)]), + nil_index_list()))), "theta")))), + "assigning variable log_q"); + for (size_t j = 2; j <= J; ++j) { + current_statement__ = 15; + assign(log_q, nil_index_list(), + add(stan::model::deep_copy(log_q), + to_vector( + stan::math::log( + rvalue(theta, + cons_list(index_uni(j), + cons_list(index_omni(), + cons_list(index_uni(y[(i - 1)][(j - 1)]), + nil_index_list()))), "theta")))), + "assigning variable log_q");} + } + current_statement__ = 17; + lp_accum__.add(log_sum_exp(log_q));} + } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "expr_prop_fail7_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + Eigen::Matrix lcm_sym38__; + Eigen::Matrix lcm_sym37__; + Eigen::Matrix lcm_sym36__; + Eigen::Matrix lcm_sym35__; + double lcm_sym54__; + double lcm_sym53__; + double lcm_sym52__; + double lcm_sym51__; + double lcm_sym50__; + double lcm_sym49__; + double lcm_sym48__; + double lcm_sym47__; + double lcm_sym46__; + double lcm_sym45__; + double lcm_sym44__; + double lcm_sym43__; + double lcm_sym42__; + double lcm_sym41__; + double lcm_sym39__; + Eigen::Matrix lcm_sym34__; + Eigen::Matrix lcm_sym33__; + Eigen::Matrix lcm_sym32__; + Eigen::Matrix lcm_sym31__; + Eigen::Matrix lcm_sym30__; + int lcm_sym29__; + int lcm_sym28__; + Eigen::Matrix lcm_sym27__; + int lcm_sym40__; + int lcm_sym26__; + int lcm_sym25__; + int lcm_sym24__; + current_statement__ = 1; + validate_positive_index("pi", "K", K); + Eigen::Matrix pi; + pi = Eigen::Matrix(K); + + Eigen::Matrix pi_in__; + pi_in__ = Eigen::Matrix((K - 1)); + + lcm_sym40__ = (K - 1); + pi_in__ = in__.vector(lcm_sym40__); + current_statement__ = 1; + assign(pi, nil_index_list(), stan::math::simplex_constrain(pi_in__), + "assigning variable pi"); + current_statement__ = 2; + validate_non_negative_index("theta", "J", J); + current_statement__ = 2; + validate_non_negative_index("theta", "K", K); + current_statement__ = 2; + validate_positive_index("theta", "K", K); + std::vector>> theta; + theta = std::vector>>(J, std::vector>(K, Eigen::Matrix(K))); + + std::vector>> theta_in__; + theta_in__ = std::vector>>(J, std::vector>(K, Eigen::Matrix(lcm_sym40__))); + + lcm_sym25__ = logical_gte(J, 1); + if (lcm_sym25__) { + { + lcm_sym26__ = logical_gte(K, 1); + if (lcm_sym26__) { + current_statement__ = 2; + assign(theta_in__, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + in__.vector(lcm_sym40__), "assigning variable theta_in__"); + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + current_statement__ = 2; + assign(theta_in__, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + in__.vector(lcm_sym40__), "assigning variable theta_in__");} + } + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + current_statement__ = 2; + if (lcm_sym26__) { + current_statement__ = 2; + assign(theta_in__, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), + in__.vector(lcm_sym40__), "assigning variable theta_in__"); + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + current_statement__ = 2; + assign(theta_in__, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + in__.vector(lcm_sym40__), "assigning variable theta_in__"); + } + } } + } + } else { + lcm_sym26__ = logical_gte(K, 1); + } + current_statement__ = 2; + if (lcm_sym25__) { + current_statement__ = 2; + if (lcm_sym26__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + stan::math::simplex_constrain(theta_in__[(1 - 1)][(1 - 1)]), + "assigning variable theta"); + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + stan::math::simplex_constrain(theta_in__[(1 - 1)][(sym2__ - 1)]), + "assigning variable theta");} + } + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + current_statement__ = 2; + if (lcm_sym26__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), + stan::math::simplex_constrain(theta_in__[(sym1__ - 1)][(1 - 1)]), + "assigning variable theta"); + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + stan::math::simplex_constrain( + theta_in__[(sym1__ - 1)][(sym2__ - 1)]), + "assigning variable theta");} + } } + } + if (lcm_sym26__) { + vars__.push_back(pi[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= K; ++sym1__) { + vars__.push_back(pi[(sym1__ - 1)]);} + } + if (lcm_sym26__) { + if (lcm_sym26__) { + if (lcm_sym25__) { + vars__.push_back(theta[(1 - 1)][(1 - 1)][(1 - 1)]); + for (size_t sym3__ = 2; sym3__ <= J; ++sym3__) { + vars__.push_back(theta[(sym3__ - 1)][(1 - 1)][(1 - 1)]);} + } + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + if (lcm_sym25__) { + vars__.push_back(theta[(1 - 1)][(sym2__ - 1)][(1 - 1)]); + for (size_t sym3__ = 2; sym3__ <= J; ++sym3__) { + vars__.push_back(theta[(sym3__ - 1)][(sym2__ - 1)][(1 - 1)]); + } + } } + } + for (size_t sym1__ = 2; sym1__ <= K; ++sym1__) { + if (lcm_sym26__) { + if (lcm_sym25__) { + vars__.push_back(theta[(1 - 1)][(1 - 1)][(sym1__ - 1)]); + for (size_t sym3__ = 2; sym3__ <= J; ++sym3__) { + vars__.push_back(theta[(sym3__ - 1)][(1 - 1)][(sym1__ - 1)]); + } + } + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + if (lcm_sym25__) { + vars__.push_back(theta[(1 - 1)][(sym2__ - 1)][(sym1__ - 1)]); + for (size_t sym3__ = 2; sym3__ <= J; ++sym3__) { + vars__.push_back( + theta[(sym3__ - 1)][(sym2__ - 1)][(sym1__ - 1)]);} + } } + } } + } + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + current_statement__ = 3; + validate_non_negative_index("log_Pr_z", "I", I); + current_statement__ = 3; + validate_non_negative_index("log_Pr_z", "K", K); + std::vector> log_Pr_z; + log_Pr_z = std::vector>(I, Eigen::Matrix(K)); + + lcm_sym24__ = logical_gte(I, 1); + if (lcm_sym24__) { + current_statement__ = 3; + if (lcm_sym26__) { + lcm_sym39__ = std::numeric_limits::quiet_NaN(); + assign(log_Pr_z, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym39__, + "assigning variable log_Pr_z"); + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + current_statement__ = 3; + assign(log_Pr_z, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), lcm_sym39__, + "assigning variable log_Pr_z");} + } + for (size_t sym1__ = 2; sym1__ <= I; ++sym1__) { + current_statement__ = 3; + if (lcm_sym26__) { + lcm_sym39__ = std::numeric_limits::quiet_NaN(); + assign(log_Pr_z, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym39__, + "assigning variable log_Pr_z"); + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + current_statement__ = 3; + assign(log_Pr_z, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym39__, "assigning variable log_Pr_z");} + } } + } + current_statement__ = 9; + if (lcm_sym24__) { + current_statement__ = 4; + validate_non_negative_index("log_q", "K", K); + Eigen::Matrix log_q; + log_q = Eigen::Matrix(K); + + assign(lcm_sym34__, nil_index_list(), stan::math::log(pi), + "assigning variable lcm_sym34__"); + assign(log_q, nil_index_list(), lcm_sym34__, + "assigning variable log_q"); + current_statement__ = 6; + if (lcm_sym25__) { + current_statement__ = 5; + assign(log_q, nil_index_list(), + add(lcm_sym34__, + to_vector( + stan::math::log( + rvalue(theta, + cons_list(index_uni(1), + cons_list(index_omni(), + cons_list(index_uni(y[(1 - 1)][(1 - 1)]), + nil_index_list()))), "theta")))), + "assigning variable log_q"); + for (size_t j = 2; j <= J; ++j) { + current_statement__ = 5; + assign(log_q, nil_index_list(), + add(stan::model::deep_copy(log_q), + to_vector( + stan::math::log( + rvalue(theta, + cons_list(index_uni(j), + cons_list(index_omni(), + cons_list(index_uni(y[(1 - 1)][(j - 1)]), + nil_index_list()))), "theta")))), + "assigning variable log_q");} + } + current_statement__ = 7; + assign(log_Pr_z, cons_list(index_uni(1), nil_index_list()), + subtract(log_q, log_sum_exp(log_q)), "assigning variable log_Pr_z"); + for (size_t i = 2; i <= I; ++i) { + current_statement__ = 4; + validate_non_negative_index("log_q", "K", K); + Eigen::Matrix log_q; + log_q = Eigen::Matrix(K); + + current_statement__ = 4; + assign(log_q, nil_index_list(), lcm_sym34__, + "assigning variable log_q"); + current_statement__ = 6; + if (lcm_sym25__) { + current_statement__ = 5; + assign(log_q, nil_index_list(), + add(lcm_sym34__, + to_vector( + stan::math::log( + rvalue(theta, + cons_list(index_uni(1), + cons_list(index_omni(), + cons_list(index_uni(y[(i - 1)][(1 - 1)]), + nil_index_list()))), "theta")))), + "assigning variable log_q"); + for (size_t j = 2; j <= J; ++j) { + current_statement__ = 5; + assign(log_q, nil_index_list(), + add(stan::model::deep_copy(log_q), + to_vector( + stan::math::log( + rvalue(theta, + cons_list(index_uni(j), + cons_list(index_omni(), + cons_list(index_uni(y[(i - 1)][(j - 1)]), + nil_index_list()))), "theta")))), + "assigning variable log_q");} + } + current_statement__ = 7; + assign(log_Pr_z, cons_list(index_uni(i), nil_index_list()), + subtract(log_q, log_sum_exp(log_q)), + "assigning variable log_Pr_z");} + } + if (lcm_sym26__) { + if (lcm_sym24__) { + vars__.push_back(log_Pr_z[(1 - 1)][(1 - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(log_Pr_z[(sym2__ - 1)][(1 - 1)]);} + } + for (size_t sym1__ = 2; sym1__ <= K; ++sym1__) { + if (lcm_sym24__) { + vars__.push_back(log_Pr_z[(1 - 1)][(sym1__ - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(log_Pr_z[(sym2__ - 1)][(sym1__ - 1)]);} + } } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + double lcm_sym23__; + double lcm_sym22__; + double lcm_sym21__; + double lcm_sym20__; + Eigen::Matrix lcm_sym9__; + double lcm_sym19__; + double lcm_sym18__; + Eigen::Matrix lcm_sym8__; + double lcm_sym17__; + double lcm_sym16__; + double lcm_sym15__; + double lcm_sym14__; + Eigen::Matrix lcm_sym7__; + Eigen::Matrix lcm_sym6__; + double lcm_sym13__; + double lcm_sym12__; + double lcm_sym11__; + double lcm_sym10__; + int lcm_sym5__; + int lcm_sym4__; + int lcm_sym3__; + int lcm_sym2__; + int lcm_sym1__; + int pos__; + + pos__ = 1; + current_statement__ = 1; + validate_positive_index("pi", "K", K); + Eigen::Matrix pi; + pi = Eigen::Matrix(K); + + { + std::vector pi_flat__; + current_statement__ = 1; + assign(pi_flat__, nil_index_list(), context__.vals_r("pi"), + "assigning variable pi_flat__"); + current_statement__ = 1; + pos__ = 1; + lcm_sym2__ = logical_gte(K, 1); + if (lcm_sym2__) { + current_statement__ = 1; + assign(pi, cons_list(index_uni(1), nil_index_list()), + pi_flat__[(1 - 1)], "assigning variable pi"); + current_statement__ = 1; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= K; ++sym1__) { + current_statement__ = 1; + assign(pi, cons_list(index_uni(sym1__), nil_index_list()), + pi_flat__[(pos__ - 1)], "assigning variable pi"); + current_statement__ = 1; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 1; + assign(pi, nil_index_list(), stan::math::simplex_free(pi), + "assigning variable pi"); + current_statement__ = 2; + validate_non_negative_index("theta", "J", J); + current_statement__ = 2; + validate_non_negative_index("theta", "K", K); + current_statement__ = 2; + validate_positive_index("theta", "K", K); + std::vector>> theta; + theta = std::vector>>(J, std::vector>(K, Eigen::Matrix(K))); + + { + std::vector theta_flat__; + current_statement__ = 2; + assign(theta_flat__, nil_index_list(), context__.vals_r("theta"), + "assigning variable theta_flat__"); + current_statement__ = 2; + pos__ = 1; + current_statement__ = 2; + if (lcm_sym2__) { + { + current_statement__ = 2; + if (lcm_sym2__) { + { + lcm_sym1__ = logical_gte(J, 1); + if (lcm_sym1__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(1), + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list()))), + theta_flat__[(1 - 1)], "assigning variable theta"); + current_statement__ = 2; + pos__ = 2; + for (size_t sym3__ = 2; sym3__ <= J; ++sym3__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(sym3__), + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list()))), + theta_flat__[(pos__ - 1)], "assigning variable theta"); + current_statement__ = 2; + pos__ = (pos__ + 1);} + } + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + current_statement__ = 2; + if (lcm_sym1__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list()))), + theta_flat__[(pos__ - 1)], "assigning variable theta"); + current_statement__ = 2; + pos__ = (pos__ + 1); + for (size_t sym3__ = 2; sym3__ <= J; ++sym3__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(sym3__), + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list()))), + theta_flat__[(pos__ - 1)], "assigning variable theta"); + current_statement__ = 2; + pos__ = (pos__ + 1);} + } } + } + } else { + lcm_sym1__ = logical_gte(J, 1); + } + for (size_t sym1__ = 2; sym1__ <= K; ++sym1__) { + current_statement__ = 2; + if (lcm_sym2__) { + current_statement__ = 2; + if (lcm_sym1__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(1), + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list()))), + theta_flat__[(pos__ - 1)], "assigning variable theta"); + current_statement__ = 2; + pos__ = (pos__ + 1); + for (size_t sym3__ = 2; sym3__ <= J; ++sym3__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(sym3__), + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list()))), + theta_flat__[(pos__ - 1)], "assigning variable theta"); + current_statement__ = 2; + pos__ = (pos__ + 1);} + } + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + current_statement__ = 2; + if (lcm_sym1__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list()))), + theta_flat__[(pos__ - 1)], "assigning variable theta"); + current_statement__ = 2; + pos__ = (pos__ + 1); + for (size_t sym3__ = 2; sym3__ <= J; ++sym3__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(sym3__), + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list()))), + theta_flat__[(pos__ - 1)], "assigning variable theta"); + current_statement__ = 2; + pos__ = (pos__ + 1);} + } } + } } + } + } else { + lcm_sym1__ = logical_gte(J, 1); + } + } + current_statement__ = 2; + if (lcm_sym1__) { + current_statement__ = 2; + if (lcm_sym2__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + stan::math::simplex_free(theta[(1 - 1)][(1 - 1)]), + "assigning variable theta"); + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + stan::math::simplex_free(theta[(1 - 1)][(sym2__ - 1)]), + "assigning variable theta");} + } + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + current_statement__ = 2; + if (lcm_sym2__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), + stan::math::simplex_free(theta[(sym1__ - 1)][(1 - 1)]), + "assigning variable theta"); + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + current_statement__ = 2; + assign(theta, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + stan::math::simplex_free(theta[(sym1__ - 1)][(sym2__ - 1)]), + "assigning variable theta");} + } } + } + lcm_sym4__ = (K - 1); + lcm_sym3__ = logical_gte(lcm_sym4__, 1); + if (lcm_sym3__) { + vars__.push_back(pi[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= lcm_sym4__; ++sym1__) { + vars__.push_back(pi[(sym1__ - 1)]);} + } + if (lcm_sym3__) { + if (lcm_sym2__) { + if (lcm_sym1__) { + vars__.push_back(theta[(1 - 1)][(1 - 1)][(1 - 1)]); + for (size_t sym3__ = 2; sym3__ <= J; ++sym3__) { + vars__.push_back(theta[(sym3__ - 1)][(1 - 1)][(1 - 1)]);} + } + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + if (lcm_sym1__) { + vars__.push_back(theta[(1 - 1)][(sym2__ - 1)][(1 - 1)]); + for (size_t sym3__ = 2; sym3__ <= J; ++sym3__) { + vars__.push_back(theta[(sym3__ - 1)][(sym2__ - 1)][(1 - 1)]); + } + } } + } + for (size_t sym1__ = 2; sym1__ <= lcm_sym4__; ++sym1__) { + if (lcm_sym2__) { + if (lcm_sym1__) { + vars__.push_back(theta[(1 - 1)][(1 - 1)][(sym1__ - 1)]); + for (size_t sym3__ = 2; sym3__ <= J; ++sym3__) { + vars__.push_back(theta[(sym3__ - 1)][(1 - 1)][(sym1__ - 1)]); + } + } + for (size_t sym2__ = 2; sym2__ <= K; ++sym2__) { + if (lcm_sym1__) { + vars__.push_back(theta[(1 - 1)][(sym2__ - 1)][(sym1__ - 1)]); + for (size_t sym3__ = 2; sym3__ <= J; ++sym3__) { + vars__.push_back( + theta[(sym3__ - 1)][(sym2__ - 1)][(sym1__ - 1)]);} + } } + } } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("pi"); + names__.push_back("theta"); + names__.push_back("log_Pr_z"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dims__.push_back(K); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(J); + + dims__.push_back(K); + + dims__.push_back(K); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(I); + + dims__.push_back(K); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + for (size_t sym94__ = 1; sym94__ <= K; ++sym94__) { + { + param_names__.push_back(std::string() + "pi" + '.' + std::to_string(sym94__)); + }} + for (size_t sym94__ = 1; sym94__ <= K; ++sym94__) { + { + for (size_t sym95__ = 1; sym95__ <= K; ++sym95__) { + { + for (size_t sym96__ = 1; sym96__ <= J; ++sym96__) { + { + param_names__.push_back(std::string() + "theta" + '.' + std::to_string(sym96__) + '.' + std::to_string(sym95__) + '.' + std::to_string(sym94__)); + }} + }} + }} + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + for (size_t sym94__ = 1; sym94__ <= K; ++sym94__) { + { + for (size_t sym95__ = 1; sym95__ <= I; ++sym95__) { + { + param_names__.push_back(std::string() + "log_Pr_z" + '.' + std::to_string(sym95__) + '.' + std::to_string(sym94__)); + }} + }} + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + for (size_t sym94__ = 1; sym94__ <= (K - 1); ++sym94__) { + { + param_names__.push_back(std::string() + "pi" + '.' + std::to_string(sym94__)); + }} + for (size_t sym94__ = 1; sym94__ <= (K - 1); ++sym94__) { + { + for (size_t sym95__ = 1; sym95__ <= K; ++sym95__) { + { + for (size_t sym96__ = 1; sym96__ <= J; ++sym96__) { + { + param_names__.push_back(std::string() + "theta" + '.' + std::to_string(sym96__) + '.' + std::to_string(sym95__) + '.' + std::to_string(sym94__)); + }} + }} + }} + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + for (size_t sym94__ = 1; sym94__ <= K; ++sym94__) { + { + for (size_t sym95__ = 1; sym95__ <= I; ++sym95__) { + { + param_names__.push_back(std::string() + "log_Pr_z" + '.' + std::to_string(sym95__) + '.' + std::to_string(sym94__)); + }} + }} + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"pi\",\"type\":{\"name\":\"vector\",\"length\":" << K << "},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"array\",\"length\":" << J << ",\"element_type\":{\"name\":\"array\",\"length\":" << K << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}}},\"block\":\"parameters\"},{\"name\":\"log_Pr_z\",\"type\":{\"name\":\"array\",\"length\":" << I << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"pi\",\"type\":{\"name\":\"vector\",\"length\":" << (K - 1) << "},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"array\",\"length\":" << J << ",\"element_type\":{\"name\":\"array\",\"length\":" << K << ",\"element_type\":{\"name\":\"vector\",\"length\":" << (K - 1) << "}}},\"block\":\"parameters\"},{\"name\":\"log_Pr_z\",\"type\":{\"name\":\"array\",\"length\":" << I << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef expr_prop_fail7_model_namespace::expr_prop_fail7_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-fail8.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace expr_prop_fail8_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'expr-prop-fail8.stan', line 11, column 2 to column 13)", + " (in 'expr-prop-fail8.stan', line 12, column 2 to column 13)", + " (in 'expr-prop-fail8.stan', line 14, column 2 to column 26)", + " (in 'expr-prop-fail8.stan', line 15, column 2 to column 24)", + " (in 'expr-prop-fail8.stan', line 17, column 2 to column 22)", + " (in 'expr-prop-fail8.stan', line 18, column 2 to column 24)", + " (in 'expr-prop-fail8.stan', line 21, column 2 to column 47)", + " (in 'expr-prop-fail8.stan', line 22, column 2 to column 16)", + " (in 'expr-prop-fail8.stan', line 23, column 2 to column 25)", + " (in 'expr-prop-fail8.stan', line 24, column 2 to column 24)", + " (in 'expr-prop-fail8.stan', line 27, column 2 to column 33)", + " (in 'expr-prop-fail8.stan', line 2, column 2 to column 17)", + " (in 'expr-prop-fail8.stan', line 3, column 2 to column 23)", + " (in 'expr-prop-fail8.stan', line 4, column 2 to column 39)", + " (in 'expr-prop-fail8.stan', line 5, column 2 to column 39)", + " (in 'expr-prop-fail8.stan', line 7, column 2 to column 20)", + " (in 'expr-prop-fail8.stan', line 8, column 2 to column 14)"}; + + + +class expr_prop_fail8_model : public model_base_crtp { + + private: + int lcm_sym38__; + int lcm_sym37__; + double lcm_sym36__; + double lcm_sym35__; + int lcm_sym34__; + int lcm_sym33__; + int lcm_sym32__; + int lcm_sym31__; + int lcm_sym30__; + int lcm_sym29__; + int lcm_sym28__; + int pos__; + int N; + int N_edges; + std::vector node1; + std::vector node2; + std::vector y; + Eigen::Matrix x; + + public: + ~expr_prop_fail8_model() { } + + std::string model_name() const { return "expr_prop_fail8_model"; } + + expr_prop_fail8_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "expr_prop_fail8_model_namespace::expr_prop_fail8_model"; + (void) function__; // suppress unused var warning + + try { + + + + + + + + + + + + + pos__ = 1; + context__.validate_dims("data initialization","N","int", + context__.to_vec()); + + current_statement__ = 12; + N = context__.vals_i("N")[(1 - 1)]; + context__.validate_dims("data initialization","N_edges","int", + context__.to_vec()); + + current_statement__ = 13; + N_edges = context__.vals_i("N_edges")[(1 - 1)]; + current_statement__ = 14; + validate_non_negative_index("node1", "N_edges", N_edges); + context__.validate_dims("data initialization","node1","int", + context__.to_vec(N_edges)); + node1 = std::vector(N_edges, 0); + + current_statement__ = 14; + assign(node1, nil_index_list(), context__.vals_i("node1"), + "assigning variable node1"); + current_statement__ = 15; + validate_non_negative_index("node2", "N_edges", N_edges); + context__.validate_dims("data initialization","node2","int", + context__.to_vec(N_edges)); + node2 = std::vector(N_edges, 0); + + current_statement__ = 15; + assign(node2, nil_index_list(), context__.vals_i("node2"), + "assigning variable node2"); + current_statement__ = 16; + validate_non_negative_index("y", "N", N); + context__.validate_dims("data initialization","y","int", + context__.to_vec(N)); + y = std::vector(N, 0); + + current_statement__ = 16; + assign(y, nil_index_list(), context__.vals_i("y"), + "assigning variable y"); + current_statement__ = 17; + validate_non_negative_index("x", "N", N); + context__.validate_dims("data initialization","x","double", + context__.to_vec(N)); + x = Eigen::Matrix(N); + + { + std::vector x_flat__; + current_statement__ = 17; + assign(x_flat__, nil_index_list(), context__.vals_r("x"), + "assigning variable x_flat__"); + current_statement__ = 17; + pos__ = 1; + lcm_sym28__ = logical_gte(N, 1); + if (lcm_sym28__) { + current_statement__ = 17; + assign(x, cons_list(index_uni(1), nil_index_list()), + x_flat__[(1 - 1)], "assigning variable x"); + current_statement__ = 17; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 17; + assign(x, cons_list(index_uni(sym1__), nil_index_list()), + x_flat__[(pos__ - 1)], "assigning variable x"); + current_statement__ = 17; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 12; + current_statement__ = 12; + check_greater_or_equal(function__, "N", N, 0); + current_statement__ = 13; + current_statement__ = 13; + check_greater_or_equal(function__, "N_edges", N_edges, 0); + lcm_sym29__ = logical_gte(N_edges, 1); + if (lcm_sym29__) { + current_statement__ = 14; + current_statement__ = 14; + check_greater_or_equal(function__, "node1[sym1__]", node1[(1 - 1)], 1); + for (size_t sym1__ = 2; sym1__ <= N_edges; ++sym1__) { + current_statement__ = 14; + current_statement__ = 14; + check_greater_or_equal(function__, "node1[sym1__]", + node1[(sym1__ - 1)], 1);} + } + current_statement__ = 14; + if (lcm_sym29__) { + current_statement__ = 14; + current_statement__ = 14; + check_less_or_equal(function__, "node1[sym1__]", node1[(1 - 1)], N); + for (size_t sym1__ = 2; sym1__ <= N_edges; ++sym1__) { + current_statement__ = 14; + current_statement__ = 14; + check_less_or_equal(function__, "node1[sym1__]", + node1[(sym1__ - 1)], N);} + } + current_statement__ = 15; + if (lcm_sym29__) { + current_statement__ = 15; + current_statement__ = 15; + check_greater_or_equal(function__, "node2[sym1__]", node2[(1 - 1)], 1); + for (size_t sym1__ = 2; sym1__ <= N_edges; ++sym1__) { + current_statement__ = 15; + current_statement__ = 15; + check_greater_or_equal(function__, "node2[sym1__]", + node2[(sym1__ - 1)], 1);} + } + current_statement__ = 15; + if (lcm_sym29__) { + current_statement__ = 15; + current_statement__ = 15; + check_less_or_equal(function__, "node2[sym1__]", node2[(1 - 1)], N); + for (size_t sym1__ = 2; sym1__ <= N_edges; ++sym1__) { + current_statement__ = 15; + current_statement__ = 15; + check_less_or_equal(function__, "node2[sym1__]", + node2[(sym1__ - 1)], N);} + } + current_statement__ = 16; + if (lcm_sym28__) { + current_statement__ = 16; + current_statement__ = 16; + check_greater_or_equal(function__, "y[sym1__]", y[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 16; + current_statement__ = 16; + check_greater_or_equal(function__, "y[sym1__]", y[(sym1__ - 1)], 0); + } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + current_statement__ = 5; + validate_non_negative_index("theta_std", "N", N); + num_params_r__ += N; + current_statement__ = 6; + validate_non_negative_index("phi_std_raw", "N", N); + num_params_r__ += N; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "expr_prop_fail8_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + double lcm_sym27__; + local_scalar_t__ lcm_sym26__; + double lcm_sym25__; + Eigen::Matrix lcm_sym24__; + int lcm_sym23__; + local_scalar_t__ beta0; + + current_statement__ = 1; + beta0 = in__.scalar(); + local_scalar_t__ beta1; + + current_statement__ = 2; + beta1 = in__.scalar(); + local_scalar_t__ tau_theta; + + current_statement__ = 3; + tau_theta = in__.scalar(); + current_statement__ = 3; + if (jacobian__) { + current_statement__ = 3; + tau_theta = stan::math::lb_constrain(tau_theta, 0, lp__); + } else { + current_statement__ = 3; + tau_theta = stan::math::lb_constrain(tau_theta, 0); + } + local_scalar_t__ tau_phi; + + current_statement__ = 4; + tau_phi = in__.scalar(); + current_statement__ = 4; + if (jacobian__) { + current_statement__ = 4; + tau_phi = stan::math::lb_constrain(tau_phi, 0, lp__); + } else { + current_statement__ = 4; + tau_phi = stan::math::lb_constrain(tau_phi, 0); + } + current_statement__ = 5; + validate_non_negative_index("theta_std", "N", N); + Eigen::Matrix theta_std; + theta_std = Eigen::Matrix(N); + + current_statement__ = 5; + theta_std = in__.vector(N); + current_statement__ = 6; + validate_non_negative_index("phi_std_raw", "N", N); + Eigen::Matrix phi_std_raw; + phi_std_raw = Eigen::Matrix(N); + + current_statement__ = 6; + phi_std_raw = in__.vector(N); + local_scalar_t__ sigma_phi; + + lcm_sym27__ = std::numeric_limits::quiet_NaN(); + sigma_phi = lcm_sym27__; + lcm_sym26__ = inv_sqrt(tau_phi); + sigma_phi = lcm_sym26__; + current_statement__ = 8; + validate_non_negative_index("phi", "N", N); + Eigen::Matrix phi; + phi = Eigen::Matrix(N); + + current_statement__ = 8; + if (logical_gte(N, 1)) { + current_statement__ = 8; + assign(phi, cons_list(index_uni(1), nil_index_list()), lcm_sym27__, + "assigning variable phi"); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 8; + assign(phi, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym27__, "assigning variable phi");} + } + current_statement__ = 9; + assign(phi, cons_list(index_min_max(1, N), nil_index_list()), + phi_std_raw, "assigning variable phi"); + current_statement__ = 10; + assign(phi, nil_index_list(), + multiply(stan::model::deep_copy(phi), lcm_sym26__), + "assigning variable phi"); + current_statement__ = 7; + current_statement__ = 7; + check_greater_or_equal(function__, "sigma_phi", lcm_sym26__, 0); + { + current_statement__ = 11; + lp_accum__.add( + dot_self( + rvalue(phi, cons_list(index_multi(node1), nil_index_list()), + "phi"))); + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "expr_prop_fail8_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + double lcm_sym22__; + double lcm_sym21__; + double lcm_sym20__; + double lcm_sym19__; + double lcm_sym18__; + double lcm_sym17__; + double lcm_sym16__; + double lcm_sym15__; + Eigen::Matrix lcm_sym14__; + int lcm_sym13__; + int lcm_sym12__; + int lcm_sym11__; + double beta0; + + current_statement__ = 1; + beta0 = in__.scalar(); + double beta1; + + current_statement__ = 2; + beta1 = in__.scalar(); + double tau_theta; + + current_statement__ = 3; + tau_theta = in__.scalar(); + current_statement__ = 3; + tau_theta = stan::math::lb_constrain(tau_theta, 0); + double tau_phi; + + current_statement__ = 4; + tau_phi = in__.scalar(); + current_statement__ = 4; + tau_phi = stan::math::lb_constrain(tau_phi, 0); + current_statement__ = 5; + validate_non_negative_index("theta_std", "N", N); + Eigen::Matrix theta_std; + theta_std = Eigen::Matrix(N); + + current_statement__ = 5; + theta_std = in__.vector(N); + current_statement__ = 6; + validate_non_negative_index("phi_std_raw", "N", N); + Eigen::Matrix phi_std_raw; + phi_std_raw = Eigen::Matrix(N); + + current_statement__ = 6; + phi_std_raw = in__.vector(N); + double sigma_phi; + + lcm_sym16__ = std::numeric_limits::quiet_NaN(); + sigma_phi = lcm_sym16__; + current_statement__ = 8; + validate_non_negative_index("phi", "N", N); + Eigen::Matrix phi; + phi = Eigen::Matrix(N); + + lcm_sym11__ = logical_gte(N, 1); + if (lcm_sym11__) { + current_statement__ = 8; + assign(phi, cons_list(index_uni(1), nil_index_list()), lcm_sym16__, + "assigning variable phi"); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 8; + assign(phi, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym16__, "assigning variable phi");} + } + vars__.push_back(beta0); + vars__.push_back(beta1); + vars__.push_back(tau_theta); + vars__.push_back(tau_phi); + if (lcm_sym11__) { + vars__.push_back(theta_std[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + vars__.push_back(theta_std[(sym1__ - 1)]);} + } + if (lcm_sym11__) { + vars__.push_back(phi_std_raw[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + vars__.push_back(phi_std_raw[(sym1__ - 1)]);} + } + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + lcm_sym15__ = inv_sqrt(tau_phi); + sigma_phi = lcm_sym15__; + current_statement__ = 9; + assign(phi, cons_list(index_min_max(1, N), nil_index_list()), + phi_std_raw, "assigning variable phi"); + current_statement__ = 10; + assign(phi, nil_index_list(), + multiply(stan::model::deep_copy(phi), lcm_sym15__), + "assigning variable phi"); + vars__.push_back(lcm_sym15__); + if (lcm_sym11__) { + vars__.push_back(phi[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + vars__.push_back(phi[(sym1__ - 1)]);} + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + double lcm_sym10__; + double lcm_sym9__; + double lcm_sym8__; + double lcm_sym7__; + double lcm_sym6__; + double lcm_sym5__; + double lcm_sym4__; + double lcm_sym3__; + int lcm_sym2__; + int lcm_sym1__; + int pos__; + + pos__ = 1; + double beta0; + + current_statement__ = 1; + beta0 = context__.vals_r("beta0")[(1 - 1)]; + double beta1; + + current_statement__ = 2; + beta1 = context__.vals_r("beta1")[(1 - 1)]; + double tau_theta; + + current_statement__ = 3; + tau_theta = context__.vals_r("tau_theta")[(1 - 1)]; + current_statement__ = 3; + tau_theta = stan::math::lb_free(tau_theta, 0); + double tau_phi; + + current_statement__ = 4; + tau_phi = context__.vals_r("tau_phi")[(1 - 1)]; + current_statement__ = 4; + tau_phi = stan::math::lb_free(tau_phi, 0); + current_statement__ = 5; + validate_non_negative_index("theta_std", "N", N); + Eigen::Matrix theta_std; + theta_std = Eigen::Matrix(N); + + { + std::vector theta_std_flat__; + current_statement__ = 5; + assign(theta_std_flat__, nil_index_list(), + context__.vals_r("theta_std"), + "assigning variable theta_std_flat__"); + current_statement__ = 5; + pos__ = 1; + lcm_sym1__ = logical_gte(N, 1); + if (lcm_sym1__) { + current_statement__ = 5; + assign(theta_std, cons_list(index_uni(1), nil_index_list()), + theta_std_flat__[(1 - 1)], "assigning variable theta_std"); + current_statement__ = 5; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 5; + assign(theta_std, cons_list(index_uni(sym1__), nil_index_list()), + theta_std_flat__[(pos__ - 1)], "assigning variable theta_std"); + current_statement__ = 5; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 6; + validate_non_negative_index("phi_std_raw", "N", N); + Eigen::Matrix phi_std_raw; + phi_std_raw = Eigen::Matrix(N); + + { + std::vector phi_std_raw_flat__; + current_statement__ = 6; + assign(phi_std_raw_flat__, nil_index_list(), + context__.vals_r("phi_std_raw"), + "assigning variable phi_std_raw_flat__"); + current_statement__ = 6; + pos__ = 1; + current_statement__ = 6; + if (lcm_sym1__) { + current_statement__ = 6; + assign(phi_std_raw, cons_list(index_uni(1), nil_index_list()), + phi_std_raw_flat__[(1 - 1)], "assigning variable phi_std_raw"); + current_statement__ = 6; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 6; + assign(phi_std_raw, + cons_list(index_uni(sym1__), nil_index_list()), + phi_std_raw_flat__[(pos__ - 1)], + "assigning variable phi_std_raw"); + current_statement__ = 6; + pos__ = (pos__ + 1);} + } + } + vars__.push_back(beta0); + vars__.push_back(beta1); + vars__.push_back(tau_theta); + vars__.push_back(tau_phi); + if (lcm_sym1__) { + vars__.push_back(theta_std[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + vars__.push_back(theta_std[(sym1__ - 1)]);} + } + if (lcm_sym1__) { + vars__.push_back(phi_std_raw[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + vars__.push_back(phi_std_raw[(sym1__ - 1)]);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("beta0"); + names__.push_back("beta1"); + names__.push_back("tau_theta"); + names__.push_back("tau_phi"); + names__.push_back("theta_std"); + names__.push_back("phi_std_raw"); + names__.push_back("sigma_phi"); + names__.push_back("phi"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(N); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(N); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(N); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "beta0"); + param_names__.push_back(std::string() + "beta1"); + param_names__.push_back(std::string() + "tau_theta"); + param_names__.push_back(std::string() + "tau_phi"); + for (size_t sym39__ = 1; sym39__ <= N; ++sym39__) { + { + param_names__.push_back(std::string() + "theta_std" + '.' + std::to_string(sym39__)); + }} + for (size_t sym39__ = 1; sym39__ <= N; ++sym39__) { + { + param_names__.push_back(std::string() + "phi_std_raw" + '.' + std::to_string(sym39__)); + }} + if (emit_transformed_parameters__) { + param_names__.push_back(std::string() + "sigma_phi"); + for (size_t sym39__ = 1; sym39__ <= N; ++sym39__) { + { + param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym39__)); + }} + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "beta0"); + param_names__.push_back(std::string() + "beta1"); + param_names__.push_back(std::string() + "tau_theta"); + param_names__.push_back(std::string() + "tau_phi"); + for (size_t sym39__ = 1; sym39__ <= N; ++sym39__) { + { + param_names__.push_back(std::string() + "theta_std" + '.' + std::to_string(sym39__)); + }} + for (size_t sym39__ = 1; sym39__ <= N; ++sym39__) { + { + param_names__.push_back(std::string() + "phi_std_raw" + '.' + std::to_string(sym39__)); + }} + if (emit_transformed_parameters__) { + param_names__.push_back(std::string() + "sigma_phi"); + for (size_t sym39__ = 1; sym39__ <= N; ++sym39__) { + { + param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym39__)); + }} + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"beta0\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta1\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"tau_theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"tau_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"theta_std\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"parameters\"},{\"name\":\"phi_std_raw\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"parameters\"},{\"name\":\"sigma_phi\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"beta0\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta1\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"tau_theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"tau_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"theta_std\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"parameters\"},{\"name\":\"phi_std_raw\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"parameters\"},{\"name\":\"sigma_phi\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef expr_prop_fail8_model_namespace::expr_prop_fail8_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp fails-test.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace fails_test_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'fails-test.stan', line 71, column 2 to column 31)", + " (in 'fails-test.stan', line 72, column 2 to column 40)", + " (in 'fails-test.stan', line 76, column 2 to column 51)", + " (in 'fails-test.stan', line 77, column 2 to column 49)", + " (in 'fails-test.stan', line 78, column 2 to column 49)", + " (in 'fails-test.stan', line 83, column 6 to column 20)", + " (in 'fails-test.stan', line 84, column 6 to column 18)", + " (in 'fails-test.stan', line 82, column 32 to line 85, column 5)", + " (in 'fails-test.stan', line 87, column 6 to column 32)", + " (in 'fails-test.stan', line 88, column 6 to column 23)", + " (in 'fails-test.stan', line 86, column 38 to line 89, column 5)", + " (in 'fails-test.stan', line 86, column 4 to line 89, column 5)", + " (in 'fails-test.stan', line 81, column 20 to line 90, column 3)", + " (in 'fails-test.stan', line 81, column 2 to line 90, column 3)", + " (in 'fails-test.stan', line 26, column 4 to column 34)", + " (in 'fails-test.stan', line 29, column 6 to column 32)", + " (in 'fails-test.stan', line 32, column 8 to column 37)", + " (in 'fails-test.stan', line 33, column 8 to column 32)", + " (in 'fails-test.stan', line 41, column 8 to line 42, column 83)", + " (in 'fails-test.stan', line 30, column 37 to line 43, column 7)", + " (in 'fails-test.stan', line 28, column 22 to line 44, column 5)", + " (in 'fails-test.stan', line 25, column 47 to line 46, column 3)", + " (in 'fails-test.stan', line 105, column 8 to column 37)", + " (in 'fails-test.stan', line 106, column 8 to column 41)", + " (in 'fails-test.stan', line 104, column 40 to line 107, column 7)", + " (in 'fails-test.stan', line 108, column 6 to column 37)", + " (in 'fails-test.stan', line 103, column 22 to line 109, column 5)", + " (in 'fails-test.stan', line 102, column 20 to line 110, column 3)", + " (in 'fails-test.stan', line 102, column 2 to line 110, column 3)", + " (in 'fails-test.stan', line 50, column 2 to column 20)", + " (in 'fails-test.stan', line 51, column 2 to column 27)", + " (in 'fails-test.stan', line 52, column 2 to column 44)", + " (in 'fails-test.stan', line 53, column 2 to column 23)", + " (in 'fails-test.stan', line 54, column 2 to column 54)", + " (in 'fails-test.stan', line 58, column 2 to column 38)", + " (in 'fails-test.stan', line 60, column 2 to column 45)", + " (in 'fails-test.stan', line 61, column 2 to column 44)", + " (in 'fails-test.stan', line 8, column 8 to column 17)", + " (in 'fails-test.stan', line 7, column 6 to line 8, column 17)", + " (in 'fails-test.stan', line 5, column 31 to line 10, column 3)", + " (in 'fails-test.stan', line 65, column 4 to column 35)", + " (in 'fails-test.stan', line 64, column 2 to line 65, column 35)", + " (in 'fails-test.stan', line 15, column 6 to column 32)", + " (in 'fails-test.stan', line 19, column 8 to column 17)", + " (in 'fails-test.stan', line 18, column 6 to line 19, column 17)", + " (in 'fails-test.stan', line 13, column 37 to line 20, column 5)", + " (in 'fails-test.stan', line 12, column 30 to line 22, column 3)", + " (in 'fails-test.stan', line 67, column 4 to column 33)", + " (in 'fails-test.stan', line 66, column 2 to line 67, column 33)", + " (in 'fails-test.stan', line 9, column 4 to column 13)", + " (in 'fails-test.stan', line 21, column 4 to column 13)", + " (in 'fails-test.stan', line 30, column 6 to line 43, column 7)", + " (in 'fails-test.stan', line 28, column 4 to line 44, column 5)", + " (in 'fails-test.stan', line 45, column 4 to column 15)"}; + + +int +first_capture(const std::vector& y_i, std::ostream* pstream__) { + using local_scalar_t__ = double; + const static bool propto__ = true; + (void) propto__; + + try { + int lcm_sym33__; + int lcm_sym32__; + int lcm_sym31__; + int lcm_sym30__; + { + lcm_sym31__ = size(y_i); + if (logical_gte(lcm_sym31__, 1)) { + current_statement__ = 39; + if (y_i[(1 - 1)]) { + current_statement__ = 38; + return 1; + } + for (size_t k = 2; k <= lcm_sym31__; ++k) { + current_statement__ = 39; + if (y_i[(k - 1)]) { + current_statement__ = 38; + return k; + } } + } + current_statement__ = 50; + return 0; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct first_capture_functor__ { +int +operator()(const std::vector& y_i, std::ostream* pstream__) const +{ +return first_capture(y_i, pstream__); +} +}; + +int +last_capture(const std::vector& y_i, std::ostream* pstream__) { + using local_scalar_t__ = double; + const static bool propto__ = true; + (void) propto__; + + try { + int lcm_sym39__; + int lcm_sym38__; + int lcm_sym37__; + int lcm_sym36__; + int lcm_sym35__; + int lcm_sym34__; + { + lcm_sym37__ = (size(y_i) - 1); + if (logical_gte(lcm_sym37__, 0)) { + int k; + + lcm_sym36__ = (size(y_i) - 0); + current_statement__ = 45; + if (y_i[(lcm_sym36__ - 1)]) { + current_statement__ = 44; + return lcm_sym36__; + } + for (size_t k_rev = 1; k_rev <= lcm_sym37__; ++k_rev) { + int k; + + lcm_sym35__ = (size(y_i) - k_rev); + current_statement__ = 45; + if (y_i[(lcm_sym35__ - 1)]) { + current_statement__ = 44; + return lcm_sym35__; + } } + } + current_statement__ = 51; + return 0; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct last_capture_functor__ { +int +operator()(const std::vector& y_i, std::ostream* pstream__) const +{ +return last_capture(y_i, pstream__); +} +}; + +template +Eigen::Matrix::type, -1, -1> +prob_uncaptured(const int& nind, const int& n_occasions, + const Eigen::Matrix& p, + const Eigen::Matrix& phi, + std::ostream* pstream__) { + using local_scalar_t__ = typename boost::math::tools::promote_args::type; + const static bool propto__ = true; + (void) propto__; + + try { + double lcm_sym51__; + double lcm_sym50__; + double lcm_sym49__; + double lcm_sym48__; + double lcm_sym47__; + int lcm_sym46__; + int lcm_sym45__; + int lcm_sym44__; + int lcm_sym43__; + int lcm_sym42__; + int lcm_sym41__; + int lcm_sym40__; + { + current_statement__ = 15; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 15; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix chi; + chi = Eigen::Matrix(nind, n_occasions); + + lcm_sym41__ = logical_gte(nind, 1); + if (lcm_sym41__) { + lcm_sym40__ = logical_gte(n_occasions, 1); + if (lcm_sym40__) { + lcm_sym51__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym51__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 15; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), lcm_sym51__, + "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 15; + if (lcm_sym40__) { + lcm_sym51__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym51__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 15; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym51__, "assigning variable chi");} + } } + } + current_statement__ = 53; + if (lcm_sym41__) { + current_statement__ = 16; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(n_occasions), nil_index_list())), 1.0, + "assigning variable chi"); + lcm_sym44__ = (n_occasions - 1); + lcm_sym42__ = logical_gte(lcm_sym44__, 1); + if (lcm_sym42__) { + int t_curr; + + int t_next; + + lcm_sym46__ = (lcm_sym44__ + 1); + current_statement__ = 19; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym46__ - 1)), + nil_index_list())), "p"))), + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym46__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + "phi"))), "assigning variable chi"); + for (size_t t = 2; t <= lcm_sym44__; ++t) { + int t_curr; + + lcm_sym43__ = (n_occasions - t); + int t_next; + + lcm_sym45__ = (lcm_sym43__ + 1); + current_statement__ = 19; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym45__ - 1)), + nil_index_list())), "p"))), + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym45__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + "phi"))), "assigning variable chi");} + } + for (size_t i = 2; i <= nind; ++i) { + current_statement__ = 16; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(n_occasions), nil_index_list())), 1.0, + "assigning variable chi"); + current_statement__ = 52; + if (lcm_sym42__) { + int t_curr; + + int t_next; + + lcm_sym46__ = (lcm_sym44__ + 1); + current_statement__ = 19; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym46__ - 1)), + nil_index_list())), "p"))), + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym46__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + "phi"))), "assigning variable chi"); + for (size_t t = 2; t <= lcm_sym44__; ++t) { + int t_curr; + + lcm_sym43__ = (n_occasions - t); + int t_next; + + lcm_sym45__ = (lcm_sym43__ + 1); + current_statement__ = 19; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym45__ - 1)), + nil_index_list())), "p"))), + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym45__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + "phi"))), "assigning variable chi");} + } } + } + current_statement__ = 54; + return chi; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct prob_uncaptured_functor__ { +template +Eigen::Matrix::type, -1, -1> +operator()(const int& nind, const int& n_occasions, + const Eigen::Matrix& p, + const Eigen::Matrix& phi, std::ostream* pstream__) const +{ +return prob_uncaptured(nind, n_occasions, p, phi, pstream__); +} +}; + +class fails_test_model : public model_base_crtp { + + private: + int lcm_sym180__; + int lcm_sym179__; + int lcm_sym178__; + int lcm_sym177__; + int lcm_sym176__; + int lcm_sym175__; + int lcm_sym174__; + int lcm_sym173__; + int lcm_sym172__; + int lcm_sym171__; + int lcm_sym170__; + int lcm_sym169__; + int lcm_sym168__; + int lcm_sym167__; + int lcm_sym166__; + int lcm_sym165__; + int lcm_sym164__; + int lcm_sym163__; + int lcm_sym162__; + int lcm_sym161__; + int lcm_sym160__; + int lcm_sym159__; + int lcm_sym158__; + int lcm_sym157__; + int lcm_sym156__; + int lcm_sym155__; + int lcm_sym154__; + int lcm_sym153__; + int lcm_sym152__; + int lcm_sym151__; + int lcm_sym150__; + int pos__; + int nind; + int n_occasions; + std::vector> y; + int max_age; + std::vector> x; + int n_occ_minus_1; + std::vector first; + std::vector last; + + public: + ~fails_test_model() { } + + std::string model_name() const { return "fails_test_model"; } + + fails_test_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "fails_test_model_namespace::fails_test_model"; + (void) function__; // suppress unused var warning + + try { + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + pos__ = 1; + context__.validate_dims("data initialization","nind","int", + context__.to_vec()); + + current_statement__ = 30; + nind = context__.vals_i("nind")[(1 - 1)]; + context__.validate_dims("data initialization","n_occasions","int", + context__.to_vec()); + + current_statement__ = 31; + n_occasions = context__.vals_i("n_occasions")[(1 - 1)]; + current_statement__ = 32; + validate_non_negative_index("y", "nind", nind); + current_statement__ = 32; + validate_non_negative_index("y", "n_occasions", n_occasions); + context__.validate_dims("data initialization","y","int", + context__.to_vec(nind, n_occasions)); + y = std::vector>(nind, std::vector(n_occasions, 0)); + + { + std::vector y_flat__; + current_statement__ = 32; + assign(y_flat__, nil_index_list(), context__.vals_i("y"), + "assigning variable y_flat__"); + current_statement__ = 32; + pos__ = 1; + lcm_sym150__ = logical_gte(n_occasions, 1); + if (lcm_sym150__) { + { + lcm_sym151__ = logical_gte(nind, 1); + if (lcm_sym151__) { + current_statement__ = 32; + assign(y, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + y_flat__[(1 - 1)], "assigning variable y"); + current_statement__ = 32; + pos__ = 2; + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + current_statement__ = 32; + assign(y, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 32; + pos__ = (pos__ + 1);} + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 32; + if (lcm_sym151__) { + current_statement__ = 32; + assign(y, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 32; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + current_statement__ = 32; + assign(y, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 32; + pos__ = (pos__ + 1);} + } } + } + } else { + lcm_sym151__ = logical_gte(nind, 1); + } + } + context__.validate_dims("data initialization","max_age","int", + context__.to_vec()); + + current_statement__ = 33; + max_age = context__.vals_i("max_age")[(1 - 1)]; + current_statement__ = 34; + validate_non_negative_index("x", "nind", nind); + lcm_sym153__ = (n_occasions - 1); + validate_non_negative_index("x", "(n_occasions - 1)", lcm_sym153__); + context__.validate_dims("data initialization","x","int", + context__.to_vec(nind, lcm_sym153__)); + x = std::vector>(nind, std::vector(lcm_sym153__, 0)); + + { + std::vector x_flat__; + current_statement__ = 34; + assign(x_flat__, nil_index_list(), context__.vals_i("x"), + "assigning variable x_flat__"); + current_statement__ = 34; + pos__ = 1; + lcm_sym152__ = logical_gte(lcm_sym153__, 1); + if (lcm_sym152__) { + current_statement__ = 34; + if (lcm_sym151__) { + current_statement__ = 34; + assign(x, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + x_flat__[(1 - 1)], "assigning variable x"); + current_statement__ = 34; + pos__ = 2; + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + current_statement__ = 34; + assign(x, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + x_flat__[(pos__ - 1)], "assigning variable x"); + current_statement__ = 34; + pos__ = (pos__ + 1);} + } + for (size_t sym1__ = 2; sym1__ <= lcm_sym153__; ++sym1__) { + current_statement__ = 34; + if (lcm_sym151__) { + current_statement__ = 34; + assign(x, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + x_flat__[(pos__ - 1)], "assigning variable x"); + current_statement__ = 34; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + current_statement__ = 34; + assign(x, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + x_flat__[(pos__ - 1)], "assigning variable x"); + current_statement__ = 34; + pos__ = (pos__ + 1);} + } } + } + } + + current_statement__ = 35; + n_occ_minus_1 = lcm_sym153__; + current_statement__ = 36; + validate_non_negative_index("first", "nind", nind); + first = std::vector(nind, 0); + + current_statement__ = 37; + validate_non_negative_index("last", "nind", nind); + last = std::vector(nind, 0); + + current_statement__ = 42; + if (lcm_sym151__) { + int inline_sym21__; + int inline_sym23__; + + inline_sym23__ = 0; + for (size_t inline_sym24__ = 1; inline_sym24__ <= 1; ++inline_sym24__) { + lcm_sym160__ = size(y[(1 - 1)]); + for (size_t inline_sym22__ = 1; inline_sym22__ <= lcm_sym160__; + ++inline_sym22__) { + current_statement__ = 39; + if (y[(1 - 1)][(inline_sym22__ - 1)]) { + inline_sym23__ = 1; + inline_sym21__ = inline_sym22__; + break; + } } + if (inline_sym23__) { + break; + } + inline_sym23__ = 1; + inline_sym21__ = 0; + break;} + assign(first, cons_list(index_uni(1), nil_index_list()), + inline_sym21__, "assigning variable first"); + for (size_t i = 2; i <= nind; ++i) { + int inline_sym21__; + int inline_sym23__; + + inline_sym23__ = 0; + for (size_t inline_sym24__ = 1; inline_sym24__ <= 1; + ++inline_sym24__) { + lcm_sym159__ = size(y[(i - 1)]); + for (size_t inline_sym22__ = 1; inline_sym22__ <= lcm_sym159__; + ++inline_sym22__) { + current_statement__ = 39; + if (y[(i - 1)][(inline_sym22__ - 1)]) { + inline_sym23__ = 1; + inline_sym21__ = inline_sym22__; + break; + } } + if (inline_sym23__) { + break; + } + inline_sym23__ = 1; + inline_sym21__ = 0; + break;} + assign(first, cons_list(index_uni(i), nil_index_list()), + inline_sym21__, "assigning variable first");} + } + current_statement__ = 49; + if (lcm_sym151__) { + int inline_sym25__; + int inline_sym28__; + + inline_sym28__ = 0; + for (size_t inline_sym29__ = 1; inline_sym29__ <= 1; ++inline_sym29__) { + lcm_sym160__ = size(y[(1 - 1)]); + lcm_sym157__ = (lcm_sym160__ - 1); + for (size_t inline_sym27__ = 0; inline_sym27__ <= lcm_sym157__; + ++inline_sym27__) { + int inline_sym26__; + + lcm_sym156__ = (lcm_sym160__ - inline_sym27__); + inline_sym26__ = lcm_sym156__; + current_statement__ = 45; + if (y[(1 - 1)][(lcm_sym156__ - 1)]) { + inline_sym28__ = 1; + inline_sym25__ = lcm_sym156__; + break; + } } + if (inline_sym28__) { + break; + } + inline_sym28__ = 1; + inline_sym25__ = 0; + break;} + assign(last, cons_list(index_uni(1), nil_index_list()), + inline_sym25__, "assigning variable last"); + for (size_t i = 2; i <= nind; ++i) { + int inline_sym25__; + int inline_sym28__; + + inline_sym28__ = 0; + for (size_t inline_sym29__ = 1; inline_sym29__ <= 1; + ++inline_sym29__) { + lcm_sym159__ = size(y[(i - 1)]); + lcm_sym155__ = (lcm_sym159__ - 1); + for (size_t inline_sym27__ = 0; inline_sym27__ <= lcm_sym155__; + ++inline_sym27__) { + int inline_sym26__; + + lcm_sym154__ = (lcm_sym159__ - inline_sym27__); + inline_sym26__ = lcm_sym154__; + current_statement__ = 45; + if (y[(i - 1)][(lcm_sym154__ - 1)]) { + inline_sym28__ = 1; + inline_sym25__ = lcm_sym154__; + break; + } } + if (inline_sym28__) { + break; + } + inline_sym28__ = 1; + inline_sym25__ = 0; + break;} + assign(last, cons_list(index_uni(i), nil_index_list()), + inline_sym25__, "assigning variable last");} + } + current_statement__ = 30; + current_statement__ = 30; + check_greater_or_equal(function__, "nind", nind, 0); + current_statement__ = 31; + current_statement__ = 31; + check_greater_or_equal(function__, "n_occasions", n_occasions, 2); + current_statement__ = 32; + if (lcm_sym151__) { + current_statement__ = 32; + if (lcm_sym150__) { + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(sym2__ - 1)], 0);} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 32; + if (lcm_sym150__) { + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(sym2__ - 1)], 0);} + } } + } + current_statement__ = 32; + if (lcm_sym151__) { + current_statement__ = 32; + if (lcm_sym150__) { + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(sym2__ - 1)], 1);} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 32; + if (lcm_sym150__) { + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(sym2__ - 1)], 1);} + } } + } + current_statement__ = 33; + current_statement__ = 33; + check_greater_or_equal(function__, "max_age", max_age, 1); + current_statement__ = 34; + if (lcm_sym151__) { + current_statement__ = 34; + if (lcm_sym152__) { + current_statement__ = 34; + current_statement__ = 34; + check_greater_or_equal(function__, "x[sym1__, sym2__]", + x[(1 - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= lcm_sym153__; ++sym2__) { + current_statement__ = 34; + current_statement__ = 34; + check_greater_or_equal(function__, "x[sym1__, sym2__]", + x[(1 - 1)][(sym2__ - 1)], 0);} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 34; + if (lcm_sym152__) { + current_statement__ = 34; + current_statement__ = 34; + check_greater_or_equal(function__, "x[sym1__, sym2__]", + x[(sym1__ - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= lcm_sym153__; ++sym2__) { + current_statement__ = 34; + current_statement__ = 34; + check_greater_or_equal(function__, "x[sym1__, sym2__]", + x[(sym1__ - 1)][(sym2__ - 1)], 0);} + } } + } + current_statement__ = 34; + if (lcm_sym151__) { + current_statement__ = 34; + if (lcm_sym152__) { + current_statement__ = 34; + current_statement__ = 34; + check_less_or_equal(function__, "x[sym1__, sym2__]", + x[(1 - 1)][(1 - 1)], max_age); + for (size_t sym2__ = 2; sym2__ <= lcm_sym153__; ++sym2__) { + current_statement__ = 34; + current_statement__ = 34; + check_less_or_equal(function__, "x[sym1__, sym2__]", + x[(1 - 1)][(sym2__ - 1)], max_age);} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 34; + if (lcm_sym152__) { + current_statement__ = 34; + current_statement__ = 34; + check_less_or_equal(function__, "x[sym1__, sym2__]", + x[(sym1__ - 1)][(1 - 1)], max_age); + for (size_t sym2__ = 2; sym2__ <= lcm_sym153__; ++sym2__) { + current_statement__ = 34; + current_statement__ = 34; + check_less_or_equal(function__, "x[sym1__, sym2__]", + x[(sym1__ - 1)][(sym2__ - 1)], max_age);} + } } + } + current_statement__ = 36; + if (lcm_sym151__) { + current_statement__ = 36; + current_statement__ = 36; + check_greater_or_equal(function__, "first[sym1__]", first[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 36; + current_statement__ = 36; + check_greater_or_equal(function__, "first[sym1__]", + first[(sym1__ - 1)], 0);} + } + current_statement__ = 36; + if (lcm_sym151__) { + current_statement__ = 36; + current_statement__ = 36; + check_less_or_equal(function__, "first[sym1__]", first[(1 - 1)], + n_occasions); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 36; + current_statement__ = 36; + check_less_or_equal(function__, "first[sym1__]", + first[(sym1__ - 1)], n_occasions);} + } + current_statement__ = 37; + if (lcm_sym151__) { + current_statement__ = 37; + current_statement__ = 37; + check_greater_or_equal(function__, "last[sym1__]", last[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 37; + current_statement__ = 37; + check_greater_or_equal(function__, "last[sym1__]", + last[(sym1__ - 1)], 0);} + } + current_statement__ = 37; + if (lcm_sym151__) { + current_statement__ = 37; + current_statement__ = 37; + check_less_or_equal(function__, "last[sym1__]", last[(1 - 1)], + n_occasions); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 37; + current_statement__ = 37; + check_less_or_equal(function__, "last[sym1__]", last[(sym1__ - 1)], + n_occasions);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + num_params_r__ += 1; + current_statement__ = 2; + validate_non_negative_index("beta", "max_age", max_age); + num_params_r__ += max_age; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "fails_test_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + int lcm_sym149__; + int lcm_sym148__; + int lcm_sym147__; + int lcm_sym146__; + double lcm_sym145__; + double lcm_sym144__; + double lcm_sym143__; + double lcm_sym142__; + double lcm_sym140__; + double lcm_sym138__; + double lcm_sym141__; + double lcm_sym136__; + double lcm_sym135__; + double lcm_sym134__; + double lcm_sym133__; + double lcm_sym132__; + double lcm_sym131__; + double lcm_sym130__; + double lcm_sym129__; + double lcm_sym128__; + double lcm_sym127__; + double lcm_sym126__; + double lcm_sym125__; + int lcm_sym124__; + int lcm_sym123__; + int lcm_sym122__; + int lcm_sym121__; + int lcm_sym120__; + int lcm_sym119__; + int lcm_sym118__; + int lcm_sym117__; + int lcm_sym116__; + int lcm_sym115__; + int lcm_sym114__; + int lcm_sym113__; + int lcm_sym112__; + int lcm_sym111__; + int lcm_sym110__; + int lcm_sym109__; + int lcm_sym108__; + int lcm_sym107__; + int lcm_sym106__; + int lcm_sym105__; + int lcm_sym104__; + int lcm_sym103__; + local_scalar_t__ mean_p; + + current_statement__ = 1; + mean_p = in__.scalar(); + current_statement__ = 1; + if (jacobian__) { + current_statement__ = 1; + mean_p = stan::math::lub_constrain(mean_p, 0, 1, lp__); + } else { + current_statement__ = 1; + mean_p = stan::math::lub_constrain(mean_p, 0, 1); + } + current_statement__ = 2; + validate_non_negative_index("beta", "max_age", max_age); + Eigen::Matrix beta; + beta = Eigen::Matrix(max_age); + + current_statement__ = 2; + beta = in__.vector(max_age); + current_statement__ = 2; + if (logical_gte(max_age, 1)) { + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + assign(beta, cons_list(index_uni(1), nil_index_list()), + stan::math::lub_constrain(beta[(1 - 1)], 0, 1, lp__), + "assigning variable beta"); + } else { + current_statement__ = 2; + assign(beta, cons_list(index_uni(1), nil_index_list()), + stan::math::lub_constrain(beta[(1 - 1)], 0, 1), + "assigning variable beta"); + } + for (size_t sym1__ = 2; sym1__ <= max_age; ++sym1__) { + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + assign(beta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(beta[(sym1__ - 1)], 0, 1, lp__), + "assigning variable beta"); + } else { + current_statement__ = 2; + assign(beta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(beta[(sym1__ - 1)], 0, 1), + "assigning variable beta"); + }} + } + current_statement__ = 3; + validate_non_negative_index("phi", "nind", nind); + lcm_sym116__ = (n_occasions - 1); + validate_non_negative_index("phi", "n_occ_minus_1", lcm_sym116__); + Eigen::Matrix phi; + phi = Eigen::Matrix(nind, lcm_sym116__); + + lcm_sym105__ = logical_gte(nind, 1); + if (lcm_sym105__) { + lcm_sym106__ = logical_gte(lcm_sym116__, 1); + if (lcm_sym106__) { + lcm_sym141__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym141__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym116__; ++sym2__) { + current_statement__ = 3; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym141__, "assigning variable phi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 3; + if (lcm_sym106__) { + lcm_sym141__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym141__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym116__; ++sym2__) { + current_statement__ = 3; + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym141__, "assigning variable phi");} + } } + } + current_statement__ = 4; + validate_non_negative_index("p", "nind", nind); + current_statement__ = 4; + validate_non_negative_index("p", "n_occ_minus_1", lcm_sym116__); + Eigen::Matrix p; + p = Eigen::Matrix(nind, lcm_sym116__); + + current_statement__ = 4; + if (lcm_sym105__) { + lcm_sym106__ = logical_gte(lcm_sym116__, 1); + if (lcm_sym106__) { + lcm_sym141__ = std::numeric_limits::quiet_NaN(); + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym141__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym116__; ++sym2__) { + current_statement__ = 4; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym141__, "assigning variable p");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 4; + if (lcm_sym106__) { + lcm_sym141__ = std::numeric_limits::quiet_NaN(); + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym141__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym116__; ++sym2__) { + current_statement__ = 4; + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym141__, "assigning variable p");} + } } + } + current_statement__ = 5; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 5; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix chi; + chi = Eigen::Matrix(nind, n_occasions); + + current_statement__ = 5; + if (lcm_sym105__) { + lcm_sym104__ = logical_gte(n_occasions, 1); + if (lcm_sym104__) { + lcm_sym141__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym141__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 5; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym141__, "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 5; + if (lcm_sym104__) { + lcm_sym141__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym141__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 5; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym141__, "assigning variable chi");} + } } + } + current_statement__ = 14; + if (lcm_sym105__) { + lcm_sym147__ = first[(1 - 1)]; + lcm_sym118__ = (lcm_sym147__ - 1); + if (logical_gte(lcm_sym118__, 1)) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable p"); + for (size_t t = 2; t <= lcm_sym118__; ++t) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable p");} + } + current_statement__ = 12; + if (logical_gte(lcm_sym116__, lcm_sym147__)) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym147__), nil_index_list())), + beta[(x[(1 - 1)][(lcm_sym147__ - 1)] - 1)], + "assigning variable phi"); + lcm_sym124__ = (lcm_sym147__ + 1); + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym147__), nil_index_list())), mean_p, + "assigning variable p"); + for (size_t t = lcm_sym124__; t <= lcm_sym116__; ++t) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), + beta[(x[(1 - 1)][(t - 1)] - 1)], "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), mean_p, + "assigning variable p");} + } + for (size_t i = 2; i <= nind; ++i) { + lcm_sym146__ = first[(i - 1)]; + lcm_sym117__ = (lcm_sym146__ - 1); + if (logical_gte(lcm_sym117__, 1)) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable p"); + for (size_t t = 2; t <= lcm_sym117__; ++t) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable p");} + } + current_statement__ = 12; + if (logical_gte(lcm_sym116__, lcm_sym146__)) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym146__), nil_index_list())), + beta[(x[(i - 1)][(lcm_sym146__ - 1)] - 1)], + "assigning variable phi"); + lcm_sym123__ = (lcm_sym146__ + 1); + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym146__), nil_index_list())), + mean_p, "assigning variable p"); + for (size_t t = lcm_sym123__; t <= lcm_sym116__; ++t) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), + beta[(x[(i - 1)][(t - 1)] - 1)], "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), mean_p, + "assigning variable p");} + } } + } + Eigen::Matrix inline_sym11__; + int inline_sym19__; + + inline_sym19__ = 0; + for (size_t inline_sym20__ = 1; inline_sym20__ <= 1; ++inline_sym20__) { + current_statement__ = 15; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 15; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix inline_sym12__; + inline_sym12__ = Eigen::Matrix(nind, n_occasions); + + for (size_t inline_sym14__ = 1; inline_sym14__ <= nind; + ++inline_sym14__) { + if (logical_gte(n_occasions, 1)) { + lcm_sym141__ = std::numeric_limits::quiet_NaN(); + assign(inline_sym12__, + cons_list(index_uni(inline_sym14__), + cons_list(index_uni(1), nil_index_list())), lcm_sym141__, + "assigning variable inline_sym12__"); + for (size_t inline_sym13__ = 2; inline_sym13__ <= n_occasions; + ++inline_sym13__) { + current_statement__ = 15; + assign(inline_sym12__, + cons_list(index_uni(inline_sym14__), + cons_list(index_uni(inline_sym13__), nil_index_list())), + lcm_sym141__, "assigning variable inline_sym12__");} + } + if (inline_sym19__) { + break; + } } + if (inline_sym19__) { + break; + } + for (size_t inline_sym18__ = 1; inline_sym18__ <= nind; + ++inline_sym18__) { + current_statement__ = 16; + assign(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(n_occasions), nil_index_list())), 1.0, + "assigning variable inline_sym12__"); + if (logical_gte(lcm_sym116__, 1)) { + int inline_sym15__; + + int inline_sym16__; + + lcm_sym120__ = (lcm_sym116__ + 1); + current_statement__ = 19; + assign(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym116__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym116__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni((lcm_sym120__ - 1)), + nil_index_list())), "p"))), + rvalue(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym120__), nil_index_list())), + "inline_sym12__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym116__), nil_index_list())), + "phi"))), "assigning variable inline_sym12__"); + for (size_t inline_sym17__ = 2; inline_sym17__ <= lcm_sym116__; + ++inline_sym17__) { + int inline_sym15__; + + lcm_sym115__ = (n_occasions - inline_sym17__); + int inline_sym16__; + + lcm_sym119__ = (lcm_sym115__ + 1); + current_statement__ = 19; + assign(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym115__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym115__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni((lcm_sym119__ - 1)), + nil_index_list())), "p"))), + rvalue(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym119__), nil_index_list())), + "inline_sym12__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym115__), nil_index_list())), + "phi"))), "assigning variable inline_sym12__");} + } + if (inline_sym19__) { + break; + } } + if (inline_sym19__) { + break; + } + inline_sym19__ = 1; + assign(inline_sym11__, nil_index_list(), inline_sym12__, + "assigning variable inline_sym11__"); + break;} + assign(chi, nil_index_list(), inline_sym11__, "assigning variable chi"); + current_statement__ = 3; + current_statement__ = 3; + check_greater_or_equal(function__, "phi", phi, 0); + current_statement__ = 3; + current_statement__ = 3; + check_less_or_equal(function__, "phi", phi, 1); + current_statement__ = 4; + current_statement__ = 4; + check_greater_or_equal(function__, "p", p, 0); + current_statement__ = 4; + current_statement__ = 4; + check_less_or_equal(function__, "p", p, 1); + current_statement__ = 5; + current_statement__ = 5; + check_greater_or_equal(function__, "chi", inline_sym11__, 0); + current_statement__ = 5; + current_statement__ = 5; + check_less_or_equal(function__, "chi", inline_sym11__, 1); + { + current_statement__ = 29; + if (lcm_sym105__) { + lcm_sym147__ = first[(1 - 1)]; + if (logical_gt(lcm_sym147__, 0)) { + lcm_sym149__ = last[(1 - 1)]; + lcm_sym124__ = (lcm_sym147__ + 1); + if (logical_gte(lcm_sym149__, lcm_sym124__)) { + current_statement__ = 23; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym124__ - 1)), + nil_index_list())), "phi"))); + lcm_sym122__ = (lcm_sym124__ + 1); + lp_accum__.add( + bernoulli_log(y[(1 - 1)][(lcm_sym124__ - 1)], + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym124__ - 1)), + nil_index_list())), "p"))); + for (size_t t = lcm_sym122__; t <= lcm_sym149__; ++t) { + current_statement__ = 23; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni((t - 1)), nil_index_list())), + "phi"))); + current_statement__ = 24; + lp_accum__.add( + bernoulli_log(y[(1 - 1)][(t - 1)], + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((t - 1)), nil_index_list())), + "p")));} + } + current_statement__ = 26; + lp_accum__.add( + bernoulli_log(1, + rvalue(inline_sym11__, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym149__), nil_index_list())), + "inline_sym11__"))); + } + for (size_t i = 2; i <= nind; ++i) { + lcm_sym146__ = first[(i - 1)]; + if (logical_gt(lcm_sym146__, 0)) { + lcm_sym148__ = last[(i - 1)]; + lcm_sym123__ = (lcm_sym146__ + 1); + if (logical_gte(lcm_sym148__, lcm_sym123__)) { + current_statement__ = 23; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym123__ - 1)), + nil_index_list())), "phi"))); + lcm_sym121__ = (lcm_sym123__ + 1); + lp_accum__.add( + bernoulli_log(y[(i - 1)][(lcm_sym123__ - 1)], + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym123__ - 1)), + nil_index_list())), "p"))); + for (size_t t = lcm_sym121__; t <= lcm_sym148__; ++t) { + current_statement__ = 23; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni((t - 1)), nil_index_list())), + "phi"))); + current_statement__ = 24; + lp_accum__.add( + bernoulli_log(y[(i - 1)][(t - 1)], + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((t - 1)), nil_index_list())), + "p")));} + } + current_statement__ = 26; + lp_accum__.add( + bernoulli_log(1, + rvalue(inline_sym11__, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym148__), nil_index_list())), + "inline_sym11__"))); + } } + } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "fails_test_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + double lcm_sym102__; + double lcm_sym101__; + double lcm_sym100__; + double lcm_sym99__; + double lcm_sym98__; + double lcm_sym97__; + double lcm_sym96__; + double lcm_sym95__; + double lcm_sym94__; + double lcm_sym93__; + double lcm_sym92__; + double lcm_sym91__; + int lcm_sym90__; + int lcm_sym89__; + double lcm_sym88__; + double lcm_sym87__; + double lcm_sym86__; + double lcm_sym85__; + double lcm_sym84__; + double lcm_sym83__; + double lcm_sym82__; + double lcm_sym79__; + double lcm_sym78__; + int lcm_sym77__; + int lcm_sym76__; + int lcm_sym75__; + int lcm_sym74__; + int lcm_sym73__; + int lcm_sym72__; + int lcm_sym71__; + int lcm_sym70__; + int lcm_sym69__; + int lcm_sym68__; + int lcm_sym67__; + int lcm_sym66__; + int lcm_sym65__; + int lcm_sym64__; + int lcm_sym63__; + int lcm_sym62__; + int lcm_sym61__; + int lcm_sym60__; + double mean_p; + + current_statement__ = 1; + mean_p = in__.scalar(); + current_statement__ = 1; + mean_p = stan::math::lub_constrain(mean_p, 0, 1); + current_statement__ = 2; + validate_non_negative_index("beta", "max_age", max_age); + Eigen::Matrix beta; + beta = Eigen::Matrix(max_age); + + current_statement__ = 2; + beta = in__.vector(max_age); + lcm_sym60__ = logical_gte(max_age, 1); + if (lcm_sym60__) { + current_statement__ = 2; + assign(beta, cons_list(index_uni(1), nil_index_list()), + stan::math::lub_constrain(beta[(1 - 1)], 0, 1), + "assigning variable beta"); + for (size_t sym1__ = 2; sym1__ <= max_age; ++sym1__) { + current_statement__ = 2; + assign(beta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(beta[(sym1__ - 1)], 0, 1), + "assigning variable beta");} + } + current_statement__ = 3; + validate_non_negative_index("phi", "nind", nind); + lcm_sym69__ = (n_occasions - 1); + validate_non_negative_index("phi", "n_occ_minus_1", lcm_sym69__); + Eigen::Matrix phi; + phi = Eigen::Matrix(nind, lcm_sym69__); + + lcm_sym62__ = logical_gte(nind, 1); + if (lcm_sym62__) { + { + lcm_sym63__ = logical_gte(lcm_sym69__, 1); + if (lcm_sym63__) { + lcm_sym82__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym82__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym69__; ++sym2__) { + current_statement__ = 3; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym82__, "assigning variable phi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 3; + if (lcm_sym63__) { + lcm_sym82__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym82__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym69__; ++sym2__) { + current_statement__ = 3; + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym82__, "assigning variable phi");} + } } + } + } else { + lcm_sym63__ = logical_gte(lcm_sym69__, 1); + } + current_statement__ = 4; + validate_non_negative_index("p", "nind", nind); + current_statement__ = 4; + validate_non_negative_index("p", "n_occ_minus_1", lcm_sym69__); + Eigen::Matrix p; + p = Eigen::Matrix(nind, lcm_sym69__); + + current_statement__ = 4; + if (lcm_sym62__) { + current_statement__ = 4; + if (lcm_sym63__) { + lcm_sym82__ = std::numeric_limits::quiet_NaN(); + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym82__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym69__; ++sym2__) { + current_statement__ = 4; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), lcm_sym82__, + "assigning variable p");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 4; + if (lcm_sym63__) { + lcm_sym82__ = std::numeric_limits::quiet_NaN(); + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym82__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym69__; ++sym2__) { + current_statement__ = 4; + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym82__, "assigning variable p");} + } } + } + current_statement__ = 5; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 5; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix chi; + chi = Eigen::Matrix(nind, n_occasions); + + current_statement__ = 5; + if (lcm_sym62__) { + { + lcm_sym61__ = logical_gte(n_occasions, 1); + if (lcm_sym61__) { + lcm_sym82__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym82__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 5; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym82__, "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 5; + if (lcm_sym61__) { + lcm_sym82__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym82__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 5; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym82__, "assigning variable chi");} + } } + } + } else { + lcm_sym61__ = logical_gte(n_occasions, 1); + } + vars__.push_back(mean_p); + if (lcm_sym60__) { + vars__.push_back(beta[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= max_age; ++sym1__) { + vars__.push_back(beta[(sym1__ - 1)]);} + } + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + current_statement__ = 14; + if (lcm_sym62__) { + lcm_sym90__ = first[(1 - 1)]; + lcm_sym71__ = (lcm_sym90__ - 1); + if (logical_gte(lcm_sym71__, 1)) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable p"); + for (size_t t = 2; t <= lcm_sym71__; ++t) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable p");} + } + current_statement__ = 12; + if (logical_gte(lcm_sym69__, lcm_sym90__)) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym90__), nil_index_list())), + beta[(x[(1 - 1)][(lcm_sym90__ - 1)] - 1)], + "assigning variable phi"); + lcm_sym77__ = (lcm_sym90__ + 1); + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym90__), nil_index_list())), mean_p, + "assigning variable p"); + for (size_t t = lcm_sym77__; t <= lcm_sym69__; ++t) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), + beta[(x[(1 - 1)][(t - 1)] - 1)], "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), mean_p, + "assigning variable p");} + } + for (size_t i = 2; i <= nind; ++i) { + lcm_sym89__ = first[(i - 1)]; + lcm_sym70__ = (lcm_sym89__ - 1); + if (logical_gte(lcm_sym70__, 1)) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable p"); + for (size_t t = 2; t <= lcm_sym70__; ++t) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable p");} + } + current_statement__ = 12; + if (logical_gte(lcm_sym69__, lcm_sym89__)) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym89__), nil_index_list())), + beta[(x[(i - 1)][(lcm_sym89__ - 1)] - 1)], + "assigning variable phi"); + lcm_sym76__ = (lcm_sym89__ + 1); + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym89__), nil_index_list())), mean_p, + "assigning variable p"); + for (size_t t = lcm_sym76__; t <= lcm_sym69__; ++t) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), + beta[(x[(i - 1)][(t - 1)] - 1)], "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), mean_p, + "assigning variable p");} + } } + } + Eigen::Matrix inline_sym1__; + int inline_sym9__; + + inline_sym9__ = 0; + for (size_t inline_sym10__ = 1; inline_sym10__ <= 1; ++inline_sym10__) { + current_statement__ = 15; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 15; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix inline_sym2__; + inline_sym2__ = Eigen::Matrix(nind, n_occasions); + + for (size_t inline_sym4__ = 1; inline_sym4__ <= nind; ++inline_sym4__) { + if (lcm_sym61__) { + lcm_sym82__ = std::numeric_limits::quiet_NaN(); + assign(inline_sym2__, + cons_list(index_uni(inline_sym4__), + cons_list(index_uni(1), nil_index_list())), lcm_sym82__, + "assigning variable inline_sym2__"); + for (size_t inline_sym3__ = 2; inline_sym3__ <= n_occasions; + ++inline_sym3__) { + current_statement__ = 15; + assign(inline_sym2__, + cons_list(index_uni(inline_sym4__), + cons_list(index_uni(inline_sym3__), nil_index_list())), + lcm_sym82__, "assigning variable inline_sym2__");} + } + if (inline_sym9__) { + break; + } } + if (inline_sym9__) { + break; + } + for (size_t inline_sym8__ = 1; inline_sym8__ <= nind; ++inline_sym8__) { + current_statement__ = 16; + assign(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(n_occasions), nil_index_list())), 1.0, + "assigning variable inline_sym2__"); + if (lcm_sym63__) { + int inline_sym5__; + + int inline_sym6__; + + lcm_sym75__ = (lcm_sym69__ + 1); + current_statement__ = 19; + assign(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym69__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym69__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni((lcm_sym75__ - 1)), + nil_index_list())), "p"))), + rvalue(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym75__), nil_index_list())), + "inline_sym2__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym69__), nil_index_list())), + "phi"))), "assigning variable inline_sym2__"); + for (size_t inline_sym7__ = 2; inline_sym7__ <= lcm_sym69__; + ++inline_sym7__) { + int inline_sym5__; + + lcm_sym68__ = (n_occasions - inline_sym7__); + int inline_sym6__; + + lcm_sym74__ = (lcm_sym68__ + 1); + current_statement__ = 19; + assign(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym68__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym68__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni((lcm_sym74__ - 1)), + nil_index_list())), "p"))), + rvalue(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym74__), nil_index_list())), + "inline_sym2__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym68__), nil_index_list())), + "phi"))), "assigning variable inline_sym2__");} + } + if (inline_sym9__) { + break; + } } + if (inline_sym9__) { + break; + } + inline_sym9__ = 1; + assign(inline_sym1__, nil_index_list(), inline_sym2__, + "assigning variable inline_sym1__"); + break;} + assign(chi, nil_index_list(), inline_sym1__, "assigning variable chi"); + if (lcm_sym63__) { + if (lcm_sym62__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "phi")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), "phi"));} + } + for (size_t sym1__ = 2; sym1__ <= lcm_sym69__; ++sym1__) { + if (lcm_sym62__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), "phi")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "phi")); + } + } } + } + if (lcm_sym63__) { + if (lcm_sym62__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "p")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), "p"));} + } + for (size_t sym1__ = 2; sym1__ <= lcm_sym69__; ++sym1__) { + if (lcm_sym62__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), "p")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "p"));} + } } + } + if (lcm_sym61__) { + if (lcm_sym62__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "inline_sym1__")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + "inline_sym1__"));} + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + if (lcm_sym62__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + "inline_sym1__")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "inline_sym1__"));} + } } + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + double lcm_sym59__; + double lcm_sym58__; + double lcm_sym57__; + double lcm_sym56__; + int lcm_sym53__; + int lcm_sym52__; + int pos__; + + pos__ = 1; + double mean_p; + + current_statement__ = 1; + mean_p = context__.vals_r("mean_p")[(1 - 1)]; + current_statement__ = 1; + mean_p = stan::math::lub_free(mean_p, 0, 1); + current_statement__ = 2; + validate_non_negative_index("beta", "max_age", max_age); + Eigen::Matrix beta; + beta = Eigen::Matrix(max_age); + + { + std::vector beta_flat__; + current_statement__ = 2; + assign(beta_flat__, nil_index_list(), context__.vals_r("beta"), + "assigning variable beta_flat__"); + current_statement__ = 2; + pos__ = 1; + lcm_sym52__ = logical_gte(max_age, 1); + if (lcm_sym52__) { + current_statement__ = 2; + assign(beta, cons_list(index_uni(1), nil_index_list()), + beta_flat__[(1 - 1)], "assigning variable beta"); + current_statement__ = 2; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= max_age; ++sym1__) { + current_statement__ = 2; + assign(beta, cons_list(index_uni(sym1__), nil_index_list()), + beta_flat__[(pos__ - 1)], "assigning variable beta"); + current_statement__ = 2; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 2; + if (lcm_sym52__) { + current_statement__ = 2; + assign(beta, cons_list(index_uni(1), nil_index_list()), + stan::math::lub_free(beta[(1 - 1)], 0, 1), + "assigning variable beta"); + for (size_t sym1__ = 2; sym1__ <= max_age; ++sym1__) { + current_statement__ = 2; + assign(beta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_free(beta[(sym1__ - 1)], 0, 1), + "assigning variable beta");} + } + vars__.push_back(mean_p); + if (lcm_sym52__) { + vars__.push_back(beta[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= max_age; ++sym1__) { + vars__.push_back(beta[(sym1__ - 1)]);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("mean_p"); + names__.push_back("beta"); + names__.push_back("phi"); + names__.push_back("p"); + names__.push_back("chi"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(max_age); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(nind); + + dims__.push_back(n_occ_minus_1); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(nind); + + dims__.push_back(n_occ_minus_1); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(nind); + + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "mean_p"); + for (size_t sym181__ = 1; sym181__ <= max_age; ++sym181__) { + { + param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym181__)); + }} + if (emit_transformed_parameters__) { + for (size_t sym181__ = 1; sym181__ <= n_occ_minus_1; ++sym181__) { + { + for (size_t sym182__ = 1; sym182__ <= nind; ++sym182__) { + { + param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym182__) + '.' + std::to_string(sym181__)); + }} + }} + for (size_t sym181__ = 1; sym181__ <= n_occ_minus_1; ++sym181__) { + { + for (size_t sym182__ = 1; sym182__ <= nind; ++sym182__) { + { + param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym182__) + '.' + std::to_string(sym181__)); + }} + }} + for (size_t sym181__ = 1; sym181__ <= n_occasions; ++sym181__) { + { + for (size_t sym182__ = 1; sym182__ <= nind; ++sym182__) { + { + param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym182__) + '.' + std::to_string(sym181__)); + }} + }} + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "mean_p"); + for (size_t sym181__ = 1; sym181__ <= max_age; ++sym181__) { + { + param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym181__)); + }} + if (emit_transformed_parameters__) { + for (size_t sym181__ = 1; sym181__ <= n_occ_minus_1; ++sym181__) { + { + for (size_t sym182__ = 1; sym182__ <= nind; ++sym182__) { + { + param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym182__) + '.' + std::to_string(sym181__)); + }} + }} + for (size_t sym181__ = 1; sym181__ <= n_occ_minus_1; ++sym181__) { + { + for (size_t sym182__ = 1; sym182__ <= nind; ++sym182__) { + { + param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym182__) + '.' + std::to_string(sym181__)); + }} + }} + for (size_t sym181__ = 1; sym181__ <= n_occasions; ++sym181__) { + { + for (size_t sym182__ = 1; sym182__ <= nind; ++sym182__) { + { + param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym182__) + '.' + std::to_string(sym181__)); + }} + }} + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << max_age << "},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << max_age << "},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef fails_test_model_namespace::fails_test_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp inlining-fail2.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace inlining_fail2_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'inlining-fail2.stan', line 177, column 2 to column 33)", + " (in 'inlining-fail2.stan', line 178, column 2 to column 31)", + " (in 'inlining-fail2.stan', line 179, column 2 to column 45)", + " (in 'inlining-fail2.stan', line 180, column 2 to column 32)", + " (in 'inlining-fail2.stan', line 181, column 2 to column 30)", + " (in 'inlining-fail2.stan', line 187, column 2 to column 50)", + " (in 'inlining-fail2.stan', line 188, column 2 to column 44)", + " (in 'inlining-fail2.stan', line 189, column 2 to column 46)", + " (in 'inlining-fail2.stan', line 194, column 6 to column 58)", + " (in 'inlining-fail2.stan', line 193, column 4 to line 194, column 58)", + " (in 'inlining-fail2.stan', line 192, column 2 to line 194, column 58)", + " (in 'inlining-fail2.stan', line 49, column 4 to column 24)", + " (in 'inlining-fail2.stan', line 50, column 4 to column 30)", + " (in 'inlining-fail2.stan', line 51, column 4 to column 35)", + " (in 'inlining-fail2.stan', line 54, column 6 to column 32)", + " (in 'inlining-fail2.stan', line 56, column 8 to column 37)", + " (in 'inlining-fail2.stan', line 57, column 8 to column 32)", + " (in 'inlining-fail2.stan', line 59, column 8 to line 60, column 65)", + " (in 'inlining-fail2.stan', line 55, column 37 to line 61, column 7)", + " (in 'inlining-fail2.stan', line 53, column 23 to line 62, column 5)", + " (in 'inlining-fail2.stan', line 48, column 47 to line 64, column 3)", + " (in 'inlining-fail2.stan', line 213, column 2 to column 14)", + " (in 'inlining-fail2.stan', line 214, column 2 to column 11)", + " (in 'inlining-fail2.stan', line 215, column 2 to column 24)", + " (in 'inlining-fail2.stan', line 216, column 2 to column 13)", + " (in 'inlining-fail2.stan', line 217, column 2 to column 21)", + " (in 'inlining-fail2.stan', line 218, column 2 to column 21)", + " (in 'inlining-fail2.stan', line 219, column 2 to column 24)", + " (in 'inlining-fail2.stan', line 223, column 4 to column 14)", + " (in 'inlining-fail2.stan', line 224, column 4 to column 13)", + " (in 'inlining-fail2.stan', line 231, column 6 to column 35)", + " (in 'inlining-fail2.stan', line 228, column 6 to column 32)", + " (in 'inlining-fail2.stan', line 227, column 29 to line 232, column 5)", + " (in 'inlining-fail2.stan', line 226, column 4 to column 38)", + " (in 'inlining-fail2.stan', line 227, column 4 to line 232, column 5)", + " (in 'inlining-fail2.stan', line 222, column 17 to line 233, column 3)", + " (in 'inlining-fail2.stan', line 222, column 2 to line 233, column 3)", + " (in 'inlining-fail2.stan', line 237, column 4 to column 49)", + " (in 'inlining-fail2.stan', line 148, column 4 to column 24)", + " (in 'inlining-fail2.stan', line 149, column 4 to column 24)", + " (in 'inlining-fail2.stan', line 150, column 4 to column 31)", + " (in 'inlining-fail2.stan', line 154, column 6 to column 64)", + " (in 'inlining-fail2.stan', line 153, column 6 to column 55)", + " (in 'inlining-fail2.stan', line 152, column 19 to line 155, column 5)", + " (in 'inlining-fail2.stan', line 147, column 33 to line 157, column 3)", + " (in 'inlining-fail2.stan', line 238, column 4 to column 63)", + " (in 'inlining-fail2.stan', line 239, column 4 to column 16)", + " (in 'inlining-fail2.stan', line 240, column 4 to column 18)", + " (in 'inlining-fail2.stan', line 247, column 6 to column 36)", + " (in 'inlining-fail2.stan', line 17, column 8 to column 17)", + " (in 'inlining-fail2.stan', line 16, column 6 to line 17, column 17)", + " (in 'inlining-fail2.stan', line 14, column 31 to line 19, column 3)", + " (in 'inlining-fail2.stan', line 250, column 8 to column 26)", + " (in 'inlining-fail2.stan', line 249, column 6 to line 250, column 26)", + " (in 'inlining-fail2.stan', line 246, column 19 to line 251, column 5)", + " (in 'inlining-fail2.stan', line 246, column 4 to line 251, column 5)", + " (in 'inlining-fail2.stan', line 253, column 6 to column 25)", + " (in 'inlining-fail2.stan', line 254, column 6 to column 31)", + " (in 'inlining-fail2.stan', line 252, column 29 to line 255, column 5)", + " (in 'inlining-fail2.stan', line 252, column 4 to line 255, column 5)", + " (in 'inlining-fail2.stan', line 257, column 6 to column 26)", + " (in 'inlining-fail2.stan', line 258, column 6 to column 31)", + " (in 'inlining-fail2.stan', line 256, column 19 to line 259, column 5)", + " (in 'inlining-fail2.stan', line 256, column 4 to line 259, column 5)", + " (in 'inlining-fail2.stan', line 260, column 4 to column 25)", + " (in 'inlining-fail2.stan', line 236, column 2 to line 261, column 3)", + " (in 'inlining-fail2.stan', line 206, column 2 to column 29)", + " (in 'inlining-fail2.stan', line 80, column 4 to column 27)", + " (in 'inlining-fail2.stan', line 81, column 4 to column 33)", + " (in 'inlining-fail2.stan', line 82, column 4 to column 45)", + " (in 'inlining-fail2.stan', line 85, column 6 to column 43)", + " (in 'inlining-fail2.stan', line 119, column 8 to column 33)", + " (in 'inlining-fail2.stan', line 127, column 10 to line 130, column 49)", + " (in 'inlining-fail2.stan', line 132, column 8 to column 63)", + " (in 'inlining-fail2.stan', line 133, column 8 to column 34)", + " (in 'inlining-fail2.stan', line 118, column 13 to line 134, column 7)", + " (in 'inlining-fail2.stan', line 92, column 10 to column 30)", + " (in 'inlining-fail2.stan', line 101, column 12 to line 105, column 56)", + " (in 'inlining-fail2.stan', line 106, column 10 to line 108, column 61)", + " (in 'inlining-fail2.stan', line 109, column 10 to column 36)", + " (in 'inlining-fail2.stan', line 91, column 15 to line 110, column 9)", + " (in 'inlining-fail2.stan', line 89, column 27 to line 91, column 9)", + " (in 'inlining-fail2.stan', line 89, column 8 to line 110, column 9)", + " (in 'inlining-fail2.stan', line 113, column 10 to column 39)", + " (in 'inlining-fail2.stan', line 114, column 10 to column 39)", + " (in 'inlining-fail2.stan', line 112, column 42 to line 115, column 9)", + " (in 'inlining-fail2.stan', line 117, column 8 to column 39)", + " (in 'inlining-fail2.stan', line 87, column 20 to line 118, column 7)", + " (in 'inlining-fail2.stan', line 122, column 8 to line 124, column 47)", + " (in 'inlining-fail2.stan', line 90, column 10 to column 44)", + " (in 'inlining-fail2.stan', line 84, column 23 to line 135, column 5)", + " (in 'inlining-fail2.stan', line 161, column 2 to column 17)", + " (in 'inlining-fail2.stan', line 162, column 2 to column 27)", + " (in 'inlining-fail2.stan', line 163, column 2 to column 41)", + " (in 'inlining-fail2.stan', line 167, column 2 to column 42)", + " (in 'inlining-fail2.stan', line 168, column 2 to column 41)", + " (in 'inlining-fail2.stan', line 171, column 4 to column 35)", + " (in 'inlining-fail2.stan', line 170, column 2 to line 171, column 35)", + " (in 'inlining-fail2.stan', line 30, column 6 to column 32)", + " (in 'inlining-fail2.stan', line 33, column 8 to column 17)", + " (in 'inlining-fail2.stan', line 32, column 6 to line 33, column 17)", + " (in 'inlining-fail2.stan', line 29, column 37 to line 34, column 5)", + " (in 'inlining-fail2.stan', line 28, column 30 to line 36, column 3)", + " (in 'inlining-fail2.stan', line 173, column 4 to column 33)", + " (in 'inlining-fail2.stan', line 172, column 2 to line 173, column 33)", + " (in 'inlining-fail2.stan', line 18, column 4 to column 13)", + " (in 'inlining-fail2.stan', line 35, column 4 to column 13)", + " (in 'inlining-fail2.stan', line 55, column 6 to line 61, column 7)", + " (in 'inlining-fail2.stan', line 53, column 4 to line 62, column 5)", + " (in 'inlining-fail2.stan', line 63, column 4 to column 15)", + " (in 'inlining-fail2.stan', line 126, column 8 to line 130, column 49)", + " (in 'inlining-fail2.stan', line 100, column 10 to line 105, column 56)", + " (in 'inlining-fail2.stan', line 84, column 4 to line 135, column 5)", + " (in 'inlining-fail2.stan', line 79, column 34 to line 136, column 3)", + " (in 'inlining-fail2.stan', line 152, column 4 to line 155, column 5)", + " (in 'inlining-fail2.stan', line 156, column 4 to column 26)"}; + + +int +first_capture(const std::vector& y_i, std::ostream* pstream__) { + using local_scalar_t__ = double; + const static bool propto__ = true; + (void) propto__; + + try { + int lcm_sym59__; + int lcm_sym58__; + int lcm_sym57__; + int lcm_sym56__; + { + lcm_sym57__ = size(y_i); + if (logical_gte(lcm_sym57__, 1)) { + current_statement__ = 51; + if (y_i[(1 - 1)]) { + current_statement__ = 50; + return 1; + } + for (size_t k = 2; k <= lcm_sym57__; ++k) { + current_statement__ = 51; + if (y_i[(k - 1)]) { + current_statement__ = 50; + return k; + } } + } + current_statement__ = 106; + return 0; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct first_capture_functor__ { +int +operator()(const std::vector& y_i, std::ostream* pstream__) const +{ +return first_capture(y_i, pstream__); +} +}; + +int +last_capture(const std::vector& y_i, std::ostream* pstream__) { + using local_scalar_t__ = double; + const static bool propto__ = true; + (void) propto__; + + try { + int lcm_sym65__; + int lcm_sym64__; + int lcm_sym63__; + int lcm_sym62__; + int lcm_sym61__; + int lcm_sym60__; + { + lcm_sym63__ = (size(y_i) - 1); + if (logical_gte(lcm_sym63__, 0)) { + int k; + + lcm_sym62__ = (size(y_i) - 0); + current_statement__ = 101; + if (y_i[(lcm_sym62__ - 1)]) { + current_statement__ = 100; + return lcm_sym62__; + } + for (size_t k_rev = 1; k_rev <= lcm_sym63__; ++k_rev) { + int k; + + lcm_sym61__ = (size(y_i) - k_rev); + current_statement__ = 101; + if (y_i[(lcm_sym61__ - 1)]) { + current_statement__ = 100; + return lcm_sym61__; + } } + } + current_statement__ = 107; + return 0; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct last_capture_functor__ { +int +operator()(const std::vector& y_i, std::ostream* pstream__) const +{ +return last_capture(y_i, pstream__); +} +}; + +template +Eigen::Matrix::type, -1, -1> +prob_uncaptured(const Eigen::Matrix& p, + const Eigen::Matrix& phi, + std::ostream* pstream__) { + using local_scalar_t__ = typename boost::math::tools::promote_args::type; + const static bool propto__ = true; + (void) propto__; + + try { + double lcm_sym79__; + int lcm_sym78__; + double lcm_sym77__; + double lcm_sym76__; + double lcm_sym75__; + double lcm_sym74__; + int lcm_sym73__; + int lcm_sym72__; + int lcm_sym71__; + int lcm_sym70__; + int lcm_sym69__; + int lcm_sym68__; + int lcm_sym67__; + int lcm_sym66__; + { + int n_ind; + + lcm_sym78__ = rows(p); + int n_occasions; + + lcm_sym73__ = cols(p); + n_occasions = lcm_sym73__; + current_statement__ = 14; + validate_non_negative_index("chi", "n_ind", lcm_sym78__); + current_statement__ = 14; + validate_non_negative_index("chi", "n_occasions", lcm_sym73__); + Eigen::Matrix chi; + chi = Eigen::Matrix(lcm_sym78__, lcm_sym73__); + + lcm_sym68__ = logical_gte(lcm_sym78__, 1); + if (lcm_sym68__) { + lcm_sym67__ = logical_gte(lcm_sym73__, 1); + if (lcm_sym67__) { + lcm_sym79__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym79__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym73__; ++sym2__) { + current_statement__ = 14; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), lcm_sym79__, + "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= lcm_sym78__; ++sym1__) { + current_statement__ = 14; + if (lcm_sym67__) { + lcm_sym79__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym79__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym73__; ++sym2__) { + current_statement__ = 14; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym79__, "assigning variable chi");} + } } + } + current_statement__ = 109; + if (lcm_sym68__) { + current_statement__ = 15; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym73__), nil_index_list())), 1.0, + "assigning variable chi"); + lcm_sym70__ = (lcm_sym73__ - 1); + lcm_sym66__ = logical_gte(lcm_sym70__, 1); + if (lcm_sym66__) { + int t_curr; + + int t_next; + + lcm_sym72__ = (lcm_sym70__ + 1); + current_statement__ = 18; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym70__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym70__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym72__), nil_index_list())), + "p"))), + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym72__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym70__), nil_index_list())), + "phi"))), "assigning variable chi"); + for (size_t t = 2; t <= lcm_sym70__; ++t) { + int t_curr; + + lcm_sym69__ = (lcm_sym73__ - t); + int t_next; + + lcm_sym71__ = (lcm_sym69__ + 1); + current_statement__ = 18; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym69__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym69__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym71__), nil_index_list())), + "p"))), + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym71__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym69__), nil_index_list())), + "phi"))), "assigning variable chi");} + } + for (size_t i = 2; i <= lcm_sym78__; ++i) { + current_statement__ = 15; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym73__), nil_index_list())), 1.0, + "assigning variable chi"); + current_statement__ = 108; + if (lcm_sym66__) { + int t_curr; + + int t_next; + + lcm_sym72__ = (lcm_sym70__ + 1); + current_statement__ = 18; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym70__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym70__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym72__), nil_index_list())), + "p"))), + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym72__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym70__), nil_index_list())), + "phi"))), "assigning variable chi"); + for (size_t t = 2; t <= lcm_sym70__; ++t) { + int t_curr; + + lcm_sym69__ = (lcm_sym73__ - t); + int t_next; + + lcm_sym71__ = (lcm_sym69__ + 1); + current_statement__ = 18; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym69__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym69__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym71__), nil_index_list())), + "p"))), + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym71__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym69__), nil_index_list())), + "phi"))), "assigning variable chi");} + } } + } + current_statement__ = 110; + return chi; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct prob_uncaptured_functor__ { +template +Eigen::Matrix::type, -1, -1> +operator()(const Eigen::Matrix& p, + const Eigen::Matrix& phi, std::ostream* pstream__) const +{ +return prob_uncaptured(p, phi, pstream__); +} +}; + +template +void +jolly_seber_lp(const std::vector>& y, + const std::vector& first, const std::vector& last, + const Eigen::Matrix& p, + const Eigen::Matrix& phi, + const Eigen::Matrix& gamma, + const Eigen::Matrix& chi, T_lp__& lp__, + T_lp_accum__& lp_accum__, std::ostream* pstream__) { + using local_scalar_t__ = typename boost::math::tools::promote_args::type; + + try { + int lcm_sym133__; + int lcm_sym132__; + int lcm_sym131__; + int lcm_sym130__; + int lcm_sym129__; + int lcm_sym128__; + double lcm_sym127__; + double lcm_sym126__; + double lcm_sym125__; + double lcm_sym124__; + double lcm_sym123__; + double lcm_sym122__; + double lcm_sym121__; + double lcm_sym120__; + double lcm_sym119__; + double lcm_sym118__; + double lcm_sym117__; + double lcm_sym116__; + double lcm_sym115__; + double lcm_sym114__; + double lcm_sym113__; + int lcm_sym112__; + int lcm_sym111__; + int lcm_sym110__; + double lcm_sym109__; + double lcm_sym108__; + double lcm_sym107__; + double lcm_sym106__; + double lcm_sym105__; + double lcm_sym104__; + double lcm_sym103__; + double lcm_sym102__; + double lcm_sym101__; + double lcm_sym100__; + double lcm_sym99__; + double lcm_sym98__; + double lcm_sym97__; + double lcm_sym96__; + int lcm_sym95__; + int lcm_sym94__; + Eigen::Matrix lcm_sym93__; + Eigen::Matrix lcm_sym92__; + Eigen::Matrix lcm_sym91__; + int lcm_sym90__; + int lcm_sym89__; + int lcm_sym88__; + int lcm_sym87__; + int lcm_sym86__; + int lcm_sym85__; + int lcm_sym84__; + int lcm_sym83__; + int lcm_sym82__; + int lcm_sym81__; + int lcm_sym80__; + { + int n_ind; + + lcm_sym132__ = dims(y)[(1 - 1)]; + int n_occasions; + + lcm_sym133__ = dims(y)[(2 - 1)]; + n_occasions = lcm_sym133__; + current_statement__ = 70; + validate_non_negative_index("qgamma", "n_occasions", lcm_sym133__); + Eigen::Matrix qgamma; + qgamma = Eigen::Matrix(lcm_sym133__); + + assign(lcm_sym91__, nil_index_list(), subtract(1.0, gamma), + "assigning variable lcm_sym91__"); + current_statement__ = 113; + if (logical_gte(lcm_sym132__, 1)) { + current_statement__ = 71; + validate_non_negative_index("qp", "n_occasions", lcm_sym133__); + Eigen::Matrix qp; + qp = Eigen::Matrix(lcm_sym133__); + + assign(lcm_sym93__, nil_index_list(), + subtract(1.0, + transpose( + rvalue(p, cons_list(index_uni(1), nil_index_list()), "p"))), + "assigning variable lcm_sym93__"); + lcm_sym129__ = first[(1 - 1)]; + if (lcm_sym129__) { + current_statement__ = 83; + if (logical_eq(lcm_sym129__, 1)) { + current_statement__ = 90; + lp_accum__.add( + bernoulli_log(1, + (gamma[(1 - 1)] * + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "p")))); + } else { + current_statement__ = 77; + validate_non_negative_index("lp", "first[(i - 1)]", lcm_sym129__); + Eigen::Matrix lp; + lp = Eigen::Matrix(lcm_sym129__); + + current_statement__ = 77; + if (logical_gte(lcm_sym129__, 1)) { + lcm_sym127__ = std::numeric_limits::quiet_NaN(); + assign(lp, cons_list(index_uni(1), nil_index_list()), + lcm_sym127__, "assigning variable lp"); + for (size_t sym1__ = 2; sym1__ <= lcm_sym129__; ++sym1__) { + current_statement__ = 77; + assign(lp, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym127__, "assigning variable lp");} + } + lcm_sym95__ = (lcm_sym129__ - 1); + assign(lp, cons_list(index_uni(1), nil_index_list()), + (((bernoulli_lpmf(1, gamma[(1 - 1)]) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym93__, + cons_list(index_min_max(1, lcm_sym95__), + nil_index_list()), "lcm_sym93__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_min_max(1, lcm_sym95__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym129__), nil_index_list())), + "p"))), "assigning variable lp"); + current_statement__ = 112; + if (logical_gte(lcm_sym95__, 2)) { + current_statement__ = 78; + assign(lp, cons_list(index_uni(2), nil_index_list()), + ((((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym91__, + cons_list(index_min_max(1, 1), nil_index_list()), + "lcm_sym91__"))) + + bernoulli_lpmf(1, gamma[(2 - 1)])) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym93__, + cons_list(index_min_max(2, lcm_sym95__), + nil_index_list()), "lcm_sym93__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_min_max(2, lcm_sym95__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym129__), nil_index_list())), + "p"))), "assigning variable lp"); + for (size_t t = 3; t <= lcm_sym95__; ++t) { + current_statement__ = 78; + assign(lp, cons_list(index_uni(t), nil_index_list()), + ((((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym91__, + cons_list(index_min_max(1, (t - 1)), + nil_index_list()), "lcm_sym91__"))) + + bernoulli_lpmf(1, gamma[(t - 1)])) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym93__, + cons_list(index_min_max(t, lcm_sym95__), + nil_index_list()), "lcm_sym93__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_min_max(t, lcm_sym95__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym129__), + nil_index_list())), "p"))), + "assigning variable lp");} + } + current_statement__ = 79; + assign(lp, cons_list(index_uni(lcm_sym129__), nil_index_list()), + ((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym91__, + cons_list(index_min_max(1, lcm_sym95__), + nil_index_list()), "lcm_sym91__"))) + + bernoulli_lpmf(1, gamma[(lcm_sym129__ - 1)])) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym129__), nil_index_list())), + "p"))), "assigning variable lp"); + current_statement__ = 80; + lp_accum__.add(log_sum_exp(lp)); + } + lcm_sym131__ = last[(1 - 1)]; + if (logical_gte(lcm_sym131__, (lcm_sym129__ + 1))) { + current_statement__ = 84; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(((lcm_sym129__ + 1) - 1)), + nil_index_list())), "phi"))); + lcm_sym111__ = ((lcm_sym129__ + 1) + 1); + lp_accum__.add( + bernoulli_log(y[(1 - 1)][((lcm_sym129__ + 1) - 1)], + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym129__ + 1)), + nil_index_list())), "p"))); + for (size_t t = lcm_sym111__; t <= lcm_sym131__; ++t) { + current_statement__ = 84; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni((t - 1)), nil_index_list())), + "phi"))); + current_statement__ = 85; + lp_accum__.add( + bernoulli_log(y[(1 - 1)][(t - 1)], + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), "p")));} + } + current_statement__ = 87; + lp_accum__.add( + bernoulli_log(1, + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym131__), nil_index_list())), + "chi"))); + } else { + lcm_sym112__ = (lcm_sym133__ + 1); + validate_non_negative_index("lp", "(n_occasions + 1)", lcm_sym112__); + Eigen::Matrix lp; + lp = Eigen::Matrix(lcm_sym112__); + + current_statement__ = 72; + if (logical_gte(lcm_sym112__, 1)) { + lcm_sym127__ = std::numeric_limits::quiet_NaN(); + assign(lp, cons_list(index_uni(1), nil_index_list()), + lcm_sym127__, "assigning variable lp"); + for (size_t sym1__ = 2; sym1__ <= lcm_sym112__; ++sym1__) { + current_statement__ = 72; + assign(lp, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym127__, "assigning variable lp");} + } + current_statement__ = 89; + assign(lp, cons_list(index_uni(1), nil_index_list()), + ((bernoulli_lpmf(1, gamma[(1 - 1)]) + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "p"))) + + bernoulli_lpmf(1, + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "chi"))), + "assigning variable lp"); + current_statement__ = 111; + if (logical_gte(lcm_sym133__, 2)) { + current_statement__ = 73; + assign(lp, cons_list(index_uni(2), nil_index_list()), + (((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym91__, + cons_list(index_min_max(1, 1), nil_index_list()), + "lcm_sym91__"))) + + bernoulli_lpmf(1, gamma[(2 - 1)])) + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), "p"))) + + bernoulli_lpmf(1, + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), "chi"))), + "assigning variable lp"); + for (size_t t = 3; t <= lcm_sym133__; ++t) { + current_statement__ = 73; + assign(lp, cons_list(index_uni(t), nil_index_list()), + (((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym91__, + cons_list(index_min_max(1, (t - 1)), + nil_index_list()), "lcm_sym91__"))) + + bernoulli_lpmf(1, gamma[(t - 1)])) + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), "p"))) + + bernoulli_lpmf(1, + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), "chi"))), + "assigning variable lp");} + } + current_statement__ = 74; + assign(lp, cons_list(index_uni(lcm_sym112__), nil_index_list()), + bernoulli_lpmf(1, prod(lcm_sym91__)), + "assigning variable lp"); + current_statement__ = 75; + lp_accum__.add(log_sum_exp(lp)); + } + for (size_t i = 2; i <= lcm_sym132__; ++i) { + current_statement__ = 71; + validate_non_negative_index("qp", "n_occasions", lcm_sym133__); + Eigen::Matrix qp; + qp = Eigen::Matrix(lcm_sym133__); + + assign(lcm_sym92__, nil_index_list(), + subtract(1.0, + transpose( + rvalue(p, cons_list(index_uni(i), nil_index_list()), "p"))), + "assigning variable lcm_sym92__"); + lcm_sym128__ = first[(i - 1)]; + if (lcm_sym128__) { + current_statement__ = 83; + if (logical_eq(lcm_sym128__, 1)) { + current_statement__ = 90; + lp_accum__.add( + bernoulli_log(1, + (gamma[(1 - 1)] * + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), "p")))); + } else { + current_statement__ = 77; + validate_non_negative_index("lp", "first[(i - 1)]", + lcm_sym128__); + Eigen::Matrix lp; + lp = Eigen::Matrix(lcm_sym128__); + + current_statement__ = 77; + if (logical_gte(lcm_sym128__, 1)) { + lcm_sym127__ = std::numeric_limits::quiet_NaN(); + assign(lp, cons_list(index_uni(1), nil_index_list()), + lcm_sym127__, "assigning variable lp"); + for (size_t sym1__ = 2; sym1__ <= lcm_sym128__; ++sym1__) { + current_statement__ = 77; + assign(lp, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym127__, "assigning variable lp");} + } + lcm_sym94__ = (lcm_sym128__ - 1); + assign(lp, cons_list(index_uni(1), nil_index_list()), + (((bernoulli_lpmf(1, gamma[(1 - 1)]) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym92__, + cons_list(index_min_max(1, lcm_sym94__), + nil_index_list()), "lcm_sym92__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_min_max(1, lcm_sym94__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym128__), nil_index_list())), + "p"))), "assigning variable lp"); + current_statement__ = 112; + if (logical_gte(lcm_sym94__, 2)) { + current_statement__ = 78; + assign(lp, cons_list(index_uni(2), nil_index_list()), + ((((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym91__, + cons_list(index_min_max(1, 1), nil_index_list()), + "lcm_sym91__"))) + + bernoulli_lpmf(1, gamma[(2 - 1)])) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym92__, + cons_list(index_min_max(2, lcm_sym94__), + nil_index_list()), "lcm_sym92__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_min_max(2, lcm_sym94__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym128__), + nil_index_list())), "p"))), + "assigning variable lp"); + for (size_t t = 3; t <= lcm_sym94__; ++t) { + current_statement__ = 78; + assign(lp, cons_list(index_uni(t), nil_index_list()), + ((((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym91__, + cons_list(index_min_max(1, (t - 1)), + nil_index_list()), "lcm_sym91__"))) + + bernoulli_lpmf(1, gamma[(t - 1)])) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym92__, + cons_list(index_min_max(t, lcm_sym94__), + nil_index_list()), "lcm_sym92__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_min_max(t, lcm_sym94__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym128__), + nil_index_list())), "p"))), + "assigning variable lp");} + } + current_statement__ = 79; + assign(lp, + cons_list(index_uni(lcm_sym128__), nil_index_list()), + ((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym91__, + cons_list(index_min_max(1, lcm_sym94__), + nil_index_list()), "lcm_sym91__"))) + + bernoulli_lpmf(1, gamma[(lcm_sym128__ - 1)])) + + bernoulli_lpmf(1, + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym128__), nil_index_list())), + "p"))), "assigning variable lp"); + current_statement__ = 80; + lp_accum__.add(log_sum_exp(lp)); + } + lcm_sym130__ = last[(i - 1)]; + if (logical_gte(lcm_sym130__, (lcm_sym128__ + 1))) { + current_statement__ = 84; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(((lcm_sym128__ + 1) - 1)), + nil_index_list())), "phi"))); + lcm_sym110__ = ((lcm_sym128__ + 1) + 1); + lp_accum__.add( + bernoulli_log(y[(i - 1)][((lcm_sym128__ + 1) - 1)], + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym128__ + 1)), + nil_index_list())), "p"))); + for (size_t t = lcm_sym110__; t <= lcm_sym130__; ++t) { + current_statement__ = 84; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni((t - 1)), nil_index_list())), + "phi"))); + current_statement__ = 85; + lp_accum__.add( + bernoulli_log(y[(i - 1)][(t - 1)], + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), "p")));} + } + current_statement__ = 87; + lp_accum__.add( + bernoulli_log(1, + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym130__), nil_index_list())), + "chi"))); + } else { + lcm_sym112__ = (lcm_sym133__ + 1); + validate_non_negative_index("lp", "(n_occasions + 1)", + lcm_sym112__); + Eigen::Matrix lp; + lp = Eigen::Matrix(lcm_sym112__); + + current_statement__ = 72; + if (logical_gte(lcm_sym112__, 1)) { + lcm_sym127__ = std::numeric_limits::quiet_NaN(); + assign(lp, cons_list(index_uni(1), nil_index_list()), + lcm_sym127__, "assigning variable lp"); + for (size_t sym1__ = 2; sym1__ <= lcm_sym112__; ++sym1__) { + current_statement__ = 72; + assign(lp, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym127__, "assigning variable lp");} + } + current_statement__ = 89; + assign(lp, cons_list(index_uni(1), nil_index_list()), + ((bernoulli_lpmf(1, gamma[(1 - 1)]) + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), "p"))) + + bernoulli_lpmf(1, + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), "chi"))), + "assigning variable lp"); + current_statement__ = 111; + if (logical_gte(lcm_sym133__, 2)) { + current_statement__ = 73; + assign(lp, cons_list(index_uni(2), nil_index_list()), + (((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym91__, + cons_list(index_min_max(1, 1), nil_index_list()), + "lcm_sym91__"))) + + bernoulli_lpmf(1, gamma[(2 - 1)])) + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(2), nil_index_list())), "p"))) + + bernoulli_lpmf(1, + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(2), nil_index_list())), "chi"))), + "assigning variable lp"); + for (size_t t = 3; t <= lcm_sym133__; ++t) { + current_statement__ = 73; + assign(lp, cons_list(index_uni(t), nil_index_list()), + (((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym91__, + cons_list(index_min_max(1, (t - 1)), + nil_index_list()), "lcm_sym91__"))) + + bernoulli_lpmf(1, gamma[(t - 1)])) + + bernoulli_lpmf(0, + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), "p"))) + + + bernoulli_lpmf(1, + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), "chi"))), + "assigning variable lp");} + } + current_statement__ = 74; + assign(lp, cons_list(index_uni(lcm_sym112__), nil_index_list()), + bernoulli_lpmf(1, prod(lcm_sym91__)), + "assigning variable lp"); + current_statement__ = 75; + lp_accum__.add(log_sum_exp(lp)); + }} + } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct jolly_seber_lp_functor__ { +template +void +operator()(const std::vector>& y, + const std::vector& first, const std::vector& last, + const Eigen::Matrix& p, + const Eigen::Matrix& phi, + const Eigen::Matrix& gamma, + const Eigen::Matrix& chi, T_lp__& lp__, + T_lp_accum__& lp_accum__, std::ostream* pstream__) const +{ +return jolly_seber_lp(y, first, last, p, phi, gamma, chi, lp__, lp_accum__, + pstream__); +} +}; + +template +Eigen::Matrix::type, -1, 1> +seq_cprob(const Eigen::Matrix& gamma, std::ostream* pstream__) { + using local_scalar_t__ = typename boost::math::tools::promote_args::type; + const static bool propto__ = true; + (void) propto__; + + try { + double lcm_sym141__; + int lcm_sym140__; + Eigen::Matrix lcm_sym139__; + double lcm_sym138__; + double lcm_sym137__; + double lcm_sym136__; + double lcm_sym135__; + int lcm_sym134__; + { + int N; + + lcm_sym140__ = rows(gamma); + N = lcm_sym140__; + current_statement__ = 40; + validate_non_negative_index("log_cprob", "N", lcm_sym140__); + Eigen::Matrix log_cprob; + log_cprob = Eigen::Matrix(lcm_sym140__); + + lcm_sym134__ = logical_gte(lcm_sym140__, 1); + if (lcm_sym134__) { + lcm_sym141__ = std::numeric_limits::quiet_NaN(); + assign(log_cprob, cons_list(index_uni(1), nil_index_list()), + lcm_sym141__, "assigning variable log_cprob"); + for (size_t sym1__ = 2; sym1__ <= lcm_sym140__; ++sym1__) { + current_statement__ = 40; + assign(log_cprob, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym141__, "assigning variable log_cprob");} + } + local_scalar_t__ log_residual_prob; + + current_statement__ = 115; + if (lcm_sym134__) { + current_statement__ = 43; + assign(log_cprob, cons_list(index_uni(1), nil_index_list()), + (stan::math::log(gamma[(1 - 1)]) + 0), + "assigning variable log_cprob"); + current_statement__ = 42; + log_residual_prob = (0 + log1m(gamma[(1 - 1)])); + for (size_t n = 2; n <= lcm_sym140__; ++n) { + current_statement__ = 43; + assign(log_cprob, cons_list(index_uni(n), nil_index_list()), + (stan::math::log(gamma[(n - 1)]) + log_residual_prob), + "assigning variable log_cprob"); + current_statement__ = 42; + log_residual_prob = (log_residual_prob + log1m(gamma[(n - 1)]));} + } + current_statement__ = 116; + return stan::math::exp(log_cprob); + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct seq_cprob_functor__ { +template +Eigen::Matrix::type, -1, 1> +operator()(const Eigen::Matrix& gamma, std::ostream* pstream__) const +{ +return seq_cprob(gamma, pstream__); +} +}; + +class inlining_fail2_model : public model_base_crtp { + + private: + int lcm_sym343__; + int lcm_sym342__; + int lcm_sym341__; + int lcm_sym340__; + int lcm_sym339__; + int lcm_sym338__; + int lcm_sym337__; + int lcm_sym336__; + int lcm_sym335__; + int lcm_sym334__; + int lcm_sym333__; + int lcm_sym332__; + int lcm_sym331__; + int lcm_sym330__; + int lcm_sym329__; + int lcm_sym328__; + int lcm_sym327__; + int lcm_sym326__; + int lcm_sym325__; + int lcm_sym324__; + int lcm_sym323__; + int lcm_sym322__; + int lcm_sym321__; + int pos__; + int M; + int n_occasions; + std::vector> y; + std::vector first; + std::vector last; + + public: + ~inlining_fail2_model() { } + + std::string model_name() const { return "inlining_fail2_model"; } + + inlining_fail2_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "inlining_fail2_model_namespace::inlining_fail2_model"; + (void) function__; // suppress unused var warning + + try { + + + + + + + + + + + + + + + + + + + + + + + + + pos__ = 1; + context__.validate_dims("data initialization","M","int", + context__.to_vec()); + + current_statement__ = 92; + M = context__.vals_i("M")[(1 - 1)]; + context__.validate_dims("data initialization","n_occasions","int", + context__.to_vec()); + + current_statement__ = 93; + n_occasions = context__.vals_i("n_occasions")[(1 - 1)]; + current_statement__ = 94; + validate_non_negative_index("y", "M", M); + current_statement__ = 94; + validate_non_negative_index("y", "n_occasions", n_occasions); + context__.validate_dims("data initialization","y","int", + context__.to_vec(M, n_occasions)); + y = std::vector>(M, std::vector(n_occasions, 0)); + + { + std::vector y_flat__; + current_statement__ = 94; + assign(y_flat__, nil_index_list(), context__.vals_i("y"), + "assigning variable y_flat__"); + current_statement__ = 94; + pos__ = 1; + lcm_sym322__ = logical_gte(n_occasions, 1); + if (lcm_sym322__) { + { + lcm_sym321__ = logical_gte(M, 1); + if (lcm_sym321__) { + current_statement__ = 94; + assign(y, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + y_flat__[(1 - 1)], "assigning variable y"); + current_statement__ = 94; + pos__ = 2; + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + current_statement__ = 94; + assign(y, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 94; + pos__ = (pos__ + 1);} + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 94; + if (lcm_sym321__) { + current_statement__ = 94; + assign(y, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 94; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + current_statement__ = 94; + assign(y, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 94; + pos__ = (pos__ + 1);} + } } + } + } else { + lcm_sym321__ = logical_gte(M, 1); + } + } + current_statement__ = 95; + validate_non_negative_index("first", "M", M); + first = std::vector(M, 0); + + current_statement__ = 96; + validate_non_negative_index("last", "M", M); + last = std::vector(M, 0); + + current_statement__ = 98; + if (lcm_sym321__) { + int inline_sym47__; + int inline_sym49__; + + inline_sym49__ = 0; + for (size_t inline_sym50__ = 1; inline_sym50__ <= 1; ++inline_sym50__) { + lcm_sym329__ = size(y[(1 - 1)]); + for (size_t inline_sym48__ = 1; inline_sym48__ <= lcm_sym329__; + ++inline_sym48__) { + current_statement__ = 51; + if (y[(1 - 1)][(inline_sym48__ - 1)]) { + inline_sym49__ = 1; + inline_sym47__ = inline_sym48__; + break; + } } + if (inline_sym49__) { + break; + } + inline_sym49__ = 1; + inline_sym47__ = 0; + break;} + assign(first, cons_list(index_uni(1), nil_index_list()), + inline_sym47__, "assigning variable first"); + for (size_t i = 2; i <= M; ++i) { + int inline_sym47__; + int inline_sym49__; + + inline_sym49__ = 0; + for (size_t inline_sym50__ = 1; inline_sym50__ <= 1; + ++inline_sym50__) { + lcm_sym328__ = size(y[(i - 1)]); + for (size_t inline_sym48__ = 1; inline_sym48__ <= lcm_sym328__; + ++inline_sym48__) { + current_statement__ = 51; + if (y[(i - 1)][(inline_sym48__ - 1)]) { + inline_sym49__ = 1; + inline_sym47__ = inline_sym48__; + break; + } } + if (inline_sym49__) { + break; + } + inline_sym49__ = 1; + inline_sym47__ = 0; + break;} + assign(first, cons_list(index_uni(i), nil_index_list()), + inline_sym47__, "assigning variable first");} + } + current_statement__ = 105; + if (lcm_sym321__) { + int inline_sym51__; + int inline_sym54__; + + inline_sym54__ = 0; + for (size_t inline_sym55__ = 1; inline_sym55__ <= 1; ++inline_sym55__) { + lcm_sym329__ = size(y[(1 - 1)]); + lcm_sym326__ = (lcm_sym329__ - 1); + for (size_t inline_sym53__ = 0; inline_sym53__ <= lcm_sym326__; + ++inline_sym53__) { + int inline_sym52__; + + lcm_sym325__ = (lcm_sym329__ - inline_sym53__); + inline_sym52__ = lcm_sym325__; + current_statement__ = 101; + if (y[(1 - 1)][(lcm_sym325__ - 1)]) { + inline_sym54__ = 1; + inline_sym51__ = lcm_sym325__; + break; + } } + if (inline_sym54__) { + break; + } + inline_sym54__ = 1; + inline_sym51__ = 0; + break;} + assign(last, cons_list(index_uni(1), nil_index_list()), + inline_sym51__, "assigning variable last"); + for (size_t i = 2; i <= M; ++i) { + int inline_sym51__; + int inline_sym54__; + + inline_sym54__ = 0; + for (size_t inline_sym55__ = 1; inline_sym55__ <= 1; + ++inline_sym55__) { + lcm_sym328__ = size(y[(i - 1)]); + lcm_sym324__ = (lcm_sym328__ - 1); + for (size_t inline_sym53__ = 0; inline_sym53__ <= lcm_sym324__; + ++inline_sym53__) { + int inline_sym52__; + + lcm_sym323__ = (lcm_sym328__ - inline_sym53__); + inline_sym52__ = lcm_sym323__; + current_statement__ = 101; + if (y[(i - 1)][(lcm_sym323__ - 1)]) { + inline_sym54__ = 1; + inline_sym51__ = lcm_sym323__; + break; + } } + if (inline_sym54__) { + break; + } + inline_sym54__ = 1; + inline_sym51__ = 0; + break;} + assign(last, cons_list(index_uni(i), nil_index_list()), + inline_sym51__, "assigning variable last");} + } + current_statement__ = 92; + current_statement__ = 92; + check_greater_or_equal(function__, "M", M, 0); + current_statement__ = 93; + current_statement__ = 93; + check_greater_or_equal(function__, "n_occasions", n_occasions, 0); + current_statement__ = 94; + if (lcm_sym321__) { + current_statement__ = 94; + if (lcm_sym322__) { + current_statement__ = 94; + current_statement__ = 94; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 94; + current_statement__ = 94; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(sym2__ - 1)], 0);} + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 94; + if (lcm_sym322__) { + current_statement__ = 94; + current_statement__ = 94; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 94; + current_statement__ = 94; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(sym2__ - 1)], 0);} + } } + } + current_statement__ = 94; + if (lcm_sym321__) { + current_statement__ = 94; + if (lcm_sym322__) { + current_statement__ = 94; + current_statement__ = 94; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 94; + current_statement__ = 94; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(sym2__ - 1)], 1);} + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 94; + if (lcm_sym322__) { + current_statement__ = 94; + current_statement__ = 94; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 94; + current_statement__ = 94; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(sym2__ - 1)], 1);} + } } + } + current_statement__ = 95; + if (lcm_sym321__) { + current_statement__ = 95; + current_statement__ = 95; + check_greater_or_equal(function__, "first[sym1__]", first[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 95; + current_statement__ = 95; + check_greater_or_equal(function__, "first[sym1__]", + first[(sym1__ - 1)], 0);} + } + current_statement__ = 95; + if (lcm_sym321__) { + current_statement__ = 95; + current_statement__ = 95; + check_less_or_equal(function__, "first[sym1__]", first[(1 - 1)], + n_occasions); + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 95; + current_statement__ = 95; + check_less_or_equal(function__, "first[sym1__]", + first[(sym1__ - 1)], n_occasions);} + } + current_statement__ = 96; + if (lcm_sym321__) { + current_statement__ = 96; + current_statement__ = 96; + check_greater_or_equal(function__, "last[sym1__]", last[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 96; + current_statement__ = 96; + check_greater_or_equal(function__, "last[sym1__]", + last[(sym1__ - 1)], 0);} + } + current_statement__ = 96; + if (lcm_sym321__) { + current_statement__ = 96; + current_statement__ = 96; + check_less_or_equal(function__, "last[sym1__]", last[(1 - 1)], + n_occasions); + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 96; + current_statement__ = 96; + check_less_or_equal(function__, "last[sym1__]", last[(sym1__ - 1)], + n_occasions);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + num_params_r__ += 1; + num_params_r__ += 1; + current_statement__ = 3; + validate_non_negative_index("gamma", "n_occasions", n_occasions); + num_params_r__ += n_occasions; + current_statement__ = 4; + validate_non_negative_index("epsilon", "(n_occasions - 1)", + (n_occasions - 1)); + num_params_r__ += (n_occasions - 1); + num_params_r__ += 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "inlining_fail2_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + int lcm_sym320__; + int lcm_sym319__; + int lcm_sym318__; + int lcm_sym317__; + local_scalar_t__ lcm_sym312__; + double lcm_sym310__; + int lcm_sym316__; + int lcm_sym315__; + double lcm_sym313__; + int lcm_sym308__; + Eigen::Matrix lcm_sym307__; + double lcm_sym306__; + double lcm_sym305__; + local_scalar_t__ lcm_sym304__; + local_scalar_t__ lcm_sym303__; + double lcm_sym302__; + double lcm_sym301__; + int lcm_sym300__; + double lcm_sym299__; + double lcm_sym298__; + double lcm_sym297__; + double lcm_sym296__; + double lcm_sym295__; + double lcm_sym294__; + double lcm_sym293__; + double lcm_sym292__; + double lcm_sym291__; + double lcm_sym290__; + double lcm_sym289__; + double lcm_sym288__; + double lcm_sym287__; + int lcm_sym286__; + int lcm_sym285__; + int lcm_sym284__; + double lcm_sym283__; + double lcm_sym282__; + double lcm_sym281__; + double lcm_sym280__; + double lcm_sym279__; + double lcm_sym278__; + double lcm_sym277__; + double lcm_sym276__; + double lcm_sym275__; + double lcm_sym274__; + double lcm_sym273__; + double lcm_sym272__; + double lcm_sym271__; + double lcm_sym270__; + int lcm_sym269__; + int lcm_sym268__; + int lcm_sym267__; + int lcm_sym266__; + int lcm_sym265__; + int lcm_sym264__; + Eigen::Matrix lcm_sym263__; + Eigen::Matrix lcm_sym262__; + Eigen::Matrix lcm_sym261__; + int lcm_sym314__; + int lcm_sym259__; + int lcm_sym258__; + int lcm_sym257__; + int lcm_sym256__; + int lcm_sym255__; + int lcm_sym254__; + int lcm_sym253__; + int lcm_sym252__; + int lcm_sym251__; + int lcm_sym250__; + int lcm_sym249__; + int lcm_sym248__; + int lcm_sym247__; + int lcm_sym246__; + int lcm_sym245__; + int lcm_sym244__; + local_scalar_t__ mean_phi; + + current_statement__ = 1; + mean_phi = in__.scalar(); + current_statement__ = 1; + if (jacobian__) { + current_statement__ = 1; + mean_phi = stan::math::lub_constrain(mean_phi, 0, 1, lp__); + } else { + current_statement__ = 1; + mean_phi = stan::math::lub_constrain(mean_phi, 0, 1); + } + local_scalar_t__ mean_p; + + current_statement__ = 2; + mean_p = in__.scalar(); + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + mean_p = stan::math::lub_constrain(mean_p, 0, 1, lp__); + } else { + current_statement__ = 2; + mean_p = stan::math::lub_constrain(mean_p, 0, 1); + } + current_statement__ = 3; + validate_non_negative_index("gamma", "n_occasions", n_occasions); + Eigen::Matrix gamma; + gamma = Eigen::Matrix(n_occasions); + + current_statement__ = 3; + gamma = in__.vector(n_occasions); + lcm_sym247__ = logical_gte(n_occasions, 1); + if (lcm_sym247__) { + current_statement__ = 3; + if (jacobian__) { + current_statement__ = 3; + assign(gamma, cons_list(index_uni(1), nil_index_list()), + stan::math::lub_constrain(gamma[(1 - 1)], 0, 1, lp__), + "assigning variable gamma"); + } else { + current_statement__ = 3; + assign(gamma, cons_list(index_uni(1), nil_index_list()), + stan::math::lub_constrain(gamma[(1 - 1)], 0, 1), + "assigning variable gamma"); + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 3; + if (jacobian__) { + current_statement__ = 3; + assign(gamma, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(gamma[(sym1__ - 1)], 0, 1, lp__), + "assigning variable gamma"); + } else { + current_statement__ = 3; + assign(gamma, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(gamma[(sym1__ - 1)], 0, 1), + "assigning variable gamma"); + }} + } + lcm_sym314__ = (n_occasions - 1); + validate_non_negative_index("epsilon", "(n_occasions - 1)", + lcm_sym314__); + Eigen::Matrix epsilon; + epsilon = Eigen::Matrix(lcm_sym314__); + + current_statement__ = 4; + epsilon = in__.vector(lcm_sym314__); + local_scalar_t__ sigma; + + current_statement__ = 5; + sigma = in__.scalar(); + current_statement__ = 5; + if (jacobian__) { + current_statement__ = 5; + sigma = stan::math::lub_constrain(sigma, 0, 5, lp__); + } else { + current_statement__ = 5; + sigma = stan::math::lub_constrain(sigma, 0, 5); + } + current_statement__ = 6; + validate_non_negative_index("phi", "M", M); + current_statement__ = 6; + validate_non_negative_index("phi", "(n_occasions - 1)", lcm_sym314__); + Eigen::Matrix phi; + phi = Eigen::Matrix(M, lcm_sym314__); + + lcm_sym246__ = logical_gte(M, 1); + if (lcm_sym246__) { + { + lcm_sym248__ = logical_gte(lcm_sym314__, 1); + if (lcm_sym248__) { + lcm_sym313__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym313__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym314__; ++sym2__) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym313__, "assigning variable phi");} + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 6; + if (lcm_sym248__) { + lcm_sym313__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym313__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym314__; ++sym2__) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym313__, "assigning variable phi");} + } } + } + } else { + lcm_sym248__ = logical_gte(lcm_sym314__, 1); + } + current_statement__ = 7; + validate_non_negative_index("p", "M", M); + current_statement__ = 7; + validate_non_negative_index("p", "n_occasions", n_occasions); + Eigen::Matrix p; + p = Eigen::Matrix(M, n_occasions); + + current_statement__ = 7; + if (lcm_sym246__) { + current_statement__ = 7; + if (lcm_sym247__) { + lcm_sym313__ = std::numeric_limits::quiet_NaN(); + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym313__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 7; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym313__, "assigning variable p");} + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 7; + if (lcm_sym247__) { + lcm_sym313__ = std::numeric_limits::quiet_NaN(); + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym313__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 7; + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym313__, "assigning variable p");} + } } + } + current_statement__ = 8; + validate_non_negative_index("chi", "M", M); + current_statement__ = 8; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix chi; + chi = Eigen::Matrix(M, n_occasions); + + current_statement__ = 8; + if (lcm_sym246__) { + current_statement__ = 8; + if (lcm_sym247__) { + lcm_sym313__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym313__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 8; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym313__, "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 8; + if (lcm_sym247__) { + lcm_sym313__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym313__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 8; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym313__, "assigning variable chi");} + } } + } + current_statement__ = 11; + if (lcm_sym248__) { + current_statement__ = 10; + if (lcm_sym246__) { + lcm_sym304__ = inv_logit((logit(mean_phi) + epsilon[(1 - 1)])); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym304__, + "assigning variable phi"); + for (size_t i = 2; i <= M; ++i) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), lcm_sym304__, + "assigning variable phi");} + } + for (size_t t = 2; t <= lcm_sym314__; ++t) { + current_statement__ = 10; + if (lcm_sym246__) { + lcm_sym303__ = inv_logit((logit(mean_phi) + epsilon[(t - 1)])); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), lcm_sym303__, + "assigning variable phi"); + for (size_t i = 2; i <= M; ++i) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), lcm_sym303__, + "assigning variable phi");} + } } + } + assign(lcm_sym307__, nil_index_list(), + rep_matrix(mean_p, M, n_occasions), "assigning variable lcm_sym307__"); + assign(p, nil_index_list(), lcm_sym307__, "assigning variable p"); + Eigen::Matrix inline_sym25__; + int inline_sym35__; + + inline_sym35__ = 0; + for (size_t inline_sym36__ = 1; inline_sym36__ <= 1; ++inline_sym36__) { + int inline_sym26__; + + lcm_sym308__ = rows(lcm_sym307__); + int inline_sym27__; + + lcm_sym300__ = cols(lcm_sym307__); + current_statement__ = 14; + validate_non_negative_index("chi", "n_ind", lcm_sym308__); + current_statement__ = 14; + validate_non_negative_index("chi", "n_occasions", lcm_sym300__); + Eigen::Matrix inline_sym28__; + inline_sym28__ = Eigen::Matrix(lcm_sym308__, lcm_sym300__); + + for (size_t inline_sym30__ = 1; inline_sym30__ <= lcm_sym308__; + ++inline_sym30__) { + if (logical_gte(lcm_sym300__, 1)) { + lcm_sym313__ = std::numeric_limits::quiet_NaN(); + assign(inline_sym28__, + cons_list(index_uni(inline_sym30__), + cons_list(index_uni(1), nil_index_list())), lcm_sym313__, + "assigning variable inline_sym28__"); + for (size_t inline_sym29__ = 2; inline_sym29__ <= lcm_sym300__; + ++inline_sym29__) { + current_statement__ = 14; + assign(inline_sym28__, + cons_list(index_uni(inline_sym30__), + cons_list(index_uni(inline_sym29__), nil_index_list())), + lcm_sym313__, "assigning variable inline_sym28__");} + } + if (inline_sym35__) { + break; + } } + if (inline_sym35__) { + break; + } + for (size_t inline_sym34__ = 1; inline_sym34__ <= lcm_sym308__; + ++inline_sym34__) { + current_statement__ = 15; + assign(inline_sym28__, + cons_list(index_uni(inline_sym34__), + cons_list(index_uni(lcm_sym300__), nil_index_list())), 1.0, + "assigning variable inline_sym28__"); + lcm_sym265__ = (lcm_sym300__ - 1); + if (logical_gte(lcm_sym265__, 1)) { + int inline_sym31__; + + int inline_sym32__; + + lcm_sym269__ = (lcm_sym265__ + 1); + current_statement__ = 18; + assign(inline_sym28__, + cons_list(index_uni(inline_sym34__), + cons_list(index_uni(lcm_sym265__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym34__), + cons_list(index_uni(lcm_sym265__), nil_index_list())), + "phi") * + (1 - + rvalue(lcm_sym307__, + cons_list(index_uni(inline_sym34__), + cons_list(index_uni(lcm_sym269__), nil_index_list())), + "lcm_sym307__"))), + rvalue(inline_sym28__, + cons_list(index_uni(inline_sym34__), + cons_list(index_uni(lcm_sym269__), nil_index_list())), + "inline_sym28__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym34__), + cons_list(index_uni(lcm_sym265__), nil_index_list())), + "phi"))), "assigning variable inline_sym28__"); + for (size_t inline_sym33__ = 2; inline_sym33__ <= lcm_sym265__; + ++inline_sym33__) { + int inline_sym31__; + + lcm_sym264__ = (lcm_sym300__ - inline_sym33__); + int inline_sym32__; + + lcm_sym268__ = (lcm_sym264__ + 1); + current_statement__ = 18; + assign(inline_sym28__, + cons_list(index_uni(inline_sym34__), + cons_list(index_uni(lcm_sym264__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym34__), + cons_list(index_uni(lcm_sym264__), nil_index_list())), + "phi") * + (1 - + rvalue(lcm_sym307__, + cons_list(index_uni(inline_sym34__), + cons_list(index_uni(lcm_sym268__), + nil_index_list())), "lcm_sym307__"))), + rvalue(inline_sym28__, + cons_list(index_uni(inline_sym34__), + cons_list(index_uni(lcm_sym268__), nil_index_list())), + "inline_sym28__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym34__), + cons_list(index_uni(lcm_sym264__), nil_index_list())), + "phi"))), "assigning variable inline_sym28__");} + } + if (inline_sym35__) { + break; + } } + if (inline_sym35__) { + break; + } + inline_sym35__ = 1; + assign(inline_sym25__, nil_index_list(), inline_sym28__, + "assigning variable inline_sym25__"); + break;} + assign(chi, nil_index_list(), inline_sym25__, "assigning variable chi"); + current_statement__ = 6; + current_statement__ = 6; + check_greater_or_equal(function__, "phi", phi, 0); + current_statement__ = 6; + current_statement__ = 6; + check_less_or_equal(function__, "phi", phi, 1); + current_statement__ = 7; + current_statement__ = 7; + check_greater_or_equal(function__, "p", lcm_sym307__, 0); + current_statement__ = 7; + current_statement__ = 7; + check_less_or_equal(function__, "p", lcm_sym307__, 1); + current_statement__ = 8; + current_statement__ = 8; + check_greater_or_equal(function__, "chi", inline_sym25__, 0); + current_statement__ = 8; + current_statement__ = 8; + check_less_or_equal(function__, "chi", inline_sym25__, 1); + { + current_statement__ = 67; + lp_accum__.add(normal_log(epsilon, 0, sigma)); + int inline_sym45__; + + { + int inline_sym37__; + + lcm_sym319__ = dims(y)[(1 - 1)]; + int inline_sym38__; + + lcm_sym320__ = dims(y)[(2 - 1)]; + current_statement__ = 70; + validate_non_negative_index("qgamma", "n_occasions", lcm_sym320__); + Eigen::Matrix inline_sym39__; + inline_sym39__ = Eigen::Matrix(lcm_sym320__); + + assign(lcm_sym261__, nil_index_list(), subtract(1.0, gamma), + "assigning variable lcm_sym261__"); + lcm_sym258__ = logical_gte(lcm_sym319__, 1); + if (lcm_sym258__) { + current_statement__ = 71; + validate_non_negative_index("qp", "n_occasions", lcm_sym320__); + Eigen::Matrix inline_sym41__; + inline_sym41__ = Eigen::Matrix(lcm_sym320__); + + assign(lcm_sym263__, nil_index_list(), + subtract(1.0, + transpose( + rvalue(lcm_sym307__, + cons_list(index_uni(1), nil_index_list()), + "lcm_sym307__"))), "assigning variable lcm_sym263__"); + lcm_sym316__ = first[(1 - 1)]; + if (lcm_sym316__) { + current_statement__ = 83; + if (logical_eq(lcm_sym316__, 1)) { + lcm_sym312__ = gamma[(1 - 1)]; + lp_accum__.add( + bernoulli_log(1, + (lcm_sym312__ * + rvalue(lcm_sym307__, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + "lcm_sym307__")))); + } else { + current_statement__ = 77; + validate_non_negative_index("lp", "first[(i - 1)]", + lcm_sym316__); + Eigen::Matrix inline_sym42__; + inline_sym42__ = Eigen::Matrix(lcm_sym316__); + + if (logical_gte(lcm_sym316__, 1)) { + lcm_sym313__ = std::numeric_limits::quiet_NaN(); + assign(inline_sym42__, + cons_list(index_uni(1), nil_index_list()), lcm_sym313__, + "assigning variable inline_sym42__"); + for (size_t inline_sym40__ = 2; + inline_sym40__ <= lcm_sym316__; ++inline_sym40__) { + current_statement__ = 77; + assign(inline_sym42__, + cons_list(index_uni(inline_sym40__), nil_index_list()), + lcm_sym313__, "assigning variable inline_sym42__");} + } + lcm_sym312__ = gamma[(1 - 1)]; + lcm_sym267__ = (lcm_sym316__ - 1); + assign(inline_sym42__, + cons_list(index_uni(1), nil_index_list()), + (((bernoulli_lpmf(1, lcm_sym312__) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym263__, + cons_list(index_min_max(1, lcm_sym267__), + nil_index_list()), "lcm_sym263__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_min_max(1, lcm_sym267__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(lcm_sym307__, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym316__), + nil_index_list())), "lcm_sym307__"))), + "assigning variable inline_sym42__"); + if (logical_gte(lcm_sym267__, 2)) { + current_statement__ = 78; + assign(inline_sym42__, + cons_list(index_uni(2), nil_index_list()), + ((((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym261__, + cons_list(index_min_max(1, 1), + nil_index_list()), "lcm_sym261__"))) + + bernoulli_lpmf(1, gamma[(2 - 1)])) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym263__, + cons_list(index_min_max(2, lcm_sym267__), + nil_index_list()), "lcm_sym263__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_min_max(2, lcm_sym267__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(lcm_sym307__, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym316__), + nil_index_list())), "lcm_sym307__"))), + "assigning variable inline_sym42__"); + for (size_t inline_sym43__ = 3; + inline_sym43__ <= lcm_sym267__; ++inline_sym43__) { + current_statement__ = 78; + assign(inline_sym42__, + cons_list(index_uni(inline_sym43__), nil_index_list()), + ((((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym261__, + cons_list( + index_min_max(1, (inline_sym43__ - 1)), + nil_index_list()), "lcm_sym261__"))) + + bernoulli_lpmf(1, + gamma[(inline_sym43__ - 1)])) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym263__, + cons_list( + index_min_max(inline_sym43__, lcm_sym267__), + nil_index_list()), "lcm_sym263__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(1), + cons_list( + index_min_max(inline_sym43__, lcm_sym267__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(lcm_sym307__, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym316__), + nil_index_list())), "lcm_sym307__"))), + "assigning variable inline_sym42__");} + } + current_statement__ = 79; + assign(inline_sym42__, + cons_list(index_uni(lcm_sym316__), nil_index_list()), + ((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym261__, + cons_list(index_min_max(1, lcm_sym267__), + nil_index_list()), "lcm_sym261__"))) + + bernoulli_lpmf(1, gamma[(lcm_sym316__ - 1)])) + + bernoulli_lpmf(1, + rvalue(lcm_sym307__, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym316__), + nil_index_list())), "lcm_sym307__"))), + "assigning variable inline_sym42__"); + current_statement__ = 80; + lp_accum__.add(log_sum_exp(inline_sym42__)); + } + lcm_sym318__ = last[(1 - 1)]; + if (logical_gte(lcm_sym318__, (lcm_sym316__ + 1))) { + current_statement__ = 84; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(((lcm_sym316__ + 1) - 1)), + nil_index_list())), "phi"))); + lcm_sym285__ = ((lcm_sym316__ + 1) + 1); + lp_accum__.add( + bernoulli_log( + y[(1 - 1)][((lcm_sym316__ + 1) - 1)], + rvalue(lcm_sym307__, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym316__ + 1)), + nil_index_list())), "lcm_sym307__"))); + for (size_t inline_sym43__ = lcm_sym285__; + inline_sym43__ <= lcm_sym318__; ++inline_sym43__) { + current_statement__ = 84; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni((inline_sym43__ - 1)), + nil_index_list())), "phi"))); + current_statement__ = 85; + lp_accum__.add( + bernoulli_log(y[(1 - 1)][(inline_sym43__ - 1)], + rvalue(lcm_sym307__, + cons_list(index_uni(1), + cons_list(index_uni(inline_sym43__), + nil_index_list())), "lcm_sym307__")));} + } + current_statement__ = 87; + lp_accum__.add( + bernoulli_log(1, + rvalue(inline_sym25__, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym318__), nil_index_list())), + "inline_sym25__"))); + } else { + lcm_sym286__ = (lcm_sym320__ + 1); + validate_non_negative_index("lp", "(n_occasions + 1)", + lcm_sym286__); + Eigen::Matrix inline_sym42__; + inline_sym42__ = Eigen::Matrix(lcm_sym286__); + + if (logical_gte(lcm_sym286__, 1)) { + lcm_sym313__ = std::numeric_limits::quiet_NaN(); + assign(inline_sym42__, + cons_list(index_uni(1), nil_index_list()), lcm_sym313__, + "assigning variable inline_sym42__"); + for (size_t inline_sym40__ = 2; + inline_sym40__ <= lcm_sym286__; ++inline_sym40__) { + current_statement__ = 72; + assign(inline_sym42__, + cons_list(index_uni(inline_sym40__), nil_index_list()), + lcm_sym313__, "assigning variable inline_sym42__");} + } + lcm_sym312__ = gamma[(1 - 1)]; + assign(inline_sym42__, + cons_list(index_uni(1), nil_index_list()), + ((bernoulli_lpmf(1, lcm_sym312__) + + bernoulli_lpmf(0, + rvalue(lcm_sym307__, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + "lcm_sym307__"))) + + bernoulli_lpmf(1, + rvalue(inline_sym25__, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + "inline_sym25__"))), + "assigning variable inline_sym42__"); + if (logical_gte(lcm_sym320__, 2)) { + current_statement__ = 73; + assign(inline_sym42__, + cons_list(index_uni(2), nil_index_list()), + (((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym261__, + cons_list(index_min_max(1, 1), nil_index_list()), + "lcm_sym261__"))) + + bernoulli_lpmf(1, gamma[(2 - 1)])) + + bernoulli_lpmf(0, + rvalue(lcm_sym307__, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), + "lcm_sym307__"))) + + bernoulli_lpmf(1, + rvalue(inline_sym25__, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), + "inline_sym25__"))), + "assigning variable inline_sym42__"); + for (size_t inline_sym43__ = 3; + inline_sym43__ <= lcm_sym320__; ++inline_sym43__) { + current_statement__ = 73; + assign(inline_sym42__, + cons_list(index_uni(inline_sym43__), nil_index_list()), + (((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym261__, + cons_list( + index_min_max(1, (inline_sym43__ - 1)), + nil_index_list()), "lcm_sym261__"))) + + bernoulli_lpmf(1, gamma[(inline_sym43__ - 1)])) + + + bernoulli_lpmf(0, + rvalue(lcm_sym307__, + cons_list(index_uni(1), + cons_list(index_uni(inline_sym43__), + nil_index_list())), "lcm_sym307__"))) + + bernoulli_lpmf(1, + rvalue(inline_sym25__, + cons_list(index_uni(1), + cons_list(index_uni(inline_sym43__), + nil_index_list())), "inline_sym25__"))), + "assigning variable inline_sym42__");} + } + current_statement__ = 74; + assign(inline_sym42__, + cons_list(index_uni(lcm_sym286__), nil_index_list()), + bernoulli_lpmf(1, prod(lcm_sym261__)), + "assigning variable inline_sym42__"); + current_statement__ = 75; + lp_accum__.add(log_sum_exp(inline_sym42__)); + } + for (size_t inline_sym44__ = 2; inline_sym44__ <= lcm_sym319__; + ++inline_sym44__) { + current_statement__ = 71; + validate_non_negative_index("qp", "n_occasions", lcm_sym320__); + Eigen::Matrix inline_sym41__; + inline_sym41__ = Eigen::Matrix(lcm_sym320__); + + assign(lcm_sym262__, nil_index_list(), + subtract(1.0, + transpose( + rvalue(lcm_sym307__, + cons_list(index_uni(inline_sym44__), nil_index_list()), + "lcm_sym307__"))), "assigning variable lcm_sym262__"); + lcm_sym315__ = first[(inline_sym44__ - 1)]; + if (lcm_sym315__) { + current_statement__ = 83; + if (logical_eq(lcm_sym315__, 1)) { + current_statement__ = 90; + lp_accum__.add( + bernoulli_log(1, + (lcm_sym312__ * + rvalue(lcm_sym307__, + cons_list(index_uni(inline_sym44__), + cons_list(index_uni(1), nil_index_list())), + "lcm_sym307__")))); + } else { + current_statement__ = 77; + validate_non_negative_index("lp", "first[(i - 1)]", + lcm_sym315__); + Eigen::Matrix inline_sym42__; + inline_sym42__ = Eigen::Matrix(lcm_sym315__); + + if (logical_gte(lcm_sym315__, 1)) { + lcm_sym313__ = std::numeric_limits::quiet_NaN(); + assign(inline_sym42__, + cons_list(index_uni(1), nil_index_list()), + lcm_sym313__, "assigning variable inline_sym42__"); + for (size_t inline_sym40__ = 2; + inline_sym40__ <= lcm_sym315__; ++inline_sym40__) { + current_statement__ = 77; + assign(inline_sym42__, + cons_list(index_uni(inline_sym40__), + nil_index_list()), lcm_sym313__, + "assigning variable inline_sym42__");} + } + lcm_sym266__ = (lcm_sym315__ - 1); + assign(inline_sym42__, + cons_list(index_uni(1), nil_index_list()), + (((bernoulli_lpmf(1, lcm_sym312__) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym262__, + cons_list(index_min_max(1, lcm_sym266__), + nil_index_list()), "lcm_sym262__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(inline_sym44__), + cons_list(index_min_max(1, lcm_sym266__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(lcm_sym307__, + cons_list(index_uni(inline_sym44__), + cons_list(index_uni(lcm_sym315__), + nil_index_list())), "lcm_sym307__"))), + "assigning variable inline_sym42__"); + if (logical_gte(lcm_sym266__, 2)) { + current_statement__ = 78; + assign(inline_sym42__, + cons_list(index_uni(2), nil_index_list()), + ((((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym261__, + cons_list(index_min_max(1, 1), + nil_index_list()), "lcm_sym261__"))) + + bernoulli_lpmf(1, gamma[(2 - 1)])) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym262__, + cons_list(index_min_max(2, lcm_sym266__), + nil_index_list()), "lcm_sym262__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(inline_sym44__), + cons_list(index_min_max(2, lcm_sym266__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(lcm_sym307__, + cons_list(index_uni(inline_sym44__), + cons_list(index_uni(lcm_sym315__), + nil_index_list())), "lcm_sym307__"))), + "assigning variable inline_sym42__"); + for (size_t inline_sym43__ = 3; + inline_sym43__ <= lcm_sym266__; ++inline_sym43__) { + current_statement__ = 78; + assign(inline_sym42__, + cons_list(index_uni(inline_sym43__), + nil_index_list()), + ((((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym261__, + cons_list( + index_min_max(1, (inline_sym43__ - 1)), + nil_index_list()), "lcm_sym261__"))) + + bernoulli_lpmf(1, + gamma[(inline_sym43__ - 1)])) + + bernoulli_lpmf(1, + prod( + rvalue(lcm_sym262__, + cons_list( + index_min_max(inline_sym43__, lcm_sym266__), + nil_index_list()), "lcm_sym262__")))) + + bernoulli_lpmf(1, + prod( + rvalue(phi, + cons_list(index_uni(inline_sym44__), + cons_list( + index_min_max(inline_sym43__, lcm_sym266__), + nil_index_list())), "phi")))) + + bernoulli_lpmf(1, + rvalue(lcm_sym307__, + cons_list(index_uni(inline_sym44__), + cons_list(index_uni(lcm_sym315__), + nil_index_list())), "lcm_sym307__"))), + "assigning variable inline_sym42__");} + } + current_statement__ = 79; + assign(inline_sym42__, + cons_list(index_uni(lcm_sym315__), nil_index_list()), + ((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym261__, + cons_list(index_min_max(1, lcm_sym266__), + nil_index_list()), "lcm_sym261__"))) + + bernoulli_lpmf(1, gamma[(lcm_sym315__ - 1)])) + + bernoulli_lpmf(1, + rvalue(lcm_sym307__, + cons_list(index_uni(inline_sym44__), + cons_list(index_uni(lcm_sym315__), + nil_index_list())), "lcm_sym307__"))), + "assigning variable inline_sym42__"); + current_statement__ = 80; + lp_accum__.add(log_sum_exp(inline_sym42__)); + } + lcm_sym317__ = last[(inline_sym44__ - 1)]; + if (logical_gte(lcm_sym317__, (lcm_sym315__ + 1))) { + current_statement__ = 84; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(inline_sym44__), + cons_list(index_uni(((lcm_sym315__ + 1) - 1)), + nil_index_list())), "phi"))); + lcm_sym284__ = ((lcm_sym315__ + 1) + 1); + lp_accum__.add( + bernoulli_log( + y[(inline_sym44__ - 1)][((lcm_sym315__ + 1) - 1)], + rvalue(lcm_sym307__, + cons_list(index_uni(inline_sym44__), + cons_list(index_uni((lcm_sym315__ + 1)), + nil_index_list())), "lcm_sym307__"))); + for (size_t inline_sym43__ = lcm_sym284__; + inline_sym43__ <= lcm_sym317__; ++inline_sym43__) { + current_statement__ = 84; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(inline_sym44__), + cons_list(index_uni((inline_sym43__ - 1)), + nil_index_list())), "phi"))); + current_statement__ = 85; + lp_accum__.add( + bernoulli_log( + y[(inline_sym44__ - 1)][(inline_sym43__ - 1)], + rvalue(lcm_sym307__, + cons_list(index_uni(inline_sym44__), + cons_list(index_uni(inline_sym43__), + nil_index_list())), "lcm_sym307__")));} + } + current_statement__ = 87; + lp_accum__.add( + bernoulli_log(1, + rvalue(inline_sym25__, + cons_list(index_uni(inline_sym44__), + cons_list(index_uni(lcm_sym317__), nil_index_list())), + "inline_sym25__"))); + } else { + lcm_sym286__ = (lcm_sym320__ + 1); + validate_non_negative_index("lp", "(n_occasions + 1)", + lcm_sym286__); + Eigen::Matrix inline_sym42__; + inline_sym42__ = Eigen::Matrix(lcm_sym286__); + + if (logical_gte(lcm_sym286__, 1)) { + lcm_sym313__ = std::numeric_limits::quiet_NaN(); + assign(inline_sym42__, + cons_list(index_uni(1), nil_index_list()), lcm_sym313__, + "assigning variable inline_sym42__"); + for (size_t inline_sym40__ = 2; + inline_sym40__ <= lcm_sym286__; ++inline_sym40__) { + current_statement__ = 72; + assign(inline_sym42__, + cons_list(index_uni(inline_sym40__), nil_index_list()), + lcm_sym313__, "assigning variable inline_sym42__");} + } + current_statement__ = 89; + assign(inline_sym42__, + cons_list(index_uni(1), nil_index_list()), + ((bernoulli_lpmf(1, lcm_sym312__) + + bernoulli_lpmf(0, + rvalue(lcm_sym307__, + cons_list(index_uni(inline_sym44__), + cons_list(index_uni(1), nil_index_list())), + "lcm_sym307__"))) + + bernoulli_lpmf(1, + rvalue(inline_sym25__, + cons_list(index_uni(inline_sym44__), + cons_list(index_uni(1), nil_index_list())), + "inline_sym25__"))), + "assigning variable inline_sym42__"); + if (logical_gte(lcm_sym320__, 2)) { + current_statement__ = 73; + assign(inline_sym42__, + cons_list(index_uni(2), nil_index_list()), + (((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym261__, + cons_list(index_min_max(1, 1), nil_index_list()), + "lcm_sym261__"))) + + bernoulli_lpmf(1, gamma[(2 - 1)])) + + bernoulli_lpmf(0, + rvalue(lcm_sym307__, + cons_list(index_uni(inline_sym44__), + cons_list(index_uni(2), nil_index_list())), + "lcm_sym307__"))) + + bernoulli_lpmf(1, + rvalue(inline_sym25__, + cons_list(index_uni(inline_sym44__), + cons_list(index_uni(2), nil_index_list())), + "inline_sym25__"))), + "assigning variable inline_sym42__"); + for (size_t inline_sym43__ = 3; + inline_sym43__ <= lcm_sym320__; ++inline_sym43__) { + current_statement__ = 73; + assign(inline_sym42__, + cons_list(index_uni(inline_sym43__), nil_index_list()), + (((bernoulli_lpmf(1, + prod( + rvalue(lcm_sym261__, + cons_list( + index_min_max(1, (inline_sym43__ - 1)), + nil_index_list()), "lcm_sym261__"))) + + bernoulli_lpmf(1, + gamma[(inline_sym43__ - 1)])) + + bernoulli_lpmf(0, + rvalue(lcm_sym307__, + cons_list(index_uni(inline_sym44__), + cons_list(index_uni(inline_sym43__), + nil_index_list())), "lcm_sym307__"))) + + bernoulli_lpmf(1, + rvalue(inline_sym25__, + cons_list(index_uni(inline_sym44__), + cons_list(index_uni(inline_sym43__), + nil_index_list())), "inline_sym25__"))), + "assigning variable inline_sym42__");} + } + current_statement__ = 74; + assign(inline_sym42__, + cons_list(index_uni(lcm_sym286__), nil_index_list()), + bernoulli_lpmf(1, prod(lcm_sym261__)), + "assigning variable inline_sym42__"); + current_statement__ = 75; + lp_accum__.add(log_sum_exp(inline_sym42__)); + }} + } + } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "inlining_fail2_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + int lcm_sym243__; + int lcm_sym242__; + double lcm_sym241__; + double lcm_sym240__; + double lcm_sym239__; + double lcm_sym238__; + double lcm_sym237__; + double lcm_sym236__; + int lcm_sym235__; + int lcm_sym234__; + int lcm_sym233__; + int lcm_sym232__; + double lcm_sym231__; + double lcm_sym230__; + double lcm_sym229__; + double lcm_sym228__; + double lcm_sym227__; + double lcm_sym226__; + double lcm_sym225__; + double lcm_sym224__; + local_scalar_t__ lcm_sym186__; + double lcm_sym223__; + double lcm_sym222__; + double lcm_sym221__; + double lcm_sym220__; + int lcm_sym219__; + int lcm_sym218__; + int lcm_sym217__; + int lcm_sym216__; + double lcm_sym214__; + int lcm_sym211__; + int lcm_sym210__; + int lcm_sym209__; + int lcm_sym208__; + int lcm_sym207__; + int lcm_sym206__; + local_scalar_t__ lcm_sym205__; + int lcm_sym204__; + double lcm_sym203__; + int lcm_sym202__; + int lcm_sym201__; + int lcm_sym200__; + int lcm_sym199__; + Eigen::Matrix lcm_sym198__; + std::vector> lcm_sym197__; + local_scalar_t__ lcm_sym196__; + local_scalar_t__ lcm_sym195__; + local_scalar_t__ lcm_sym194__; + local_scalar_t__ lcm_sym193__; + local_scalar_t__ lcm_sym192__; + local_scalar_t__ lcm_sym191__; + double lcm_sym190__; + double lcm_sym189__; + Eigen::Matrix lcm_sym188__; + int lcm_sym187__; + int lcm_sym181__; + int lcm_sym180__; + int lcm_sym179__; + int lcm_sym178__; + double lcm_sym177__; + double lcm_sym176__; + int lcm_sym175__; + int lcm_sym174__; + double lcm_sym173__; + double lcm_sym172__; + int lcm_sym171__; + int lcm_sym170__; + int lcm_sym169__; + int lcm_sym168__; + int lcm_sym167__; + int lcm_sym166__; + int lcm_sym215__; + int lcm_sym164__; + int lcm_sym163__; + int lcm_sym162__; + int lcm_sym161__; + int lcm_sym160__; + int lcm_sym159__; + int lcm_sym158__; + int lcm_sym157__; + Eigen::Matrix lcm_sym156__; + double mean_phi; + + current_statement__ = 1; + mean_phi = in__.scalar(); + current_statement__ = 1; + mean_phi = stan::math::lub_constrain(mean_phi, 0, 1); + double mean_p; + + current_statement__ = 2; + mean_p = in__.scalar(); + current_statement__ = 2; + mean_p = stan::math::lub_constrain(mean_p, 0, 1); + current_statement__ = 3; + validate_non_negative_index("gamma", "n_occasions", n_occasions); + Eigen::Matrix gamma; + gamma = Eigen::Matrix(n_occasions); + + current_statement__ = 3; + gamma = in__.vector(n_occasions); + lcm_sym158__ = logical_gte(n_occasions, 1); + if (lcm_sym158__) { + current_statement__ = 3; + assign(gamma, cons_list(index_uni(1), nil_index_list()), + stan::math::lub_constrain(gamma[(1 - 1)], 0, 1), + "assigning variable gamma"); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 3; + assign(gamma, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(gamma[(sym1__ - 1)], 0, 1), + "assigning variable gamma");} + } + lcm_sym215__ = (n_occasions - 1); + validate_non_negative_index("epsilon", "(n_occasions - 1)", + lcm_sym215__); + Eigen::Matrix epsilon; + epsilon = Eigen::Matrix(lcm_sym215__); + + current_statement__ = 4; + epsilon = in__.vector(lcm_sym215__); + double sigma; + + current_statement__ = 5; + sigma = in__.scalar(); + current_statement__ = 5; + sigma = stan::math::lub_constrain(sigma, 0, 5); + current_statement__ = 6; + validate_non_negative_index("phi", "M", M); + current_statement__ = 6; + validate_non_negative_index("phi", "(n_occasions - 1)", lcm_sym215__); + Eigen::Matrix phi; + phi = Eigen::Matrix(M, lcm_sym215__); + + lcm_sym157__ = logical_gte(M, 1); + if (lcm_sym157__) { + { + lcm_sym160__ = logical_gte(lcm_sym215__, 1); + if (lcm_sym160__) { + { + lcm_sym214__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym214__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym215__; ++sym2__) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym214__, "assigning variable phi");} + } + } else { + lcm_sym214__ = std::numeric_limits::quiet_NaN(); + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 6; + if (lcm_sym160__) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym214__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym215__; ++sym2__) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym214__, "assigning variable phi");} + } } + } + } else { + lcm_sym214__ = std::numeric_limits::quiet_NaN(); + lcm_sym160__ = logical_gte(lcm_sym215__, 1); + } + current_statement__ = 7; + validate_non_negative_index("p", "M", M); + current_statement__ = 7; + validate_non_negative_index("p", "n_occasions", n_occasions); + Eigen::Matrix p; + p = Eigen::Matrix(M, n_occasions); + + current_statement__ = 7; + if (lcm_sym157__) { + current_statement__ = 7; + if (lcm_sym158__) { + current_statement__ = 7; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym214__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 7; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym214__, "assigning variable p");} + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 7; + if (lcm_sym158__) { + current_statement__ = 7; + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym214__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 7; + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym214__, "assigning variable p");} + } } + } + current_statement__ = 8; + validate_non_negative_index("chi", "M", M); + current_statement__ = 8; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix chi; + chi = Eigen::Matrix(M, n_occasions); + + current_statement__ = 8; + if (lcm_sym157__) { + current_statement__ = 8; + if (lcm_sym158__) { + current_statement__ = 8; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym214__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 8; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym214__, "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= M; ++sym1__) { + current_statement__ = 8; + if (lcm_sym158__) { + current_statement__ = 8; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym214__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 8; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym214__, "assigning variable chi");} + } } + } + vars__.push_back(mean_phi); + vars__.push_back(mean_p); + if (lcm_sym158__) { + vars__.push_back(gamma[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + vars__.push_back(gamma[(sym1__ - 1)]);} + } + if (lcm_sym160__) { + vars__.push_back(epsilon[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= lcm_sym215__; ++sym1__) { + vars__.push_back(epsilon[(sym1__ - 1)]);} + } + vars__.push_back(sigma); + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + current_statement__ = 11; + if (lcm_sym160__) { + current_statement__ = 10; + if (lcm_sym157__) { + lcm_sym196__ = inv_logit((logit(mean_phi) + epsilon[(1 - 1)])); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym196__, + "assigning variable phi"); + for (size_t i = 2; i <= M; ++i) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), lcm_sym196__, + "assigning variable phi");} + } + for (size_t t = 2; t <= lcm_sym215__; ++t) { + current_statement__ = 10; + if (lcm_sym157__) { + lcm_sym195__ = inv_logit((logit(mean_phi) + epsilon[(t - 1)])); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), lcm_sym195__, + "assigning variable phi"); + for (size_t i = 2; i <= M; ++i) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), lcm_sym195__, + "assigning variable phi");} + } } + } + assign(lcm_sym198__, nil_index_list(), + rep_matrix(mean_p, M, n_occasions), "assigning variable lcm_sym198__"); + assign(p, nil_index_list(), lcm_sym198__, "assigning variable p"); + Eigen::Matrix inline_sym1__; + int inline_sym11__; + + inline_sym11__ = 0; + for (size_t inline_sym12__ = 1; inline_sym12__ <= 1; ++inline_sym12__) { + int inline_sym2__; + + lcm_sym200__ = rows(lcm_sym198__); + int inline_sym3__; + + lcm_sym187__ = cols(lcm_sym198__); + current_statement__ = 14; + validate_non_negative_index("chi", "n_ind", lcm_sym200__); + current_statement__ = 14; + validate_non_negative_index("chi", "n_occasions", lcm_sym187__); + Eigen::Matrix inline_sym4__; + inline_sym4__ = Eigen::Matrix(lcm_sym200__, lcm_sym187__); + + for (size_t inline_sym6__ = 1; inline_sym6__ <= lcm_sym200__; + ++inline_sym6__) { + if (logical_gte(lcm_sym187__, 1)) { + current_statement__ = 14; + assign(inline_sym4__, + cons_list(index_uni(inline_sym6__), + cons_list(index_uni(1), nil_index_list())), lcm_sym214__, + "assigning variable inline_sym4__"); + for (size_t inline_sym5__ = 2; inline_sym5__ <= lcm_sym187__; + ++inline_sym5__) { + current_statement__ = 14; + assign(inline_sym4__, + cons_list(index_uni(inline_sym6__), + cons_list(index_uni(inline_sym5__), nil_index_list())), + lcm_sym214__, "assigning variable inline_sym4__");} + } + if (inline_sym11__) { + break; + } } + if (inline_sym11__) { + break; + } + for (size_t inline_sym10__ = 1; inline_sym10__ <= lcm_sym200__; + ++inline_sym10__) { + current_statement__ = 15; + assign(inline_sym4__, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym187__), nil_index_list())), 1.0, + "assigning variable inline_sym4__"); + lcm_sym169__ = (lcm_sym187__ - 1); + if (logical_gte(lcm_sym169__, 1)) { + int inline_sym7__; + + int inline_sym8__; + + lcm_sym175__ = (lcm_sym169__ + 1); + current_statement__ = 18; + assign(inline_sym4__, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym169__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym169__), nil_index_list())), + "phi") * + (1 - + rvalue(lcm_sym198__, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym175__), nil_index_list())), + "lcm_sym198__"))), + rvalue(inline_sym4__, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym175__), nil_index_list())), + "inline_sym4__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym169__), nil_index_list())), + "phi"))), "assigning variable inline_sym4__"); + for (size_t inline_sym9__ = 2; inline_sym9__ <= lcm_sym169__; + ++inline_sym9__) { + int inline_sym7__; + + lcm_sym168__ = (lcm_sym187__ - inline_sym9__); + int inline_sym8__; + + lcm_sym174__ = (lcm_sym168__ + 1); + current_statement__ = 18; + assign(inline_sym4__, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym168__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym168__), nil_index_list())), + "phi") * + (1 - + rvalue(lcm_sym198__, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym174__), + nil_index_list())), "lcm_sym198__"))), + rvalue(inline_sym4__, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym174__), nil_index_list())), + "inline_sym4__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym10__), + cons_list(index_uni(lcm_sym168__), nil_index_list())), + "phi"))), "assigning variable inline_sym4__");} + } + if (inline_sym11__) { + break; + } } + if (inline_sym11__) { + break; + } + inline_sym11__ = 1; + assign(inline_sym1__, nil_index_list(), inline_sym4__, + "assigning variable inline_sym1__"); + break;} + assign(chi, nil_index_list(), inline_sym1__, "assigning variable chi"); + if (lcm_sym160__) { + if (lcm_sym157__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "phi")); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), "phi"));} + } + for (size_t sym1__ = 2; sym1__ <= lcm_sym215__; ++sym1__) { + if (lcm_sym157__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), "phi")); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "phi")); + } + } } + } + if (lcm_sym158__) { + if (lcm_sym157__) { + vars__.push_back( + rvalue(lcm_sym198__, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "lcm_sym198__")); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + vars__.push_back( + rvalue(lcm_sym198__, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), "lcm_sym198__")); + } + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + if (lcm_sym157__) { + vars__.push_back( + rvalue(lcm_sym198__, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + "lcm_sym198__")); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + vars__.push_back( + rvalue(lcm_sym198__, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "lcm_sym198__"));} + } } + } + if (lcm_sym158__) { + if (lcm_sym157__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "inline_sym1__")); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + "inline_sym1__"));} + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + if (lcm_sym157__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + "inline_sym1__")); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "inline_sym1__"));} + } } + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + double sigma2; + + current_statement__ = 22; + sigma2 = lcm_sym214__; + local_scalar_t__ psi; + + current_statement__ = 23; + psi = lcm_sym214__; + current_statement__ = 24; + validate_non_negative_index("b", "n_occasions", n_occasions); + Eigen::Matrix b; + b = Eigen::Matrix(n_occasions); + + current_statement__ = 24; + if (lcm_sym158__) { + current_statement__ = 24; + assign(b, cons_list(index_uni(1), nil_index_list()), lcm_sym214__, + "assigning variable b"); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 24; + assign(b, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym214__, "assigning variable b");} + } + int Nsuper; + + current_statement__ = 26; + validate_non_negative_index("N", "n_occasions", n_occasions); + std::vector N; + N = std::vector(n_occasions, 0); + + current_statement__ = 27; + validate_non_negative_index("B", "n_occasions", n_occasions); + std::vector B; + B = std::vector(n_occasions, 0); + + current_statement__ = 28; + validate_non_negative_index("z", "M", M); + current_statement__ = 28; + validate_non_negative_index("z", "n_occasions", n_occasions); + std::vector> z; + z = std::vector>(M, std::vector(n_occasions, 0)); + + current_statement__ = 37; + if (lcm_sym157__) { + int q; + + double mu2; + + lcm_sym186__ = gamma[(1 - 1)]; + assign(z, + cons_list(index_uni(1), cons_list(index_uni(1), nil_index_list())), + bernoulli_rng(lcm_sym186__, base_rng__), "assigning variable z"); + lcm_sym159__ = logical_gte(n_occasions, 2); + if (lcm_sym159__) { + lcm_sym235__ = z[(1 - 1)][(1 - 1)]; + lcm_sym181__ = (1 * (1 - lcm_sym235__)); + q = lcm_sym181__; + lcm_sym193__ = stan::math::fma( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + "phi"), lcm_sym235__, + (gamma[(2 - 1)] * lcm_sym181__)); + current_statement__ = 31; + assign(z, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), + bernoulli_rng(lcm_sym193__, base_rng__), "assigning variable z"); + for (size_t t = 3; t <= n_occasions; ++t) { + current_statement__ = 32; + q = (q * (1 - z[(1 - 1)][((t - 1) - 1)])); + lcm_sym194__ = stan::math::fma( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni((t - 1)), + nil_index_list())), "phi"), + z[(1 - 1)][((t - 1) - 1)], (gamma[(t - 1)] * q)); + current_statement__ = 31; + assign(z, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), + bernoulli_rng(lcm_sym194__, base_rng__), "assigning variable z"); + } + } + for (size_t i = 2; i <= M; ++i) { + int q; + + double mu2; + + current_statement__ = 34; + assign(z, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), + bernoulli_rng(lcm_sym186__, base_rng__), "assigning variable z"); + current_statement__ = 35; + if (lcm_sym159__) { + lcm_sym180__ = (1 * (1 - z[(i - 1)][(1 - 1)])); + q = lcm_sym180__; + lcm_sym191__ = stan::math::fma( + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), + "phi"), z[(i - 1)][(1 - 1)], + (gamma[(2 - 1)] * lcm_sym180__)); + current_statement__ = 31; + assign(z, + cons_list(index_uni(i), + cons_list(index_uni(2), nil_index_list())), + bernoulli_rng(lcm_sym191__, base_rng__), "assigning variable z"); + for (size_t t = 3; t <= n_occasions; ++t) { + current_statement__ = 32; + q = (q * (1 - z[(i - 1)][((t - 1) - 1)])); + lcm_sym192__ = stan::math::fma( + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni((t - 1)), + nil_index_list())), "phi"), + z[(i - 1)][((t - 1) - 1)], + (gamma[(t - 1)] * q)); + current_statement__ = 31; + assign(z, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), + bernoulli_rng(lcm_sym192__, base_rng__), + "assigning variable z");} + } } + } + { + current_statement__ = 38; + validate_non_negative_index("cprob", "n_occasions", n_occasions); + Eigen::Matrix cprob; + cprob = Eigen::Matrix(n_occasions); + + Eigen::Matrix inline_sym13__; + int inline_sym19__; + + inline_sym19__ = 0; + for (size_t inline_sym20__ = 1; inline_sym20__ <= 1; ++inline_sym20__) { + int inline_sym14__; + + lcm_sym199__ = rows(gamma); + current_statement__ = 40; + validate_non_negative_index("log_cprob", "N", lcm_sym199__); + Eigen::Matrix inline_sym15__; + inline_sym15__ = Eigen::Matrix(lcm_sym199__); + + lcm_sym163__ = logical_gte(lcm_sym199__, 1); + if (lcm_sym163__) { + current_statement__ = 40; + assign(inline_sym15__, cons_list(index_uni(1), nil_index_list()), + lcm_sym214__, "assigning variable inline_sym15__"); + for (size_t inline_sym16__ = 2; inline_sym16__ <= lcm_sym199__; + ++inline_sym16__) { + current_statement__ = 40; + assign(inline_sym15__, + cons_list(index_uni(inline_sym16__), nil_index_list()), + lcm_sym214__, "assigning variable inline_sym15__");} + } + if (inline_sym19__) { + break; + } + local_scalar_t__ inline_sym17__; + + if (lcm_sym163__) { + lcm_sym186__ = gamma[(1 - 1)]; + assign(inline_sym15__, cons_list(index_uni(1), nil_index_list()), + (stan::math::log(lcm_sym186__) + 0), + "assigning variable inline_sym15__"); + current_statement__ = 42; + inline_sym17__ = (0 + log1m(lcm_sym186__)); + for (size_t inline_sym18__ = 2; inline_sym18__ <= lcm_sym199__; + ++inline_sym18__) { + current_statement__ = 43; + assign(inline_sym15__, + cons_list(index_uni(inline_sym18__), nil_index_list()), + (stan::math::log(gamma[(inline_sym18__ - 1)]) + + inline_sym17__), "assigning variable inline_sym15__"); + current_statement__ = 42; + inline_sym17__ = (inline_sym17__ + + log1m(gamma[(inline_sym18__ - 1)]));} + } + if (inline_sym19__) { + break; + } + inline_sym19__ = 1; + assign(inline_sym13__, nil_index_list(), + stan::math::exp(inline_sym15__), + "assigning variable inline_sym13__"); + break;} + current_statement__ = 46; + validate_non_negative_index("recruit", "M", M); + current_statement__ = 46; + validate_non_negative_index("recruit", "n_occasions", n_occasions); + std::vector> recruit; + recruit = std::vector>(M, std::vector(n_occasions, 0)); + + current_statement__ = 46; + assign(recruit, nil_index_list(), rep_array(0, M, n_occasions), + "assigning variable recruit"); + current_statement__ = 47; + validate_non_negative_index("Nind", "M", M); + std::vector Nind; + Nind = std::vector(M, 0); + + current_statement__ = 48; + validate_non_negative_index("Nalive", "M", M); + std::vector Nalive; + Nalive = std::vector(M, 0); + + lcm_sym203__ = square(sigma); + sigma2 = lcm_sym203__; + lcm_sym205__ = sum(inline_sym13__); + psi = lcm_sym205__; + assign(lcm_sym156__, nil_index_list(), + divide(inline_sym13__, lcm_sym205__), + "assigning variable lcm_sym156__"); + assign(b, nil_index_list(), lcm_sym156__, "assigning variable b"); + current_statement__ = 56; + if (lcm_sym157__) { + int f; + + int inline_sym21__; + int inline_sym23__; + + inline_sym23__ = 0; + for (size_t inline_sym24__ = 1; inline_sym24__ <= 1; + ++inline_sym24__) { + lcm_sym202__ = size(z[(1 - 1)]); + for (size_t inline_sym22__ = 1; inline_sym22__ <= lcm_sym202__; + ++inline_sym22__) { + current_statement__ = 51; + if (z[(1 - 1)][(inline_sym22__ - 1)]) { + inline_sym23__ = 1; + inline_sym21__ = inline_sym22__; + break; + } } + if (inline_sym23__) { + break; + } + inline_sym23__ = 1; + inline_sym21__ = 0; + break;} + current_statement__ = 54; + if (logical_gt(inline_sym21__, 0)) { + current_statement__ = 53; + assign(recruit, + cons_list(index_uni(1), + cons_list(index_uni(inline_sym21__), nil_index_list())), 1, + "assigning variable recruit"); + } + for (size_t i = 2; i <= M; ++i) { + int f; + + int inline_sym21__; + int inline_sym23__; + + inline_sym23__ = 0; + for (size_t inline_sym24__ = 1; inline_sym24__ <= 1; + ++inline_sym24__) { + lcm_sym201__ = size(z[(i - 1)]); + for (size_t inline_sym22__ = 1; inline_sym22__ <= lcm_sym201__; + ++inline_sym22__) { + current_statement__ = 51; + if (z[(i - 1)][(inline_sym22__ - 1)]) { + inline_sym23__ = 1; + inline_sym21__ = inline_sym22__; + break; + } } + if (inline_sym23__) { + break; + } + inline_sym23__ = 1; + inline_sym21__ = 0; + break;} + current_statement__ = 54; + if (logical_gt(inline_sym21__, 0)) { + current_statement__ = 53; + assign(recruit, + cons_list(index_uni(i), + cons_list(index_uni(inline_sym21__), nil_index_list())), 1, + "assigning variable recruit"); + } } + } + current_statement__ = 60; + if (lcm_sym158__) { + current_statement__ = 57; + assign(N, cons_list(index_uni(1), nil_index_list()), + sum( + rvalue(z, + cons_list(index_omni(), + cons_list(index_uni(1), nil_index_list())), "z")), + "assigning variable N"); + current_statement__ = 58; + assign(B, cons_list(index_uni(1), nil_index_list()), + sum( + rvalue(recruit, + cons_list(index_omni(), + cons_list(index_uni(1), nil_index_list())), "recruit")), + "assigning variable B"); + for (size_t t = 2; t <= n_occasions; ++t) { + current_statement__ = 57; + assign(N, cons_list(index_uni(t), nil_index_list()), + sum( + rvalue(z, + cons_list(index_omni(), + cons_list(index_uni(t), nil_index_list())), "z")), + "assigning variable N"); + current_statement__ = 58; + assign(B, cons_list(index_uni(t), nil_index_list()), + sum( + rvalue(recruit, + cons_list(index_omni(), + cons_list(index_uni(t), nil_index_list())), "recruit")), + "assigning variable B");} + } + current_statement__ = 64; + if (lcm_sym157__) { + current_statement__ = 61; + assign(Nind, cons_list(index_uni(1), nil_index_list()), + sum(z[(1 - 1)]), "assigning variable Nind"); + current_statement__ = 62; + assign(Nalive, cons_list(index_uni(1), nil_index_list()), + (1 - logical_negation(Nind[(1 - 1)])), + "assigning variable Nalive"); + for (size_t i = 2; i <= M; ++i) { + current_statement__ = 61; + assign(Nind, cons_list(index_uni(i), nil_index_list()), + sum(z[(i - 1)]), "assigning variable Nind"); + current_statement__ = 62; + assign(Nalive, cons_list(index_uni(i), nil_index_list()), + (1 - logical_negation(Nind[(i - 1)])), + "assigning variable Nalive");} + } + current_statement__ = 65; + Nsuper = sum(Nalive); + } + vars__.push_back(lcm_sym203__); + vars__.push_back(lcm_sym205__); + if (lcm_sym158__) { + vars__.push_back(lcm_sym156__[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + vars__.push_back(lcm_sym156__[(sym1__ - 1)]);} + } + vars__.push_back(Nsuper); + if (lcm_sym158__) { + vars__.push_back(N[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + vars__.push_back(N[(sym1__ - 1)]);} + } + if (lcm_sym158__) { + vars__.push_back(B[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + vars__.push_back(B[(sym1__ - 1)]);} + } + if (lcm_sym158__) { + if (lcm_sym157__) { + vars__.push_back(z[(1 - 1)][(1 - 1)]); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + vars__.push_back(z[(sym2__ - 1)][(1 - 1)]);} + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + if (lcm_sym157__) { + vars__.push_back(z[(1 - 1)][(sym1__ - 1)]); + for (size_t sym2__ = 2; sym2__ <= M; ++sym2__) { + vars__.push_back(z[(sym2__ - 1)][(sym1__ - 1)]);} + } } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + double lcm_sym155__; + double lcm_sym154__; + double lcm_sym153__; + double lcm_sym152__; + double lcm_sym151__; + double lcm_sym150__; + double lcm_sym149__; + double lcm_sym148__; + int lcm_sym145__; + int lcm_sym144__; + int lcm_sym143__; + int lcm_sym142__; + int pos__; + + pos__ = 1; + double mean_phi; + + current_statement__ = 1; + mean_phi = context__.vals_r("mean_phi")[(1 - 1)]; + current_statement__ = 1; + mean_phi = stan::math::lub_free(mean_phi, 0, 1); + double mean_p; + + current_statement__ = 2; + mean_p = context__.vals_r("mean_p")[(1 - 1)]; + current_statement__ = 2; + mean_p = stan::math::lub_free(mean_p, 0, 1); + current_statement__ = 3; + validate_non_negative_index("gamma", "n_occasions", n_occasions); + Eigen::Matrix gamma; + gamma = Eigen::Matrix(n_occasions); + + { + std::vector gamma_flat__; + current_statement__ = 3; + assign(gamma_flat__, nil_index_list(), context__.vals_r("gamma"), + "assigning variable gamma_flat__"); + current_statement__ = 3; + pos__ = 1; + lcm_sym142__ = logical_gte(n_occasions, 1); + if (lcm_sym142__) { + current_statement__ = 3; + assign(gamma, cons_list(index_uni(1), nil_index_list()), + gamma_flat__[(1 - 1)], "assigning variable gamma"); + current_statement__ = 3; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 3; + assign(gamma, cons_list(index_uni(sym1__), nil_index_list()), + gamma_flat__[(pos__ - 1)], "assigning variable gamma"); + current_statement__ = 3; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 3; + if (lcm_sym142__) { + current_statement__ = 3; + assign(gamma, cons_list(index_uni(1), nil_index_list()), + stan::math::lub_free(gamma[(1 - 1)], 0, 1), + "assigning variable gamma"); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 3; + assign(gamma, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_free(gamma[(sym1__ - 1)], 0, 1), + "assigning variable gamma");} + } + lcm_sym144__ = (n_occasions - 1); + validate_non_negative_index("epsilon", "(n_occasions - 1)", + lcm_sym144__); + Eigen::Matrix epsilon; + epsilon = Eigen::Matrix(lcm_sym144__); + + { + std::vector epsilon_flat__; + current_statement__ = 4; + assign(epsilon_flat__, nil_index_list(), context__.vals_r("epsilon"), + "assigning variable epsilon_flat__"); + current_statement__ = 4; + pos__ = 1; + lcm_sym143__ = logical_gte(lcm_sym144__, 1); + if (lcm_sym143__) { + current_statement__ = 4; + assign(epsilon, cons_list(index_uni(1), nil_index_list()), + epsilon_flat__[(1 - 1)], "assigning variable epsilon"); + current_statement__ = 4; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= lcm_sym144__; ++sym1__) { + current_statement__ = 4; + assign(epsilon, cons_list(index_uni(sym1__), nil_index_list()), + epsilon_flat__[(pos__ - 1)], "assigning variable epsilon"); + current_statement__ = 4; + pos__ = (pos__ + 1);} + } + } + double sigma; + + current_statement__ = 5; + sigma = context__.vals_r("sigma")[(1 - 1)]; + current_statement__ = 5; + sigma = stan::math::lub_free(sigma, 0, 5); + vars__.push_back(mean_phi); + vars__.push_back(mean_p); + if (lcm_sym142__) { + vars__.push_back(gamma[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + vars__.push_back(gamma[(sym1__ - 1)]);} + } + if (lcm_sym143__) { + vars__.push_back(epsilon[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= lcm_sym144__; ++sym1__) { + vars__.push_back(epsilon[(sym1__ - 1)]);} + } + vars__.push_back(sigma); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("mean_phi"); + names__.push_back("mean_p"); + names__.push_back("gamma"); + names__.push_back("epsilon"); + names__.push_back("sigma"); + names__.push_back("phi"); + names__.push_back("p"); + names__.push_back("chi"); + names__.push_back("sigma2"); + names__.push_back("psi"); + names__.push_back("b"); + names__.push_back("Nsuper"); + names__.push_back("N"); + names__.push_back("B"); + names__.push_back("z"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back((n_occasions - 1)); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(M); + + dims__.push_back((n_occasions - 1)); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(M); + + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(M); + + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(M); + + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "mean_phi"); + param_names__.push_back(std::string() + "mean_p"); + for (size_t sym344__ = 1; sym344__ <= n_occasions; ++sym344__) { + { + param_names__.push_back(std::string() + "gamma" + '.' + std::to_string(sym344__)); + }} + for (size_t sym344__ = 1; sym344__ <= (n_occasions - 1); ++sym344__) { + { + param_names__.push_back(std::string() + "epsilon" + '.' + std::to_string(sym344__)); + }} + param_names__.push_back(std::string() + "sigma"); + if (emit_transformed_parameters__) { + for (size_t sym344__ = 1; sym344__ <= (n_occasions - 1); ++sym344__) { + { + for (size_t sym345__ = 1; sym345__ <= M; ++sym345__) { + { + param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym345__) + '.' + std::to_string(sym344__)); + }} + }} + for (size_t sym344__ = 1; sym344__ <= n_occasions; ++sym344__) { + { + for (size_t sym345__ = 1; sym345__ <= M; ++sym345__) { + { + param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym345__) + '.' + std::to_string(sym344__)); + }} + }} + for (size_t sym344__ = 1; sym344__ <= n_occasions; ++sym344__) { + { + for (size_t sym345__ = 1; sym345__ <= M; ++sym345__) { + { + param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym345__) + '.' + std::to_string(sym344__)); + }} + }} + } + + if (emit_generated_quantities__) { + param_names__.push_back(std::string() + "sigma2"); + param_names__.push_back(std::string() + "psi"); + for (size_t sym344__ = 1; sym344__ <= n_occasions; ++sym344__) { + { + param_names__.push_back(std::string() + "b" + '.' + std::to_string(sym344__)); + }} + param_names__.push_back(std::string() + "Nsuper"); + for (size_t sym344__ = 1; sym344__ <= n_occasions; ++sym344__) { + { + param_names__.push_back(std::string() + "N" + '.' + std::to_string(sym344__)); + }} + for (size_t sym344__ = 1; sym344__ <= n_occasions; ++sym344__) { + { + param_names__.push_back(std::string() + "B" + '.' + std::to_string(sym344__)); + }} + for (size_t sym344__ = 1; sym344__ <= n_occasions; ++sym344__) { + { + for (size_t sym345__ = 1; sym345__ <= M; ++sym345__) { + { + param_names__.push_back(std::string() + "z" + '.' + std::to_string(sym345__) + '.' + std::to_string(sym344__)); + }} + }} + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "mean_phi"); + param_names__.push_back(std::string() + "mean_p"); + for (size_t sym344__ = 1; sym344__ <= n_occasions; ++sym344__) { + { + param_names__.push_back(std::string() + "gamma" + '.' + std::to_string(sym344__)); + }} + for (size_t sym344__ = 1; sym344__ <= (n_occasions - 1); ++sym344__) { + { + param_names__.push_back(std::string() + "epsilon" + '.' + std::to_string(sym344__)); + }} + param_names__.push_back(std::string() + "sigma"); + if (emit_transformed_parameters__) { + for (size_t sym344__ = 1; sym344__ <= (n_occasions - 1); ++sym344__) { + { + for (size_t sym345__ = 1; sym345__ <= M; ++sym345__) { + { + param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym345__) + '.' + std::to_string(sym344__)); + }} + }} + for (size_t sym344__ = 1; sym344__ <= n_occasions; ++sym344__) { + { + for (size_t sym345__ = 1; sym345__ <= M; ++sym345__) { + { + param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym345__) + '.' + std::to_string(sym344__)); + }} + }} + for (size_t sym344__ = 1; sym344__ <= n_occasions; ++sym344__) { + { + for (size_t sym345__ = 1; sym345__ <= M; ++sym345__) { + { + param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym345__) + '.' + std::to_string(sym344__)); + }} + }} + } + + if (emit_generated_quantities__) { + param_names__.push_back(std::string() + "sigma2"); + param_names__.push_back(std::string() + "psi"); + for (size_t sym344__ = 1; sym344__ <= n_occasions; ++sym344__) { + { + param_names__.push_back(std::string() + "b" + '.' + std::to_string(sym344__)); + }} + param_names__.push_back(std::string() + "Nsuper"); + for (size_t sym344__ = 1; sym344__ <= n_occasions; ++sym344__) { + { + param_names__.push_back(std::string() + "N" + '.' + std::to_string(sym344__)); + }} + for (size_t sym344__ = 1; sym344__ <= n_occasions; ++sym344__) { + { + param_names__.push_back(std::string() + "B" + '.' + std::to_string(sym344__)); + }} + for (size_t sym344__ = 1; sym344__ <= n_occasions; ++sym344__) { + { + for (size_t sym345__ = 1; sym345__ <= M; ++sym345__) { + { + param_names__.push_back(std::string() + "z" + '.' + std::to_string(sym345__) + '.' + std::to_string(sym344__)); + }} + }} + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mean_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"gamma\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"parameters\"},{\"name\":\"epsilon\",\"type\":{\"name\":\"vector\",\"length\":" << (n_occasions - 1) << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << (n_occasions - 1) << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"psi\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"generated_quantities\"},{\"name\":\"Nsuper\",\"type\":{\"name\":\"int\"},\"block\":\"generated_quantities\"},{\"name\":\"N\",\"type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"B\",\"type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"z\",\"type\":{\"name\":\"array\",\"length\":" << M << ",\"element_type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}}},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mean_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"gamma\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"parameters\"},{\"name\":\"epsilon\",\"type\":{\"name\":\"vector\",\"length\":" << (n_occasions - 1) << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << (n_occasions - 1) << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"psi\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"generated_quantities\"},{\"name\":\"Nsuper\",\"type\":{\"name\":\"int\"},\"block\":\"generated_quantities\"},{\"name\":\"N\",\"type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"B\",\"type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"z\",\"type\":{\"name\":\"array\",\"length\":" << M << ",\"element_type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}}},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef inlining_fail2_model_namespace::inlining_fail2_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp lcm-experiment.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace lcm_experiment_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'lcm-experiment.stan', line 2, column 2 to column 8)", + " (in 'lcm-experiment.stan', line 5, column 2 to column 13)", + " (in 'lcm-experiment.stan', line 6, column 2 to column 9)", + " (in 'lcm-experiment.stan', line 8, column 4 to column 27)", + " (in 'lcm-experiment.stan', line 7, column 2 to line 10, column 3)", + " (in 'lcm-experiment.stan', line 11, column 2 to column 38)"}; + + + +class lcm_experiment_model : public model_base_crtp { + + private: + double lcm_sym4__; + double lcm_sym3__; + int pos__; + int j; + double z; + double x; + double i; + + public: + ~lcm_experiment_model() { } + + std::string model_name() const { return "lcm_experiment_model"; } + + lcm_experiment_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "lcm_experiment_model_namespace::lcm_experiment_model"; + (void) function__; // suppress unused var warning + + try { + + + + pos__ = 1; + context__.validate_dims("data initialization","j","int", + context__.to_vec()); + + current_statement__ = 1; + j = context__.vals_i("j")[(1 - 1)]; + + lcm_sym4__ = std::numeric_limits::quiet_NaN(); + z = lcm_sym4__; + current_statement__ = 2; + z = 1; + + current_statement__ = 3; + x = lcm_sym4__; + { + current_statement__ = 4; + x = normal_rng(123, 1, base_rng__); + lcm_sym3__ = stan::math::fma(stan::math::sqrt(j), 2, 1); + z = normal_rng(lcm_sym3__, 1, base_rng__); + } + + current_statement__ = 6; + i = lcm_sym4__; + current_statement__ = 6; + i = normal_rng(lcm_sym3__, 1, base_rng__); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "lcm_experiment_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "lcm_experiment_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + int lcm_sym2__; + int lcm_sym1__; + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + int pos__; + + pos__ = 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef lcm_experiment_model_namespace::lcm_experiment_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp lcm-experiment2.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace lcm_experiment2_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'lcm-experiment2.stan', line 2, column 2 to column 9)", + " (in 'lcm-experiment2.stan', line 5, column 2 to column 18)", + " (in 'lcm-experiment2.stan', line 7, column 4 to column 11)", + " (in 'lcm-experiment2.stan', line 6, column 2 to line 8, column 3)", + " (in 'lcm-experiment2.stan', line 10, column 4 to column 11)", + " (in 'lcm-experiment2.stan', line 9, column 2 to line 10, column 11)", + " (in 'lcm-experiment2.stan', line 11, column 2 to column 14)"}; + + + +class lcm_experiment2_model : public model_base_crtp { + + private: + int pos__; + + public: + ~lcm_experiment2_model() { } + + std::string model_name() const { return "lcm_experiment2_model"; } + + lcm_experiment2_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "lcm_experiment2_model_namespace::lcm_experiment2_model"; + (void) function__; // suppress unused var warning + + try { + + pos__ = 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + num_params_r__ += 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "lcm_experiment2_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + local_scalar_t__ lcm_sym5__; + double lcm_sym4__; + double lcm_sym3__; + local_scalar_t__ x; + + current_statement__ = 1; + x = in__.scalar(); + { + local_scalar_t__ y; + + lcm_sym5__ = stan::math::log(x); + { + current_statement__ = 3; + y = (lcm_sym5__ + 1); + } + { + current_statement__ = 5; + y = (y + 1); + } + current_statement__ = 7; + lp_accum__.add(y); + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "lcm_experiment2_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + int lcm_sym2__; + int lcm_sym1__; + double x; + + current_statement__ = 1; + x = in__.scalar(); + vars__.push_back(x); + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + int pos__; + + pos__ = 1; + double x; + + current_statement__ = 1; + x = context__.vals_r("x")[(1 - 1)]; + vars__.push_back(x); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("x"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "x"); + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "x"); + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"x\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"x\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef lcm_experiment2_model_namespace::lcm_experiment2_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp lcm-fails.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace lcm_fails_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'lcm-fails.stan', line 6, column 2 to column 16)", + " (in 'lcm-fails.stan', line 9, column 2 to column 22)", + " (in 'lcm-fails.stan', line 2, column 2 to column 17)", + " (in 'lcm-fails.stan', line 3, column 2 to column 12)"}; + + + +class lcm_fails_model : public model_base_crtp { + + private: + int pos__; + int J; + std::vector y; + + public: + ~lcm_fails_model() { } + + std::string model_name() const { return "lcm_fails_model"; } + + lcm_fails_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "lcm_fails_model_namespace::lcm_fails_model"; + (void) function__; // suppress unused var warning + + try { + + pos__ = 1; + context__.validate_dims("data initialization","J","int", + context__.to_vec()); + + current_statement__ = 3; + J = context__.vals_i("J")[(1 - 1)]; + current_statement__ = 4; + validate_non_negative_index("y", "J", J); + context__.validate_dims("data initialization","y","double", + context__.to_vec(J)); + y = std::vector(J, 0); + + current_statement__ = 4; + assign(y, nil_index_list(), context__.vals_r("y"), + "assigning variable y"); + current_statement__ = 3; + current_statement__ = 3; + check_greater_or_equal(function__, "J", J, 0); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + current_statement__ = 1; + validate_non_negative_index("theta", "J", J); + num_params_r__ += J; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "lcm_fails_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + double lcm_sym10__; + int lcm_sym9__; + current_statement__ = 1; + validate_non_negative_index("theta", "J", J); + std::vector theta; + theta = std::vector(J, 0); + + current_statement__ = 1; + if (logical_gte(J, 1)) { + current_statement__ = 1; + assign(theta, cons_list(index_uni(1), nil_index_list()), + in__.scalar(), "assigning variable theta"); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + current_statement__ = 1; + assign(theta, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable theta");} + } + { + current_statement__ = 2; + lp_accum__.add(normal_log(y, theta, 1)); + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "lcm_fails_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + double lcm_sym8__; + double lcm_sym7__; + int lcm_sym6__; + int lcm_sym5__; + int lcm_sym4__; + current_statement__ = 1; + validate_non_negative_index("theta", "J", J); + std::vector theta; + theta = std::vector(J, 0); + + lcm_sym4__ = logical_gte(J, 1); + if (lcm_sym4__) { + current_statement__ = 1; + assign(theta, cons_list(index_uni(1), nil_index_list()), + in__.scalar(), "assigning variable theta"); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + current_statement__ = 1; + assign(theta, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable theta");} + } + if (lcm_sym4__) { + vars__.push_back(theta[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + vars__.push_back(theta[(sym1__ - 1)]);} + } + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + double lcm_sym3__; + double lcm_sym2__; + int lcm_sym1__; + int pos__; + + pos__ = 1; + current_statement__ = 1; + validate_non_negative_index("theta", "J", J); + std::vector theta; + theta = std::vector(J, 0); + + current_statement__ = 1; + assign(theta, nil_index_list(), context__.vals_r("theta"), + "assigning variable theta"); + if (logical_gte(J, 1)) { + vars__.push_back(theta[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + vars__.push_back(theta[(sym1__ - 1)]);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("theta"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dims__.push_back(J); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + for (size_t sym11__ = 1; sym11__ <= J; ++sym11__) { + { + param_names__.push_back(std::string() + "theta" + '.' + std::to_string(sym11__)); + }} + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + for (size_t sym11__ = 1; sym11__ <= J; ++sym11__) { + { + param_names__.push_back(std::string() + "theta" + '.' + std::to_string(sym11__)); + }} + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"theta\",\"type\":{\"name\":\"array\",\"length\":" << J << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"theta\",\"type\":{\"name\":\"array\",\"length\":" << J << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef lcm_fails_model_namespace::lcm_fails_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp lcm-fails2.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace lcm_fails2_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'lcm-fails2.stan', line 69, column 2 to column 33)", + " (in 'lcm-fails2.stan', line 70, column 2 to column 31)", + " (in 'lcm-fails2.stan', line 74, column 2 to column 51)", + " (in 'lcm-fails2.stan', line 75, column 2 to column 49)", + " (in 'lcm-fails2.stan', line 76, column 2 to column 49)", + " (in 'lcm-fails2.stan', line 81, column 6 to column 20)", + " (in 'lcm-fails2.stan', line 82, column 6 to column 18)", + " (in 'lcm-fails2.stan', line 80, column 32 to line 83, column 5)", + " (in 'lcm-fails2.stan', line 85, column 6 to column 27)", + " (in 'lcm-fails2.stan', line 86, column 6 to column 23)", + " (in 'lcm-fails2.stan', line 84, column 38 to line 87, column 5)", + " (in 'lcm-fails2.stan', line 84, column 4 to line 87, column 5)", + " (in 'lcm-fails2.stan', line 79, column 20 to line 88, column 3)", + " (in 'lcm-fails2.stan', line 79, column 2 to line 88, column 3)", + " (in 'lcm-fails2.stan', line 26, column 4 to column 34)", + " (in 'lcm-fails2.stan', line 29, column 6 to column 32)", + " (in 'lcm-fails2.stan', line 32, column 8 to column 37)", + " (in 'lcm-fails2.stan', line 33, column 8 to column 32)", + " (in 'lcm-fails2.stan', line 41, column 8 to line 42, column 83)", + " (in 'lcm-fails2.stan', line 30, column 37 to line 43, column 7)", + " (in 'lcm-fails2.stan', line 28, column 22 to line 44, column 5)", + " (in 'lcm-fails2.stan', line 25, column 47 to line 46, column 3)", + " (in 'lcm-fails2.stan', line 103, column 8 to column 37)", + " (in 'lcm-fails2.stan', line 104, column 8 to column 41)", + " (in 'lcm-fails2.stan', line 102, column 40 to line 105, column 7)", + " (in 'lcm-fails2.stan', line 106, column 6 to column 37)", + " (in 'lcm-fails2.stan', line 101, column 22 to line 107, column 5)", + " (in 'lcm-fails2.stan', line 100, column 20 to line 108, column 3)", + " (in 'lcm-fails2.stan', line 100, column 2 to line 108, column 3)", + " (in 'lcm-fails2.stan', line 50, column 2 to column 20)", + " (in 'lcm-fails2.stan', line 51, column 2 to column 27)", + " (in 'lcm-fails2.stan', line 52, column 2 to column 44)", + " (in 'lcm-fails2.stan', line 56, column 2 to column 38)", + " (in 'lcm-fails2.stan', line 58, column 2 to column 45)", + " (in 'lcm-fails2.stan', line 59, column 2 to column 44)", + " (in 'lcm-fails2.stan', line 8, column 8 to column 17)", + " (in 'lcm-fails2.stan', line 7, column 6 to line 8, column 17)", + " (in 'lcm-fails2.stan', line 5, column 31 to line 10, column 3)", + " (in 'lcm-fails2.stan', line 63, column 4 to column 35)", + " (in 'lcm-fails2.stan', line 62, column 2 to line 63, column 35)", + " (in 'lcm-fails2.stan', line 15, column 6 to column 32)", + " (in 'lcm-fails2.stan', line 19, column 8 to column 17)", + " (in 'lcm-fails2.stan', line 18, column 6 to line 19, column 17)", + " (in 'lcm-fails2.stan', line 13, column 37 to line 20, column 5)", + " (in 'lcm-fails2.stan', line 12, column 30 to line 22, column 3)", + " (in 'lcm-fails2.stan', line 65, column 4 to column 33)", + " (in 'lcm-fails2.stan', line 64, column 2 to line 65, column 33)", + " (in 'lcm-fails2.stan', line 9, column 4 to column 13)", + " (in 'lcm-fails2.stan', line 21, column 4 to column 13)", + " (in 'lcm-fails2.stan', line 30, column 6 to line 43, column 7)", + " (in 'lcm-fails2.stan', line 28, column 4 to line 44, column 5)", + " (in 'lcm-fails2.stan', line 45, column 4 to column 15)"}; + + +int +first_capture(const std::vector& y_i, std::ostream* pstream__) { + using local_scalar_t__ = double; + const static bool propto__ = true; + (void) propto__; + + try { + int lcm_sym33__; + int lcm_sym32__; + int lcm_sym31__; + int lcm_sym30__; + { + lcm_sym31__ = size(y_i); + if (logical_gte(lcm_sym31__, 1)) { + current_statement__ = 37; + if (y_i[(1 - 1)]) { + current_statement__ = 36; + return 1; + } + for (size_t k = 2; k <= lcm_sym31__; ++k) { + current_statement__ = 37; + if (y_i[(k - 1)]) { + current_statement__ = 36; + return k; + } } + } + current_statement__ = 48; + return 0; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct first_capture_functor__ { +int +operator()(const std::vector& y_i, std::ostream* pstream__) const +{ +return first_capture(y_i, pstream__); +} +}; + +int +last_capture(const std::vector& y_i, std::ostream* pstream__) { + using local_scalar_t__ = double; + const static bool propto__ = true; + (void) propto__; + + try { + int lcm_sym39__; + int lcm_sym38__; + int lcm_sym37__; + int lcm_sym36__; + int lcm_sym35__; + int lcm_sym34__; + { + lcm_sym37__ = (size(y_i) - 1); + if (logical_gte(lcm_sym37__, 0)) { + int k; + + lcm_sym36__ = (size(y_i) - 0); + current_statement__ = 43; + if (y_i[(lcm_sym36__ - 1)]) { + current_statement__ = 42; + return lcm_sym36__; + } + for (size_t k_rev = 1; k_rev <= lcm_sym37__; ++k_rev) { + int k; + + lcm_sym35__ = (size(y_i) - k_rev); + current_statement__ = 43; + if (y_i[(lcm_sym35__ - 1)]) { + current_statement__ = 42; + return lcm_sym35__; + } } + } + current_statement__ = 49; + return 0; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct last_capture_functor__ { +int +operator()(const std::vector& y_i, std::ostream* pstream__) const +{ +return last_capture(y_i, pstream__); +} +}; + +template +Eigen::Matrix::type, -1, -1> +prob_uncaptured(const int& nind, const int& n_occasions, + const Eigen::Matrix& p, + const Eigen::Matrix& phi, + std::ostream* pstream__) { + using local_scalar_t__ = typename boost::math::tools::promote_args::type; + const static bool propto__ = true; + (void) propto__; + + try { + double lcm_sym51__; + double lcm_sym50__; + double lcm_sym49__; + double lcm_sym48__; + double lcm_sym47__; + int lcm_sym46__; + int lcm_sym45__; + int lcm_sym44__; + int lcm_sym43__; + int lcm_sym42__; + int lcm_sym41__; + int lcm_sym40__; + { + current_statement__ = 15; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 15; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix chi; + chi = Eigen::Matrix(nind, n_occasions); + + lcm_sym41__ = logical_gte(nind, 1); + if (lcm_sym41__) { + lcm_sym40__ = logical_gte(n_occasions, 1); + if (lcm_sym40__) { + lcm_sym51__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym51__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 15; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), lcm_sym51__, + "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 15; + if (lcm_sym40__) { + lcm_sym51__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym51__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 15; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym51__, "assigning variable chi");} + } } + } + current_statement__ = 51; + if (lcm_sym41__) { + current_statement__ = 16; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(n_occasions), nil_index_list())), 1.0, + "assigning variable chi"); + lcm_sym44__ = (n_occasions - 1); + lcm_sym42__ = logical_gte(lcm_sym44__, 1); + if (lcm_sym42__) { + int t_curr; + + int t_next; + + lcm_sym46__ = (lcm_sym44__ + 1); + current_statement__ = 19; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym46__ - 1)), + nil_index_list())), "p"))), + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym46__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + "phi"))), "assigning variable chi"); + for (size_t t = 2; t <= lcm_sym44__; ++t) { + int t_curr; + + lcm_sym43__ = (n_occasions - t); + int t_next; + + lcm_sym45__ = (lcm_sym43__ + 1); + current_statement__ = 19; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym45__ - 1)), + nil_index_list())), "p"))), + rvalue(chi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym45__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + "phi"))), "assigning variable chi");} + } + for (size_t i = 2; i <= nind; ++i) { + current_statement__ = 16; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(n_occasions), nil_index_list())), 1.0, + "assigning variable chi"); + current_statement__ = 50; + if (lcm_sym42__) { + int t_curr; + + int t_next; + + lcm_sym46__ = (lcm_sym44__ + 1); + current_statement__ = 19; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym46__ - 1)), + nil_index_list())), "p"))), + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym46__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym44__), nil_index_list())), + "phi"))), "assigning variable chi"); + for (size_t t = 2; t <= lcm_sym44__; ++t) { + int t_curr; + + lcm_sym43__ = (n_occasions - t); + int t_next; + + lcm_sym45__ = (lcm_sym43__ + 1); + current_statement__ = 19; + assign(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym45__ - 1)), + nil_index_list())), "p"))), + rvalue(chi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym45__), nil_index_list())), + "chi"), + (1 - + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym43__), nil_index_list())), + "phi"))), "assigning variable chi");} + } } + } + current_statement__ = 52; + return chi; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct prob_uncaptured_functor__ { +template +Eigen::Matrix::type, -1, -1> +operator()(const int& nind, const int& n_occasions, + const Eigen::Matrix& p, + const Eigen::Matrix& phi, std::ostream* pstream__) const +{ +return prob_uncaptured(nind, n_occasions, p, phi, pstream__); +} +}; + +class lcm_fails2_model : public model_base_crtp { + + private: + int lcm_sym147__; + int lcm_sym146__; + int lcm_sym145__; + int lcm_sym144__; + int lcm_sym143__; + int lcm_sym142__; + int lcm_sym141__; + int lcm_sym140__; + int lcm_sym139__; + int lcm_sym138__; + int lcm_sym137__; + int lcm_sym136__; + int lcm_sym135__; + int lcm_sym134__; + int lcm_sym133__; + int lcm_sym132__; + int lcm_sym131__; + int lcm_sym130__; + int lcm_sym129__; + int lcm_sym128__; + int lcm_sym127__; + int lcm_sym126__; + int lcm_sym125__; + int lcm_sym124__; + int pos__; + int nind; + int n_occasions; + std::vector> y; + int n_occ_minus_1; + std::vector first; + std::vector last; + + public: + ~lcm_fails2_model() { } + + std::string model_name() const { return "lcm_fails2_model"; } + + lcm_fails2_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "lcm_fails2_model_namespace::lcm_fails2_model"; + (void) function__; // suppress unused var warning + + try { + + + + + + + + + + + + + + + + + + + + + + + + + + pos__ = 1; + context__.validate_dims("data initialization","nind","int", + context__.to_vec()); + + current_statement__ = 30; + nind = context__.vals_i("nind")[(1 - 1)]; + context__.validate_dims("data initialization","n_occasions","int", + context__.to_vec()); + + current_statement__ = 31; + n_occasions = context__.vals_i("n_occasions")[(1 - 1)]; + current_statement__ = 32; + validate_non_negative_index("y", "nind", nind); + current_statement__ = 32; + validate_non_negative_index("y", "n_occasions", n_occasions); + context__.validate_dims("data initialization","y","int", + context__.to_vec(nind, n_occasions)); + y = std::vector>(nind, std::vector(n_occasions, 0)); + + { + std::vector y_flat__; + current_statement__ = 32; + assign(y_flat__, nil_index_list(), context__.vals_i("y"), + "assigning variable y_flat__"); + current_statement__ = 32; + pos__ = 1; + lcm_sym124__ = logical_gte(n_occasions, 1); + if (lcm_sym124__) { + { + lcm_sym125__ = logical_gte(nind, 1); + if (lcm_sym125__) { + current_statement__ = 32; + assign(y, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + y_flat__[(1 - 1)], "assigning variable y"); + current_statement__ = 32; + pos__ = 2; + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + current_statement__ = 32; + assign(y, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 32; + pos__ = (pos__ + 1);} + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + current_statement__ = 32; + if (lcm_sym125__) { + current_statement__ = 32; + assign(y, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 32; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + current_statement__ = 32; + assign(y, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 32; + pos__ = (pos__ + 1);} + } } + } + } else { + lcm_sym125__ = logical_gte(nind, 1); + } + } + + current_statement__ = 33; + n_occ_minus_1 = (n_occasions - 1); + current_statement__ = 34; + validate_non_negative_index("first", "nind", nind); + first = std::vector(nind, 0); + + current_statement__ = 35; + validate_non_negative_index("last", "nind", nind); + last = std::vector(nind, 0); + + current_statement__ = 40; + if (lcm_sym125__) { + int inline_sym21__; + int inline_sym23__; + + inline_sym23__ = 0; + for (size_t inline_sym24__ = 1; inline_sym24__ <= 1; ++inline_sym24__) { + lcm_sym133__ = size(y[(1 - 1)]); + for (size_t inline_sym22__ = 1; inline_sym22__ <= lcm_sym133__; + ++inline_sym22__) { + current_statement__ = 37; + if (y[(1 - 1)][(inline_sym22__ - 1)]) { + inline_sym23__ = 1; + inline_sym21__ = inline_sym22__; + break; + } } + if (inline_sym23__) { + break; + } + inline_sym23__ = 1; + inline_sym21__ = 0; + break;} + assign(first, cons_list(index_uni(1), nil_index_list()), + inline_sym21__, "assigning variable first"); + for (size_t i = 2; i <= nind; ++i) { + int inline_sym21__; + int inline_sym23__; + + inline_sym23__ = 0; + for (size_t inline_sym24__ = 1; inline_sym24__ <= 1; + ++inline_sym24__) { + lcm_sym132__ = size(y[(i - 1)]); + for (size_t inline_sym22__ = 1; inline_sym22__ <= lcm_sym132__; + ++inline_sym22__) { + current_statement__ = 37; + if (y[(i - 1)][(inline_sym22__ - 1)]) { + inline_sym23__ = 1; + inline_sym21__ = inline_sym22__; + break; + } } + if (inline_sym23__) { + break; + } + inline_sym23__ = 1; + inline_sym21__ = 0; + break;} + assign(first, cons_list(index_uni(i), nil_index_list()), + inline_sym21__, "assigning variable first");} + } + current_statement__ = 47; + if (lcm_sym125__) { + int inline_sym25__; + int inline_sym28__; + + inline_sym28__ = 0; + for (size_t inline_sym29__ = 1; inline_sym29__ <= 1; ++inline_sym29__) { + lcm_sym133__ = size(y[(1 - 1)]); + lcm_sym130__ = (lcm_sym133__ - 1); + for (size_t inline_sym27__ = 0; inline_sym27__ <= lcm_sym130__; + ++inline_sym27__) { + int inline_sym26__; + + lcm_sym129__ = (lcm_sym133__ - inline_sym27__); + inline_sym26__ = lcm_sym129__; + current_statement__ = 43; + if (y[(1 - 1)][(lcm_sym129__ - 1)]) { + inline_sym28__ = 1; + inline_sym25__ = lcm_sym129__; + break; + } } + if (inline_sym28__) { + break; + } + inline_sym28__ = 1; + inline_sym25__ = 0; + break;} + assign(last, cons_list(index_uni(1), nil_index_list()), + inline_sym25__, "assigning variable last"); + for (size_t i = 2; i <= nind; ++i) { + int inline_sym25__; + int inline_sym28__; + + inline_sym28__ = 0; + for (size_t inline_sym29__ = 1; inline_sym29__ <= 1; + ++inline_sym29__) { + lcm_sym132__ = size(y[(i - 1)]); + lcm_sym128__ = (lcm_sym132__ - 1); + for (size_t inline_sym27__ = 0; inline_sym27__ <= lcm_sym128__; + ++inline_sym27__) { + int inline_sym26__; + + lcm_sym127__ = (lcm_sym132__ - inline_sym27__); + inline_sym26__ = lcm_sym127__; + current_statement__ = 43; + if (y[(i - 1)][(lcm_sym127__ - 1)]) { + inline_sym28__ = 1; + inline_sym25__ = lcm_sym127__; + break; + } } + if (inline_sym28__) { + break; + } + inline_sym28__ = 1; + inline_sym25__ = 0; + break;} + assign(last, cons_list(index_uni(i), nil_index_list()), + inline_sym25__, "assigning variable last");} + } + current_statement__ = 30; + current_statement__ = 30; + check_greater_or_equal(function__, "nind", nind, 0); + current_statement__ = 31; + current_statement__ = 31; + check_greater_or_equal(function__, "n_occasions", n_occasions, 2); + current_statement__ = 32; + if (lcm_sym125__) { + current_statement__ = 32; + if (lcm_sym124__) { + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(sym2__ - 1)], 0);} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 32; + if (lcm_sym124__) { + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(sym2__ - 1)], 0);} + } } + } + current_statement__ = 32; + if (lcm_sym125__) { + current_statement__ = 32; + if (lcm_sym124__) { + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(sym2__ - 1)], 1);} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 32; + if (lcm_sym124__) { + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(sym2__ - 1)], 1);} + } } + } + current_statement__ = 34; + if (lcm_sym125__) { + current_statement__ = 34; + current_statement__ = 34; + check_greater_or_equal(function__, "first[sym1__]", first[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 34; + current_statement__ = 34; + check_greater_or_equal(function__, "first[sym1__]", + first[(sym1__ - 1)], 0);} + } + current_statement__ = 34; + if (lcm_sym125__) { + current_statement__ = 34; + current_statement__ = 34; + check_less_or_equal(function__, "first[sym1__]", first[(1 - 1)], + n_occasions); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 34; + current_statement__ = 34; + check_less_or_equal(function__, "first[sym1__]", + first[(sym1__ - 1)], n_occasions);} + } + current_statement__ = 35; + if (lcm_sym125__) { + current_statement__ = 35; + current_statement__ = 35; + check_greater_or_equal(function__, "last[sym1__]", last[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 35; + current_statement__ = 35; + check_greater_or_equal(function__, "last[sym1__]", + last[(sym1__ - 1)], 0);} + } + current_statement__ = 35; + if (lcm_sym125__) { + current_statement__ = 35; + current_statement__ = 35; + check_less_or_equal(function__, "last[sym1__]", last[(1 - 1)], + n_occasions); + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 35; + current_statement__ = 35; + check_less_or_equal(function__, "last[sym1__]", last[(sym1__ - 1)], + n_occasions);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + num_params_r__ += 1; + num_params_r__ += 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "lcm_fails2_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + int lcm_sym123__; + int lcm_sym122__; + int lcm_sym121__; + int lcm_sym120__; + double lcm_sym119__; + double lcm_sym118__; + double lcm_sym117__; + double lcm_sym116__; + double lcm_sym115__; + double lcm_sym114__; + double lcm_sym113__; + double lcm_sym112__; + double lcm_sym111__; + double lcm_sym110__; + double lcm_sym109__; + double lcm_sym108__; + double lcm_sym107__; + int lcm_sym106__; + int lcm_sym105__; + int lcm_sym104__; + int lcm_sym103__; + int lcm_sym102__; + int lcm_sym101__; + int lcm_sym100__; + int lcm_sym99__; + int lcm_sym98__; + int lcm_sym97__; + int lcm_sym96__; + int lcm_sym95__; + int lcm_sym94__; + int lcm_sym93__; + int lcm_sym92__; + int lcm_sym91__; + int lcm_sym90__; + int lcm_sym89__; + int lcm_sym88__; + int lcm_sym87__; + int lcm_sym86__; + local_scalar_t__ mean_phi; + + current_statement__ = 1; + mean_phi = in__.scalar(); + current_statement__ = 1; + if (jacobian__) { + current_statement__ = 1; + mean_phi = stan::math::lub_constrain(mean_phi, 0, 1, lp__); + } else { + current_statement__ = 1; + mean_phi = stan::math::lub_constrain(mean_phi, 0, 1); + } + local_scalar_t__ mean_p; + + current_statement__ = 2; + mean_p = in__.scalar(); + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + mean_p = stan::math::lub_constrain(mean_p, 0, 1, lp__); + } else { + current_statement__ = 2; + mean_p = stan::math::lub_constrain(mean_p, 0, 1); + } + current_statement__ = 3; + validate_non_negative_index("phi", "nind", nind); + lcm_sym98__ = (n_occasions - 1); + validate_non_negative_index("phi", "n_occ_minus_1", lcm_sym98__); + Eigen::Matrix phi; + phi = Eigen::Matrix(nind, lcm_sym98__); + + lcm_sym87__ = logical_gte(nind, 1); + if (lcm_sym87__) { + lcm_sym88__ = logical_gte(lcm_sym98__, 1); + if (lcm_sym88__) { + lcm_sym119__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym119__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym98__; ++sym2__) { + current_statement__ = 3; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym119__, "assigning variable phi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 3; + if (lcm_sym88__) { + lcm_sym119__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym119__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym98__; ++sym2__) { + current_statement__ = 3; + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym119__, "assigning variable phi");} + } } + } + current_statement__ = 4; + validate_non_negative_index("p", "nind", nind); + current_statement__ = 4; + validate_non_negative_index("p", "n_occ_minus_1", lcm_sym98__); + Eigen::Matrix p; + p = Eigen::Matrix(nind, lcm_sym98__); + + current_statement__ = 4; + if (lcm_sym87__) { + lcm_sym88__ = logical_gte(lcm_sym98__, 1); + if (lcm_sym88__) { + lcm_sym119__ = std::numeric_limits::quiet_NaN(); + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym119__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym98__; ++sym2__) { + current_statement__ = 4; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym119__, "assigning variable p");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 4; + if (lcm_sym88__) { + lcm_sym119__ = std::numeric_limits::quiet_NaN(); + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym119__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym98__; ++sym2__) { + current_statement__ = 4; + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym119__, "assigning variable p");} + } } + } + current_statement__ = 5; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 5; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix chi; + chi = Eigen::Matrix(nind, n_occasions); + + current_statement__ = 5; + if (lcm_sym87__) { + lcm_sym86__ = logical_gte(n_occasions, 1); + if (lcm_sym86__) { + lcm_sym119__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym119__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 5; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym119__, "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 5; + if (lcm_sym86__) { + lcm_sym119__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym119__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 5; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym119__, "assigning variable chi");} + } } + } + current_statement__ = 14; + if (lcm_sym87__) { + lcm_sym121__ = first[(1 - 1)]; + lcm_sym100__ = (lcm_sym121__ - 1); + if (logical_gte(lcm_sym100__, 1)) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable p"); + for (size_t t = 2; t <= lcm_sym100__; ++t) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable p");} + } + current_statement__ = 12; + if (logical_gte(lcm_sym98__, lcm_sym121__)) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym121__), nil_index_list())), + mean_phi, "assigning variable phi"); + lcm_sym106__ = (lcm_sym121__ + 1); + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym121__), nil_index_list())), mean_p, + "assigning variable p"); + for (size_t t = lcm_sym106__; t <= lcm_sym98__; ++t) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), mean_phi, + "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), mean_p, + "assigning variable p");} + } + for (size_t i = 2; i <= nind; ++i) { + lcm_sym120__ = first[(i - 1)]; + lcm_sym99__ = (lcm_sym120__ - 1); + if (logical_gte(lcm_sym99__, 1)) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable p"); + for (size_t t = 2; t <= lcm_sym99__; ++t) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable p");} + } + current_statement__ = 12; + if (logical_gte(lcm_sym98__, lcm_sym120__)) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym120__), nil_index_list())), + mean_phi, "assigning variable phi"); + lcm_sym105__ = (lcm_sym120__ + 1); + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym120__), nil_index_list())), + mean_p, "assigning variable p"); + for (size_t t = lcm_sym105__; t <= lcm_sym98__; ++t) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), mean_phi, + "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), mean_p, + "assigning variable p");} + } } + } + Eigen::Matrix inline_sym11__; + int inline_sym19__; + + inline_sym19__ = 0; + for (size_t inline_sym20__ = 1; inline_sym20__ <= 1; ++inline_sym20__) { + current_statement__ = 15; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 15; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix inline_sym12__; + inline_sym12__ = Eigen::Matrix(nind, n_occasions); + + for (size_t inline_sym14__ = 1; inline_sym14__ <= nind; + ++inline_sym14__) { + if (logical_gte(n_occasions, 1)) { + lcm_sym119__ = std::numeric_limits::quiet_NaN(); + assign(inline_sym12__, + cons_list(index_uni(inline_sym14__), + cons_list(index_uni(1), nil_index_list())), lcm_sym119__, + "assigning variable inline_sym12__"); + for (size_t inline_sym13__ = 2; inline_sym13__ <= n_occasions; + ++inline_sym13__) { + current_statement__ = 15; + assign(inline_sym12__, + cons_list(index_uni(inline_sym14__), + cons_list(index_uni(inline_sym13__), nil_index_list())), + lcm_sym119__, "assigning variable inline_sym12__");} + } + if (inline_sym19__) { + break; + } } + if (inline_sym19__) { + break; + } + for (size_t inline_sym18__ = 1; inline_sym18__ <= nind; + ++inline_sym18__) { + current_statement__ = 16; + assign(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(n_occasions), nil_index_list())), 1.0, + "assigning variable inline_sym12__"); + if (logical_gte(lcm_sym98__, 1)) { + int inline_sym15__; + + int inline_sym16__; + + lcm_sym102__ = (lcm_sym98__ + 1); + current_statement__ = 19; + assign(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym98__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym98__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni((lcm_sym102__ - 1)), + nil_index_list())), "p"))), + rvalue(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym102__), nil_index_list())), + "inline_sym12__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym98__), nil_index_list())), + "phi"))), "assigning variable inline_sym12__"); + for (size_t inline_sym17__ = 2; inline_sym17__ <= lcm_sym98__; + ++inline_sym17__) { + int inline_sym15__; + + lcm_sym97__ = (n_occasions - inline_sym17__); + int inline_sym16__; + + lcm_sym101__ = (lcm_sym97__ + 1); + current_statement__ = 19; + assign(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym97__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym97__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni((lcm_sym101__ - 1)), + nil_index_list())), "p"))), + rvalue(inline_sym12__, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym101__), nil_index_list())), + "inline_sym12__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym18__), + cons_list(index_uni(lcm_sym97__), nil_index_list())), + "phi"))), "assigning variable inline_sym12__");} + } + if (inline_sym19__) { + break; + } } + if (inline_sym19__) { + break; + } + inline_sym19__ = 1; + assign(inline_sym11__, nil_index_list(), inline_sym12__, + "assigning variable inline_sym11__"); + break;} + assign(chi, nil_index_list(), inline_sym11__, "assigning variable chi"); + current_statement__ = 3; + current_statement__ = 3; + check_greater_or_equal(function__, "phi", phi, 0); + current_statement__ = 3; + current_statement__ = 3; + check_less_or_equal(function__, "phi", phi, 1); + current_statement__ = 4; + current_statement__ = 4; + check_greater_or_equal(function__, "p", p, 0); + current_statement__ = 4; + current_statement__ = 4; + check_less_or_equal(function__, "p", p, 1); + current_statement__ = 5; + current_statement__ = 5; + check_greater_or_equal(function__, "chi", inline_sym11__, 0); + current_statement__ = 5; + current_statement__ = 5; + check_less_or_equal(function__, "chi", inline_sym11__, 1); + { + current_statement__ = 29; + if (lcm_sym87__) { + lcm_sym121__ = first[(1 - 1)]; + if (logical_gt(lcm_sym121__, 0)) { + lcm_sym123__ = last[(1 - 1)]; + lcm_sym106__ = (lcm_sym121__ + 1); + if (logical_gte(lcm_sym123__, lcm_sym106__)) { + current_statement__ = 23; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym106__ - 1)), + nil_index_list())), "phi"))); + lcm_sym104__ = (lcm_sym106__ + 1); + lp_accum__.add( + bernoulli_log(y[(1 - 1)][(lcm_sym106__ - 1)], + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((lcm_sym106__ - 1)), + nil_index_list())), "p"))); + for (size_t t = lcm_sym104__; t <= lcm_sym123__; ++t) { + current_statement__ = 23; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni((t - 1)), nil_index_list())), + "phi"))); + current_statement__ = 24; + lp_accum__.add( + bernoulli_log(y[(1 - 1)][(t - 1)], + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni((t - 1)), nil_index_list())), + "p")));} + } + current_statement__ = 26; + lp_accum__.add( + bernoulli_log(1, + rvalue(inline_sym11__, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym123__), nil_index_list())), + "inline_sym11__"))); + } + for (size_t i = 2; i <= nind; ++i) { + lcm_sym120__ = first[(i - 1)]; + if (logical_gt(lcm_sym120__, 0)) { + lcm_sym122__ = last[(i - 1)]; + lcm_sym105__ = (lcm_sym120__ + 1); + if (logical_gte(lcm_sym122__, lcm_sym105__)) { + current_statement__ = 23; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym105__ - 1)), + nil_index_list())), "phi"))); + lcm_sym103__ = (lcm_sym105__ + 1); + lp_accum__.add( + bernoulli_log(y[(i - 1)][(lcm_sym105__ - 1)], + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((lcm_sym105__ - 1)), + nil_index_list())), "p"))); + for (size_t t = lcm_sym103__; t <= lcm_sym122__; ++t) { + current_statement__ = 23; + lp_accum__.add( + bernoulli_log(1, + rvalue(phi, + cons_list(index_uni(i), + cons_list(index_uni((t - 1)), nil_index_list())), + "phi"))); + current_statement__ = 24; + lp_accum__.add( + bernoulli_log(y[(i - 1)][(t - 1)], + rvalue(p, + cons_list(index_uni(i), + cons_list(index_uni((t - 1)), nil_index_list())), + "p")));} + } + current_statement__ = 26; + lp_accum__.add( + bernoulli_log(1, + rvalue(inline_sym11__, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym122__), nil_index_list())), + "inline_sym11__"))); + } } + } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "lcm_fails2_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + double lcm_sym85__; + double lcm_sym84__; + double lcm_sym83__; + double lcm_sym82__; + double lcm_sym81__; + double lcm_sym80__; + double lcm_sym79__; + double lcm_sym78__; + double lcm_sym77__; + double lcm_sym76__; + double lcm_sym75__; + double lcm_sym74__; + int lcm_sym73__; + int lcm_sym72__; + double lcm_sym71__; + double lcm_sym70__; + double lcm_sym69__; + int lcm_sym68__; + int lcm_sym67__; + int lcm_sym66__; + int lcm_sym65__; + int lcm_sym64__; + int lcm_sym63__; + int lcm_sym62__; + int lcm_sym61__; + int lcm_sym60__; + int lcm_sym59__; + int lcm_sym58__; + int lcm_sym57__; + int lcm_sym56__; + int lcm_sym55__; + int lcm_sym54__; + int lcm_sym53__; + int lcm_sym52__; + double mean_phi; + + current_statement__ = 1; + mean_phi = in__.scalar(); + current_statement__ = 1; + mean_phi = stan::math::lub_constrain(mean_phi, 0, 1); + double mean_p; + + current_statement__ = 2; + mean_p = in__.scalar(); + current_statement__ = 2; + mean_p = stan::math::lub_constrain(mean_p, 0, 1); + current_statement__ = 3; + validate_non_negative_index("phi", "nind", nind); + lcm_sym60__ = (n_occasions - 1); + validate_non_negative_index("phi", "n_occ_minus_1", lcm_sym60__); + Eigen::Matrix phi; + phi = Eigen::Matrix(nind, lcm_sym60__); + + lcm_sym53__ = logical_gte(nind, 1); + if (lcm_sym53__) { + { + lcm_sym54__ = logical_gte(lcm_sym60__, 1); + if (lcm_sym54__) { + lcm_sym71__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym71__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym60__; ++sym2__) { + current_statement__ = 3; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym71__, "assigning variable phi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 3; + if (lcm_sym54__) { + lcm_sym71__ = std::numeric_limits::quiet_NaN(); + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym71__, + "assigning variable phi"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym60__; ++sym2__) { + current_statement__ = 3; + assign(phi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym71__, "assigning variable phi");} + } } + } + } else { + lcm_sym54__ = logical_gte(lcm_sym60__, 1); + } + current_statement__ = 4; + validate_non_negative_index("p", "nind", nind); + current_statement__ = 4; + validate_non_negative_index("p", "n_occ_minus_1", lcm_sym60__); + Eigen::Matrix p; + p = Eigen::Matrix(nind, lcm_sym60__); + + current_statement__ = 4; + if (lcm_sym53__) { + current_statement__ = 4; + if (lcm_sym54__) { + lcm_sym71__ = std::numeric_limits::quiet_NaN(); + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym71__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym60__; ++sym2__) { + current_statement__ = 4; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), lcm_sym71__, + "assigning variable p");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 4; + if (lcm_sym54__) { + lcm_sym71__ = std::numeric_limits::quiet_NaN(); + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym71__, + "assigning variable p"); + for (size_t sym2__ = 2; sym2__ <= lcm_sym60__; ++sym2__) { + current_statement__ = 4; + assign(p, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym71__, "assigning variable p");} + } } + } + current_statement__ = 5; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 5; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix chi; + chi = Eigen::Matrix(nind, n_occasions); + + current_statement__ = 5; + if (lcm_sym53__) { + { + lcm_sym52__ = logical_gte(n_occasions, 1); + if (lcm_sym52__) { + lcm_sym71__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym71__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 5; + assign(chi, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym71__, "assigning variable chi");} + } + for (size_t sym1__ = 2; sym1__ <= nind; ++sym1__) { + current_statement__ = 5; + if (lcm_sym52__) { + lcm_sym71__ = std::numeric_limits::quiet_NaN(); + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym71__, + "assigning variable chi"); + for (size_t sym2__ = 2; sym2__ <= n_occasions; ++sym2__) { + current_statement__ = 5; + assign(chi, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym71__, "assigning variable chi");} + } } + } + } else { + lcm_sym52__ = logical_gte(n_occasions, 1); + } + vars__.push_back(mean_phi); + vars__.push_back(mean_p); + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + current_statement__ = 14; + if (lcm_sym53__) { + lcm_sym73__ = first[(1 - 1)]; + lcm_sym62__ = (lcm_sym73__ - 1); + if (logical_gte(lcm_sym62__, 1)) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable p"); + for (size_t t = 2; t <= lcm_sym62__; ++t) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable p");} + } + current_statement__ = 12; + if (logical_gte(lcm_sym60__, lcm_sym73__)) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym73__), nil_index_list())), mean_phi, + "assigning variable phi"); + lcm_sym68__ = (lcm_sym73__ + 1); + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(lcm_sym73__), nil_index_list())), mean_p, + "assigning variable p"); + for (size_t t = lcm_sym68__; t <= lcm_sym60__; ++t) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), mean_phi, + "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(1), + cons_list(index_uni(t), nil_index_list())), mean_p, + "assigning variable p");} + } + for (size_t i = 2; i <= nind; ++i) { + lcm_sym72__ = first[(i - 1)]; + lcm_sym61__ = (lcm_sym72__ - 1); + if (logical_gte(lcm_sym61__, 1)) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(1), nil_index_list())), 0, + "assigning variable p"); + for (size_t t = 2; t <= lcm_sym61__; ++t) { + current_statement__ = 6; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable phi"); + current_statement__ = 7; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), 0, + "assigning variable p");} + } + current_statement__ = 12; + if (logical_gte(lcm_sym60__, lcm_sym72__)) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym72__), nil_index_list())), + mean_phi, "assigning variable phi"); + lcm_sym67__ = (lcm_sym72__ + 1); + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(lcm_sym72__), nil_index_list())), mean_p, + "assigning variable p"); + for (size_t t = lcm_sym67__; t <= lcm_sym60__; ++t) { + current_statement__ = 9; + assign(phi, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), mean_phi, + "assigning variable phi"); + current_statement__ = 10; + assign(p, + cons_list(index_uni(i), + cons_list(index_uni(t), nil_index_list())), mean_p, + "assigning variable p");} + } } + } + Eigen::Matrix inline_sym1__; + int inline_sym9__; + + inline_sym9__ = 0; + for (size_t inline_sym10__ = 1; inline_sym10__ <= 1; ++inline_sym10__) { + current_statement__ = 15; + validate_non_negative_index("chi", "nind", nind); + current_statement__ = 15; + validate_non_negative_index("chi", "n_occasions", n_occasions); + Eigen::Matrix inline_sym2__; + inline_sym2__ = Eigen::Matrix(nind, n_occasions); + + for (size_t inline_sym4__ = 1; inline_sym4__ <= nind; ++inline_sym4__) { + if (lcm_sym52__) { + lcm_sym71__ = std::numeric_limits::quiet_NaN(); + assign(inline_sym2__, + cons_list(index_uni(inline_sym4__), + cons_list(index_uni(1), nil_index_list())), lcm_sym71__, + "assigning variable inline_sym2__"); + for (size_t inline_sym3__ = 2; inline_sym3__ <= n_occasions; + ++inline_sym3__) { + current_statement__ = 15; + assign(inline_sym2__, + cons_list(index_uni(inline_sym4__), + cons_list(index_uni(inline_sym3__), nil_index_list())), + lcm_sym71__, "assigning variable inline_sym2__");} + } + if (inline_sym9__) { + break; + } } + if (inline_sym9__) { + break; + } + for (size_t inline_sym8__ = 1; inline_sym8__ <= nind; ++inline_sym8__) { + current_statement__ = 16; + assign(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(n_occasions), nil_index_list())), 1.0, + "assigning variable inline_sym2__"); + if (lcm_sym54__) { + int inline_sym5__; + + int inline_sym6__; + + lcm_sym66__ = (lcm_sym60__ + 1); + current_statement__ = 19; + assign(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym60__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym60__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni((lcm_sym66__ - 1)), + nil_index_list())), "p"))), + rvalue(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym66__), nil_index_list())), + "inline_sym2__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym60__), nil_index_list())), + "phi"))), "assigning variable inline_sym2__"); + for (size_t inline_sym7__ = 2; inline_sym7__ <= lcm_sym60__; + ++inline_sym7__) { + int inline_sym5__; + + lcm_sym59__ = (n_occasions - inline_sym7__); + int inline_sym6__; + + lcm_sym65__ = (lcm_sym59__ + 1); + current_statement__ = 19; + assign(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym59__), nil_index_list())), + stan::math::fma( + (rvalue(phi, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym59__), nil_index_list())), + "phi") * + (1 - + rvalue(p, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni((lcm_sym65__ - 1)), + nil_index_list())), "p"))), + rvalue(inline_sym2__, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym65__), nil_index_list())), + "inline_sym2__"), + (1 - + rvalue(phi, + cons_list(index_uni(inline_sym8__), + cons_list(index_uni(lcm_sym59__), nil_index_list())), + "phi"))), "assigning variable inline_sym2__");} + } + if (inline_sym9__) { + break; + } } + if (inline_sym9__) { + break; + } + inline_sym9__ = 1; + assign(inline_sym1__, nil_index_list(), inline_sym2__, + "assigning variable inline_sym1__"); + break;} + assign(chi, nil_index_list(), inline_sym1__, "assigning variable chi"); + if (lcm_sym54__) { + if (lcm_sym53__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "phi")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), "phi"));} + } + for (size_t sym1__ = 2; sym1__ <= lcm_sym60__; ++sym1__) { + if (lcm_sym53__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), "phi")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(phi, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "phi")); + } + } } + } + if (lcm_sym54__) { + if (lcm_sym53__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "p")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), "p"));} + } + for (size_t sym1__ = 2; sym1__ <= lcm_sym60__; ++sym1__) { + if (lcm_sym53__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), "p")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(p, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "p"));} + } } + } + if (lcm_sym52__) { + if (lcm_sym53__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "inline_sym1__")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + "inline_sym1__"));} + } + for (size_t sym1__ = 2; sym1__ <= n_occasions; ++sym1__) { + if (lcm_sym53__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + "inline_sym1__")); + for (size_t sym2__ = 2; sym2__ <= nind; ++sym2__) { + vars__.push_back( + rvalue(inline_sym1__, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "inline_sym1__"));} + } } + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + int pos__; + + pos__ = 1; + double mean_phi; + + current_statement__ = 1; + mean_phi = context__.vals_r("mean_phi")[(1 - 1)]; + current_statement__ = 1; + mean_phi = stan::math::lub_free(mean_phi, 0, 1); + double mean_p; + + current_statement__ = 2; + mean_p = context__.vals_r("mean_p")[(1 - 1)]; + current_statement__ = 2; + mean_p = stan::math::lub_free(mean_p, 0, 1); + vars__.push_back(mean_phi); + vars__.push_back(mean_p); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("mean_phi"); + names__.push_back("mean_p"); + names__.push_back("phi"); + names__.push_back("p"); + names__.push_back("chi"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(nind); + + dims__.push_back(n_occ_minus_1); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(nind); + + dims__.push_back(n_occ_minus_1); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(nind); + + dims__.push_back(n_occasions); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "mean_phi"); + param_names__.push_back(std::string() + "mean_p"); + if (emit_transformed_parameters__) { + for (size_t sym148__ = 1; sym148__ <= n_occ_minus_1; ++sym148__) { + { + for (size_t sym149__ = 1; sym149__ <= nind; ++sym149__) { + { + param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym149__) + '.' + std::to_string(sym148__)); + }} + }} + for (size_t sym148__ = 1; sym148__ <= n_occ_minus_1; ++sym148__) { + { + for (size_t sym149__ = 1; sym149__ <= nind; ++sym149__) { + { + param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym149__) + '.' + std::to_string(sym148__)); + }} + }} + for (size_t sym148__ = 1; sym148__ <= n_occasions; ++sym148__) { + { + for (size_t sym149__ = 1; sym149__ <= nind; ++sym149__) { + { + param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym149__) + '.' + std::to_string(sym148__)); + }} + }} + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "mean_phi"); + param_names__.push_back(std::string() + "mean_p"); + if (emit_transformed_parameters__) { + for (size_t sym148__ = 1; sym148__ <= n_occ_minus_1; ++sym148__) { + { + for (size_t sym149__ = 1; sym149__ <= nind; ++sym149__) { + { + param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym149__) + '.' + std::to_string(sym148__)); + }} + }} + for (size_t sym148__ = 1; sym148__ <= n_occ_minus_1; ++sym148__) { + { + for (size_t sym149__ = 1; sym149__ <= nind; ++sym149__) { + { + param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym149__) + '.' + std::to_string(sym148__)); + }} + }} + for (size_t sym148__ = 1; sym148__ <= n_occasions; ++sym148__) { + { + for (size_t sym149__ = 1; sym149__ <= nind; ++sym149__) { + { + param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym149__) + '.' + std::to_string(sym148__)); + }} + }} + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mean_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mean_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef lcm_fails2_model_namespace::lcm_fails2_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp off-dce.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace off_dce_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'off-dce.stan', line 23, column 2 to column 17)", + " (in 'off-dce.stan', line 24, column 2 to column 16)", + " (in 'off-dce.stan', line 25, column 2 to column 15)", + " (in 'off-dce.stan', line 26, column 2 to column 14)", + " (in 'off-dce.stan', line 30, column 2 to column 22)", + " (in 'off-dce.stan', line 31, column 2 to column 23)", + " (in 'off-dce.stan', line 58, column 2 to column 13)", + " (in 'off-dce.stan', line 59, column 2 to column 18)", + " (in 'off-dce.stan', line 60, column 2 to column 11)", + " (in 'off-dce.stan', line 70, column 6 to column 21)", + " (in 'off-dce.stan', line 71, column 6 to column 15)", + " (in 'off-dce.stan', line 69, column 11 to line 72, column 5)", + " (in 'off-dce.stan', line 64, column 6 to column 41)", + " (in 'off-dce.stan', line 65, column 6 to column 44)", + " (in 'off-dce.stan', line 66, column 6 to column 26)", + " (in 'off-dce.stan', line 67, column 6 to column 55)", + " (in 'off-dce.stan', line 68, column 6 to column 39)", + " (in 'off-dce.stan', line 63, column 23 to line 69, column 5)", + " (in 'off-dce.stan', line 63, column 4 to line 72, column 5)", + " (in 'off-dce.stan', line 62, column 17 to line 73, column 3)", + " (in 'off-dce.stan', line 62, column 2 to line 73, column 3)", + " (in 'off-dce.stan', line 49, column 6 to line 52, column 68)", + " (in 'off-dce.stan', line 47, column 11 to line 53, column 5)", + " (in 'off-dce.stan', line 45, column 6 to column 40)", + " (in 'off-dce.stan', line 46, column 6 to column 41)", + " (in 'off-dce.stan', line 44, column 18 to line 47, column 5)", + " (in 'off-dce.stan', line 44, column 4 to line 53, column 5)", + " (in 'off-dce.stan', line 43, column 17 to line 54, column 3)", + " (in 'off-dce.stan', line 43, column 2 to line 54, column 3)", + " (in 'off-dce.stan', line 4, column 2 to column 17)", + " (in 'off-dce.stan', line 5, column 2 to column 17)", + " (in 'off-dce.stan', line 6, column 2 to column 31)", + " (in 'off-dce.stan', line 7, column 2 to column 14)", + " (in 'off-dce.stan', line 11, column 2 to column 32)", + " (in 'off-dce.stan', line 12, column 2 to column 31)", + " (in 'off-dce.stan', line 14, column 2 to column 14)", + " (in 'off-dce.stan', line 16, column 4 to column 25)", + " (in 'off-dce.stan', line 18, column 6 to column 28)", + " (in 'off-dce.stan', line 17, column 4 to line 18, column 28)", + " (in 'off-dce.stan', line 15, column 17 to line 19, column 3)", + " (in 'off-dce.stan', line 15, column 2 to line 19, column 3)"}; + + + +class off_dce_model : public model_base_crtp { + + private: + int lcm_sym60__; + int lcm_sym59__; + int lcm_sym58__; + int lcm_sym57__; + int lcm_sym56__; + int lcm_sym55__; + int lcm_sym54__; + int lcm_sym53__; + int lcm_sym52__; + double lcm_sym51__; + double lcm_sym50__; + int lcm_sym49__; + int lcm_sym48__; + int lcm_sym47__; + int lcm_sym46__; + int lcm_sym45__; + int lcm_sym44__; + int pos__; + int R; + int T; + std::vector> y; + Eigen::Matrix X; + std::vector sum_y; + int occ_obs; + + public: + ~off_dce_model() { } + + std::string model_name() const { return "off_dce_model"; } + + off_dce_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "off_dce_model_namespace::off_dce_model"; + (void) function__; // suppress unused var warning + + try { + + + + + + + + + + + + + + + + + + + pos__ = 1; + context__.validate_dims("data initialization","R","int", + context__.to_vec()); + + current_statement__ = 30; + R = context__.vals_i("R")[(1 - 1)]; + context__.validate_dims("data initialization","T","int", + context__.to_vec()); + + current_statement__ = 31; + T = context__.vals_i("T")[(1 - 1)]; + current_statement__ = 32; + validate_non_negative_index("y", "R", R); + current_statement__ = 32; + validate_non_negative_index("y", "T", T); + context__.validate_dims("data initialization","y","int", + context__.to_vec(R, T)); + y = std::vector>(R, std::vector(T, 0)); + + { + std::vector y_flat__; + current_statement__ = 32; + assign(y_flat__, nil_index_list(), context__.vals_i("y"), + "assigning variable y_flat__"); + current_statement__ = 32; + pos__ = 1; + lcm_sym45__ = logical_gte(T, 1); + if (lcm_sym45__) { + { + lcm_sym44__ = logical_gte(R, 1); + if (lcm_sym44__) { + current_statement__ = 32; + assign(y, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + y_flat__[(1 - 1)], "assigning variable y"); + current_statement__ = 32; + pos__ = 2; + for (size_t sym2__ = 2; sym2__ <= R; ++sym2__) { + current_statement__ = 32; + assign(y, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 32; + pos__ = (pos__ + 1);} + } + for (size_t sym1__ = 2; sym1__ <= T; ++sym1__) { + current_statement__ = 32; + if (lcm_sym44__) { + current_statement__ = 32; + assign(y, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 32; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= R; ++sym2__) { + current_statement__ = 32; + assign(y, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 32; + pos__ = (pos__ + 1);} + } } + } + } else { + lcm_sym44__ = logical_gte(R, 1); + } + } + current_statement__ = 33; + validate_non_negative_index("X", "R", R); + context__.validate_dims("data initialization","X","double", + context__.to_vec(R)); + X = Eigen::Matrix(R); + + { + std::vector X_flat__; + current_statement__ = 33; + assign(X_flat__, nil_index_list(), context__.vals_r("X"), + "assigning variable X_flat__"); + current_statement__ = 33; + pos__ = 1; + current_statement__ = 33; + if (lcm_sym44__) { + current_statement__ = 33; + assign(X, cons_list(index_uni(1), nil_index_list()), + X_flat__[(1 - 1)], "assigning variable X"); + current_statement__ = 33; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= R; ++sym1__) { + current_statement__ = 33; + assign(X, cons_list(index_uni(sym1__), nil_index_list()), + X_flat__[(pos__ - 1)], "assigning variable X"); + current_statement__ = 33; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 34; + validate_non_negative_index("sum_y", "R", R); + sum_y = std::vector(R, 0); + + + current_statement__ = 36; + occ_obs = 0; + current_statement__ = 41; + if (lcm_sym44__) { + current_statement__ = 37; + assign(sum_y, cons_list(index_uni(1), nil_index_list()), + sum(y[(1 - 1)]), "assigning variable sum_y"); + current_statement__ = 39; + if (sum_y[(1 - 1)]) { + current_statement__ = 38; + occ_obs = 1; + } + for (size_t i = 2; i <= R; ++i) { + current_statement__ = 37; + assign(sum_y, cons_list(index_uni(i), nil_index_list()), + sum(y[(i - 1)]), "assigning variable sum_y"); + current_statement__ = 39; + if (sum_y[(i - 1)]) { + current_statement__ = 38; + occ_obs = (occ_obs + 1); + } } + } + current_statement__ = 30; + current_statement__ = 30; + check_greater_or_equal(function__, "R", R, 1); + current_statement__ = 31; + current_statement__ = 31; + check_greater_or_equal(function__, "T", T, 1); + current_statement__ = 32; + if (lcm_sym44__) { + current_statement__ = 32; + if (lcm_sym45__) { + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= T; ++sym2__) { + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(sym2__ - 1)], 0);} + } + for (size_t sym1__ = 2; sym1__ <= R; ++sym1__) { + current_statement__ = 32; + if (lcm_sym45__) { + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(1 - 1)], 0); + for (size_t sym2__ = 2; sym2__ <= T; ++sym2__) { + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(sym2__ - 1)], 0);} + } } + } + current_statement__ = 32; + if (lcm_sym44__) { + current_statement__ = 32; + if (lcm_sym45__) { + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= T; ++sym2__) { + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(1 - 1)][(sym2__ - 1)], 1);} + } + for (size_t sym1__ = 2; sym1__ <= R; ++sym1__) { + current_statement__ = 32; + if (lcm_sym45__) { + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(1 - 1)], 1); + for (size_t sym2__ = 2; sym2__ <= T; ++sym2__) { + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "y[sym1__, sym2__]", + y[(sym1__ - 1)][(sym2__ - 1)], 1);} + } } + } + current_statement__ = 34; + if (lcm_sym44__) { + current_statement__ = 34; + current_statement__ = 34; + check_greater_or_equal(function__, "sum_y[sym1__]", sum_y[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= R; ++sym1__) { + current_statement__ = 34; + current_statement__ = 34; + check_greater_or_equal(function__, "sum_y[sym1__]", + sum_y[(sym1__ - 1)], 0);} + } + current_statement__ = 34; + if (lcm_sym44__) { + current_statement__ = 34; + current_statement__ = 34; + check_less_or_equal(function__, "sum_y[sym1__]", sum_y[(1 - 1)], T); + for (size_t sym1__ = 2; sym1__ <= R; ++sym1__) { + current_statement__ = 34; + current_statement__ = 34; + check_less_or_equal(function__, "sum_y[sym1__]", + sum_y[(sym1__ - 1)], T);} + } + current_statement__ = 35; + current_statement__ = 35; + check_greater_or_equal(function__, "occ_obs", occ_obs, 0); + current_statement__ = 35; + current_statement__ = 35; + check_less_or_equal(function__, "occ_obs", occ_obs, R); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "off_dce_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + int lcm_sym43__; + int lcm_sym42__; + double lcm_sym41__; + Eigen::Matrix lcm_sym40__; + double lcm_sym39__; + double lcm_sym38__; + double lcm_sym37__; + double lcm_sym36__; + double lcm_sym35__; + double lcm_sym34__; + Eigen::Matrix lcm_sym33__; + int lcm_sym32__; + int lcm_sym31__; + local_scalar_t__ alpha_occ; + + current_statement__ = 1; + alpha_occ = in__.scalar(); + local_scalar_t__ beta_occ; + + current_statement__ = 2; + beta_occ = in__.scalar(); + local_scalar_t__ alpha_p; + + current_statement__ = 3; + alpha_p = in__.scalar(); + local_scalar_t__ beta_p; + + current_statement__ = 4; + beta_p = in__.scalar(); + current_statement__ = 5; + validate_non_negative_index("logit_psi", "R", R); + Eigen::Matrix logit_psi; + logit_psi = Eigen::Matrix(R); + + lcm_sym31__ = logical_gte(R, 1); + if (lcm_sym31__) { + lcm_sym41__ = std::numeric_limits::quiet_NaN(); + assign(logit_psi, cons_list(index_uni(1), nil_index_list()), + lcm_sym41__, "assigning variable logit_psi"); + for (size_t sym1__ = 2; sym1__ <= R; ++sym1__) { + current_statement__ = 5; + assign(logit_psi, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym41__, "assigning variable logit_psi");} + } + current_statement__ = 6; + validate_non_negative_index("logit_p", "R", R); + current_statement__ = 6; + validate_non_negative_index("logit_p", "T", T); + Eigen::Matrix logit_p; + logit_p = Eigen::Matrix(R, T); + + current_statement__ = 6; + if (lcm_sym31__) { + lcm_sym32__ = logical_gte(T, 1); + if (lcm_sym32__) { + lcm_sym41__ = std::numeric_limits::quiet_NaN(); + assign(logit_p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym41__, + "assigning variable logit_p"); + for (size_t sym2__ = 2; sym2__ <= T; ++sym2__) { + current_statement__ = 6; + assign(logit_p, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), lcm_sym41__, + "assigning variable logit_p");} + } + for (size_t sym1__ = 2; sym1__ <= R; ++sym1__) { + current_statement__ = 6; + if (lcm_sym32__) { + lcm_sym41__ = std::numeric_limits::quiet_NaN(); + assign(logit_p, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym41__, + "assigning variable logit_p"); + for (size_t sym2__ = 2; sym2__ <= T; ++sym2__) { + current_statement__ = 6; + assign(logit_p, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym41__, "assigning variable logit_p");} + } } + } + assign(lcm_sym33__, nil_index_list(), + add(alpha_occ, multiply(beta_occ, X)), + "assigning variable lcm_sym33__"); + assign(logit_psi, nil_index_list(), lcm_sym33__, + "assigning variable logit_psi"); + assign(lcm_sym40__, nil_index_list(), + rep_matrix(add(alpha_p, multiply(beta_p, X)), T), + "assigning variable lcm_sym40__"); + assign(logit_p, nil_index_list(), lcm_sym40__, + "assigning variable logit_p"); + { + current_statement__ = 29; + if (lcm_sym31__) { + current_statement__ = 27; + if (sum_y[(1 - 1)]) { + current_statement__ = 24; + lp_accum__.add( + bernoulli_logit_log(1, lcm_sym33__[(1 - 1)])); + current_statement__ = 25; + lp_accum__.add( + bernoulli_logit_log(y[(1 - 1)], + rvalue(lcm_sym40__, + cons_list(index_uni(1), nil_index_list()), "lcm_sym40__"))); + } else { + current_statement__ = 22; + lp_accum__.add( + log_sum_exp( + (bernoulli_logit_lpmf(1, lcm_sym33__[(1 - 1)]) + + bernoulli_logit_lpmf(0, + rvalue(lcm_sym40__, + cons_list(index_uni(1), nil_index_list()), + "lcm_sym40__"))), + bernoulli_logit_lpmf(0, lcm_sym33__[(1 - 1)]))); + } + for (size_t i = 2; i <= R; ++i) { + current_statement__ = 27; + if (sum_y[(i - 1)]) { + current_statement__ = 24; + lp_accum__.add( + bernoulli_logit_log(1, lcm_sym33__[(i - 1)])); + current_statement__ = 25; + lp_accum__.add( + bernoulli_logit_log(y[(i - 1)], + rvalue(lcm_sym40__, + cons_list(index_uni(i), nil_index_list()), "lcm_sym40__"))); + } else { + current_statement__ = 22; + lp_accum__.add( + log_sum_exp( + (bernoulli_logit_lpmf(1, lcm_sym33__[(i - 1)]) + + bernoulli_logit_lpmf(0, + rvalue(lcm_sym40__, + cons_list(index_uni(i), nil_index_list()), + "lcm_sym40__"))), + bernoulli_logit_lpmf(0, lcm_sym33__[(i - 1)]))); + }} + } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "off_dce_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + double lcm_sym30__; + double lcm_sym29__; + double lcm_sym28__; + double lcm_sym27__; + double lcm_sym26__; + double lcm_sym25__; + int lcm_sym24__; + int lcm_sym23__; + double lcm_sym22__; + double lcm_sym21__; + double lcm_sym12__; + double lcm_sym20__; + int lcm_sym19__; + Eigen::Matrix lcm_sym18__; + double lcm_sym17__; + double lcm_sym16__; + local_scalar_t__ lcm_sym15__; + local_scalar_t__ lcm_sym14__; + Eigen::Matrix lcm_sym11__; + Eigen::Matrix lcm_sym10__; + Eigen::Matrix lcm_sym9__; + int lcm_sym8__; + int lcm_sym7__; + int lcm_sym6__; + int lcm_sym5__; + int lcm_sym4__; + int lcm_sym3__; + double lcm_sym2__; + double lcm_sym1__; + double alpha_occ; + + current_statement__ = 1; + alpha_occ = in__.scalar(); + double beta_occ; + + current_statement__ = 2; + beta_occ = in__.scalar(); + double alpha_p; + + current_statement__ = 3; + alpha_p = in__.scalar(); + double beta_p; + + current_statement__ = 4; + beta_p = in__.scalar(); + current_statement__ = 5; + validate_non_negative_index("logit_psi", "R", R); + Eigen::Matrix logit_psi; + logit_psi = Eigen::Matrix(R); + + lcm_sym5__ = logical_gte(R, 1); + if (lcm_sym5__) { + lcm_sym20__ = std::numeric_limits::quiet_NaN(); + assign(logit_psi, cons_list(index_uni(1), nil_index_list()), + lcm_sym20__, "assigning variable logit_psi"); + for (size_t sym1__ = 2; sym1__ <= R; ++sym1__) { + current_statement__ = 5; + assign(logit_psi, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym20__, "assigning variable logit_psi");} + } + current_statement__ = 6; + validate_non_negative_index("logit_p", "R", R); + current_statement__ = 6; + validate_non_negative_index("logit_p", "T", T); + Eigen::Matrix logit_p; + logit_p = Eigen::Matrix(R, T); + + current_statement__ = 6; + if (lcm_sym5__) { + { + lcm_sym6__ = logical_gte(T, 1); + if (lcm_sym6__) { + lcm_sym20__ = std::numeric_limits::quiet_NaN(); + assign(logit_p, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), lcm_sym20__, + "assigning variable logit_p"); + for (size_t sym2__ = 2; sym2__ <= T; ++sym2__) { + current_statement__ = 6; + assign(logit_p, + cons_list(index_uni(1), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym20__, "assigning variable logit_p");} + } + for (size_t sym1__ = 2; sym1__ <= R; ++sym1__) { + current_statement__ = 6; + if (lcm_sym6__) { + lcm_sym20__ = std::numeric_limits::quiet_NaN(); + assign(logit_p, + cons_list(index_uni(sym1__), + cons_list(index_uni(1), nil_index_list())), lcm_sym20__, + "assigning variable logit_p"); + for (size_t sym2__ = 2; sym2__ <= T; ++sym2__) { + current_statement__ = 6; + assign(logit_p, + cons_list(index_uni(sym1__), + cons_list(index_uni(sym2__), nil_index_list())), + lcm_sym20__, "assigning variable logit_p");} + } } + } + } else { + lcm_sym6__ = logical_gte(T, 1); + } + vars__.push_back(alpha_occ); + vars__.push_back(beta_occ); + vars__.push_back(alpha_p); + vars__.push_back(beta_p); + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + assign(lcm_sym9__, nil_index_list(), + add(alpha_occ, multiply(beta_occ, X)), + "assigning variable lcm_sym9__"); + assign(logit_psi, nil_index_list(), lcm_sym9__, + "assigning variable logit_psi"); + assign(lcm_sym18__, nil_index_list(), + rep_matrix(add(alpha_p, multiply(beta_p, X)), T), + "assigning variable lcm_sym18__"); + assign(logit_p, nil_index_list(), lcm_sym18__, + "assigning variable logit_p"); + if (lcm_sym5__) { + vars__.push_back(lcm_sym9__[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= R; ++sym1__) { + vars__.push_back(lcm_sym9__[(sym1__ - 1)]);} + } + if (lcm_sym6__) { + if (lcm_sym5__) { + vars__.push_back( + rvalue(lcm_sym18__, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "lcm_sym18__")); + for (size_t sym2__ = 2; sym2__ <= R; ++sym2__) { + vars__.push_back( + rvalue(lcm_sym18__, + cons_list(index_uni(sym2__), + cons_list(index_uni(1), nil_index_list())), "lcm_sym18__")); + } + } + for (size_t sym1__ = 2; sym1__ <= T; ++sym1__) { + if (lcm_sym5__) { + vars__.push_back( + rvalue(lcm_sym18__, + cons_list(index_uni(1), + cons_list(index_uni(sym1__), nil_index_list())), + "lcm_sym18__")); + for (size_t sym2__ = 2; sym2__ <= R; ++sym2__) { + vars__.push_back( + rvalue(lcm_sym18__, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "lcm_sym18__"));} + } } + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + int occ_fs; + + current_statement__ = 8; + validate_non_negative_index("psi_con", "R", R); + std::vector psi_con; + psi_con = std::vector(R, 0); + + current_statement__ = 9; + validate_non_negative_index("z", "R", R); + std::vector z; + z = std::vector(R, 0); + + current_statement__ = 21; + if (lcm_sym5__) { + current_statement__ = 19; + if (logical_eq(sum_y[(1 - 1)], 0)) { + double psi; + + lcm_sym15__ = inv_logit(lcm_sym9__[(1 - 1)]); + current_statement__ = 14; + validate_non_negative_index("q", "T", T); + Eigen::Matrix q; + q = Eigen::Matrix(T); + + assign(lcm_sym11__, nil_index_list(), + transpose( + inv_logit( + minus( + rvalue(lcm_sym18__, + cons_list(index_uni(1), nil_index_list()), "lcm_sym18__")))), + "assigning variable lcm_sym11__"); + double qT; + + lcm_sym17__ = prod(lcm_sym11__); + current_statement__ = 16; + assign(psi_con, cons_list(index_uni(1), nil_index_list()), + ((lcm_sym15__ * lcm_sym17__) / + stan::math::fma(lcm_sym15__, lcm_sym17__, (1 - lcm_sym15__))), + "assigning variable psi_con"); + current_statement__ = 17; + assign(z, cons_list(index_uni(1), nil_index_list()), + bernoulli_rng(psi_con[(1 - 1)], base_rng__), + "assigning variable z"); + } else { + current_statement__ = 10; + assign(psi_con, cons_list(index_uni(1), nil_index_list()), 1, + "assigning variable psi_con"); + current_statement__ = 11; + assign(z, cons_list(index_uni(1), nil_index_list()), 1, + "assigning variable z"); + } + for (size_t i = 2; i <= R; ++i) { + current_statement__ = 19; + if (logical_eq(sum_y[(i - 1)], 0)) { + double psi; + + lcm_sym14__ = inv_logit(lcm_sym9__[(i - 1)]); + current_statement__ = 14; + validate_non_negative_index("q", "T", T); + Eigen::Matrix q; + q = Eigen::Matrix(T); + + assign(lcm_sym10__, nil_index_list(), + transpose( + inv_logit( + minus( + rvalue(lcm_sym18__, + cons_list(index_uni(i), nil_index_list()), + "lcm_sym18__")))), "assigning variable lcm_sym10__"); + double qT; + + lcm_sym16__ = prod(lcm_sym10__); + current_statement__ = 16; + assign(psi_con, cons_list(index_uni(i), nil_index_list()), + ((lcm_sym14__ * lcm_sym16__) / + stan::math::fma(lcm_sym14__, lcm_sym16__, (1 - lcm_sym14__))), + "assigning variable psi_con"); + current_statement__ = 17; + assign(z, cons_list(index_uni(i), nil_index_list()), + bernoulli_rng(psi_con[(i - 1)], base_rng__), + "assigning variable z"); + } else { + current_statement__ = 10; + assign(psi_con, cons_list(index_uni(i), nil_index_list()), 1, + "assigning variable psi_con"); + current_statement__ = 11; + assign(z, cons_list(index_uni(i), nil_index_list()), 1, + "assigning variable z"); + }} + } + lcm_sym19__ = sum(z); + occ_fs = lcm_sym19__; + vars__.push_back(lcm_sym19__); + if (lcm_sym5__) { + vars__.push_back(psi_con[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= R; ++sym1__) { + vars__.push_back(psi_con[(sym1__ - 1)]);} + } + if (lcm_sym5__) { + vars__.push_back(z[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= R; ++sym1__) { + vars__.push_back(z[(sym1__ - 1)]);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + int pos__; + + pos__ = 1; + double alpha_occ; + + current_statement__ = 1; + alpha_occ = context__.vals_r("alpha_occ")[(1 - 1)]; + double beta_occ; + + current_statement__ = 2; + beta_occ = context__.vals_r("beta_occ")[(1 - 1)]; + double alpha_p; + + current_statement__ = 3; + alpha_p = context__.vals_r("alpha_p")[(1 - 1)]; + double beta_p; + + current_statement__ = 4; + beta_p = context__.vals_r("beta_p")[(1 - 1)]; + vars__.push_back(alpha_occ); + vars__.push_back(beta_occ); + vars__.push_back(alpha_p); + vars__.push_back(beta_p); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("alpha_occ"); + names__.push_back("beta_occ"); + names__.push_back("alpha_p"); + names__.push_back("beta_p"); + names__.push_back("logit_psi"); + names__.push_back("logit_p"); + names__.push_back("occ_fs"); + names__.push_back("psi_con"); + names__.push_back("z"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(R); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(R); + + dims__.push_back(T); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(R); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(R); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "alpha_occ"); + param_names__.push_back(std::string() + "beta_occ"); + param_names__.push_back(std::string() + "alpha_p"); + param_names__.push_back(std::string() + "beta_p"); + if (emit_transformed_parameters__) { + for (size_t sym61__ = 1; sym61__ <= R; ++sym61__) { + { + param_names__.push_back(std::string() + "logit_psi" + '.' + std::to_string(sym61__)); + }} + for (size_t sym61__ = 1; sym61__ <= T; ++sym61__) { + { + for (size_t sym62__ = 1; sym62__ <= R; ++sym62__) { + { + param_names__.push_back(std::string() + "logit_p" + '.' + std::to_string(sym62__) + '.' + std::to_string(sym61__)); + }} + }} + } + + if (emit_generated_quantities__) { + param_names__.push_back(std::string() + "occ_fs"); + for (size_t sym61__ = 1; sym61__ <= R; ++sym61__) { + { + param_names__.push_back(std::string() + "psi_con" + '.' + std::to_string(sym61__)); + }} + for (size_t sym61__ = 1; sym61__ <= R; ++sym61__) { + { + param_names__.push_back(std::string() + "z" + '.' + std::to_string(sym61__)); + }} + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "alpha_occ"); + param_names__.push_back(std::string() + "beta_occ"); + param_names__.push_back(std::string() + "alpha_p"); + param_names__.push_back(std::string() + "beta_p"); + if (emit_transformed_parameters__) { + for (size_t sym61__ = 1; sym61__ <= R; ++sym61__) { + { + param_names__.push_back(std::string() + "logit_psi" + '.' + std::to_string(sym61__)); + }} + for (size_t sym61__ = 1; sym61__ <= T; ++sym61__) { + { + for (size_t sym62__ = 1; sym62__ <= R; ++sym62__) { + { + param_names__.push_back(std::string() + "logit_p" + '.' + std::to_string(sym62__) + '.' + std::to_string(sym61__)); + }} + }} + } + + if (emit_generated_quantities__) { + param_names__.push_back(std::string() + "occ_fs"); + for (size_t sym61__ = 1; sym61__ <= R; ++sym61__) { + { + param_names__.push_back(std::string() + "psi_con" + '.' + std::to_string(sym61__)); + }} + for (size_t sym61__ = 1; sym61__ <= R; ++sym61__) { + { + param_names__.push_back(std::string() + "z" + '.' + std::to_string(sym61__)); + }} + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"alpha_occ\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta_occ\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"alpha_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"logit_psi\",\"type\":{\"name\":\"vector\",\"length\":" << R << "},\"block\":\"transformed_parameters\"},{\"name\":\"logit_p\",\"type\":{\"name\":\"matrix\",\"rows\":" << R << ",\"cols\":" << T << "},\"block\":\"transformed_parameters\"},{\"name\":\"occ_fs\",\"type\":{\"name\":\"int\"},\"block\":\"generated_quantities\"},{\"name\":\"psi_con\",\"type\":{\"name\":\"array\",\"length\":" << R << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"},{\"name\":\"z\",\"type\":{\"name\":\"array\",\"length\":" << R << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"alpha_occ\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta_occ\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"alpha_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"logit_psi\",\"type\":{\"name\":\"vector\",\"length\":" << R << "},\"block\":\"transformed_parameters\"},{\"name\":\"logit_p\",\"type\":{\"name\":\"matrix\",\"rows\":" << R << ",\"cols\":" << T << "},\"block\":\"transformed_parameters\"},{\"name\":\"occ_fs\",\"type\":{\"name\":\"int\"},\"block\":\"generated_quantities\"},{\"name\":\"psi_con\",\"type\":{\"name\":\"array\",\"length\":" << R << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"},{\"name\":\"z\",\"type\":{\"name\":\"array\",\"length\":" << R << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef off_dce_model_namespace::off_dce_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp off-small.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace off_small_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'off-small.stan', line 10, column 2 to column 12)", + " (in 'off-small.stan', line 11, column 2 to column 17)", + " (in 'off-small.stan', line 12, column 2 to column 17)", + " (in 'off-small.stan', line 13, column 2 to column 13)", + " (in 'off-small.stan', line 14, column 2 to column 13)", + " (in 'off-small.stan', line 15, column 2 to column 35)", + " (in 'off-small.stan', line 16, column 2 to column 35)", + " (in 'off-small.stan', line 17, column 2 to column 34)", + " (in 'off-small.stan', line 20, column 2 to column 15)", + " (in 'off-small.stan', line 21, column 2 to column 15)", + " (in 'off-small.stan', line 22, column 2 to column 18)", + " (in 'off-small.stan', line 28, column 4 to line 29, column 42)", + " (in 'off-small.stan', line 27, column 2 to line 29, column 42)", + " (in 'off-small.stan', line 32, column 2 to column 23)", + " (in 'off-small.stan', line 33, column 2 to column 23)", + " (in 'off-small.stan', line 34, column 2 to column 23)", + " (in 'off-small.stan', line 35, column 2 to column 23)", + " (in 'off-small.stan', line 37, column 2 to column 23)", + " (in 'off-small.stan', line 39, column 2 to column 29)", + " (in 'off-small.stan', line 2, column 2 to column 17)", + " (in 'off-small.stan', line 3, column 2 to column 17)", + " (in 'off-small.stan', line 4, column 2 to column 33)", + " (in 'off-small.stan', line 5, column 2 to column 17)", + " (in 'off-small.stan', line 6, column 2 to column 22)", + " (in 'off-small.stan', line 7, column 2 to column 14)"}; + + + +class off_small_model : public model_base_crtp { + + private: + double lcm_sym52__; + double lcm_sym51__; + double lcm_sym50__; + double lcm_sym49__; + double lcm_sym48__; + double lcm_sym47__; + int lcm_sym46__; + int lcm_sym45__; + int lcm_sym44__; + int lcm_sym43__; + int pos__; + int J; + int N; + std::vector person; + Eigen::Matrix time; + Eigen::Matrix treatment; + Eigen::Matrix y; + + public: + ~off_small_model() { } + + std::string model_name() const { return "off_small_model"; } + + off_small_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "off_small_model_namespace::off_small_model"; + (void) function__; // suppress unused var warning + + try { + + + + + + + + + + + + pos__ = 1; + context__.validate_dims("data initialization","J","int", + context__.to_vec()); + + current_statement__ = 20; + J = context__.vals_i("J")[(1 - 1)]; + context__.validate_dims("data initialization","N","int", + context__.to_vec()); + + current_statement__ = 21; + N = context__.vals_i("N")[(1 - 1)]; + current_statement__ = 22; + validate_non_negative_index("person", "N", N); + context__.validate_dims("data initialization","person","int", + context__.to_vec(N)); + person = std::vector(N, 0); + + current_statement__ = 22; + assign(person, nil_index_list(), context__.vals_i("person"), + "assigning variable person"); + current_statement__ = 23; + validate_non_negative_index("time", "N", N); + context__.validate_dims("data initialization","time","double", + context__.to_vec(N)); + time = Eigen::Matrix(N); + + { + std::vector time_flat__; + current_statement__ = 23; + assign(time_flat__, nil_index_list(), context__.vals_r("time"), + "assigning variable time_flat__"); + current_statement__ = 23; + pos__ = 1; + lcm_sym43__ = logical_gte(N, 1); + if (lcm_sym43__) { + current_statement__ = 23; + assign(time, cons_list(index_uni(1), nil_index_list()), + time_flat__[(1 - 1)], "assigning variable time"); + current_statement__ = 23; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 23; + assign(time, cons_list(index_uni(sym1__), nil_index_list()), + time_flat__[(pos__ - 1)], "assigning variable time"); + current_statement__ = 23; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 24; + validate_non_negative_index("treatment", "N", N); + context__.validate_dims("data initialization","treatment","double", + context__.to_vec(N)); + treatment = Eigen::Matrix(N); + + { + std::vector treatment_flat__; + current_statement__ = 24; + assign(treatment_flat__, nil_index_list(), + context__.vals_r("treatment"), + "assigning variable treatment_flat__"); + current_statement__ = 24; + pos__ = 1; + current_statement__ = 24; + if (lcm_sym43__) { + current_statement__ = 24; + assign(treatment, cons_list(index_uni(1), nil_index_list()), + treatment_flat__[(1 - 1)], "assigning variable treatment"); + current_statement__ = 24; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 24; + assign(treatment, cons_list(index_uni(sym1__), nil_index_list()), + treatment_flat__[(pos__ - 1)], "assigning variable treatment"); + current_statement__ = 24; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 25; + validate_non_negative_index("y", "N", N); + context__.validate_dims("data initialization","y","double", + context__.to_vec(N)); + y = Eigen::Matrix(N); + + { + std::vector y_flat__; + current_statement__ = 25; + assign(y_flat__, nil_index_list(), context__.vals_r("y"), + "assigning variable y_flat__"); + current_statement__ = 25; + pos__ = 1; + current_statement__ = 25; + if (lcm_sym43__) { + current_statement__ = 25; + assign(y, cons_list(index_uni(1), nil_index_list()), + y_flat__[(1 - 1)], "assigning variable y"); + current_statement__ = 25; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 25; + assign(y, cons_list(index_uni(sym1__), nil_index_list()), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 25; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 20; + current_statement__ = 20; + check_greater_or_equal(function__, "J", J, 0); + current_statement__ = 21; + current_statement__ = 21; + check_greater_or_equal(function__, "N", N, 0); + current_statement__ = 22; + if (lcm_sym43__) { + current_statement__ = 22; + current_statement__ = 22; + check_greater_or_equal(function__, "person[sym1__]", person[(1 - 1)], + 1); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 22; + current_statement__ = 22; + check_greater_or_equal(function__, "person[sym1__]", + person[(sym1__ - 1)], 1);} + } + current_statement__ = 22; + if (lcm_sym43__) { + current_statement__ = 22; + current_statement__ = 22; + check_less_or_equal(function__, "person[sym1__]", person[(1 - 1)], J); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 22; + current_statement__ = 22; + check_less_or_equal(function__, "person[sym1__]", + person[(sym1__ - 1)], J);} + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + num_params_r__ += 1; + current_statement__ = 2; + validate_non_negative_index("eta1", "J", J); + num_params_r__ += J; + current_statement__ = 3; + validate_non_negative_index("eta2", "J", J); + num_params_r__ += J; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "off_small_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + double lcm_sym42__; + double lcm_sym41__; + double lcm_sym40__; + double lcm_sym39__; + double lcm_sym38__; + double lcm_sym37__; + double lcm_sym36__; + double lcm_sym35__; + double lcm_sym34__; + Eigen::Matrix lcm_sym33__; + Eigen::Matrix lcm_sym32__; + int lcm_sym31__; + int lcm_sym30__; + local_scalar_t__ beta; + + current_statement__ = 1; + beta = in__.scalar(); + current_statement__ = 2; + validate_non_negative_index("eta1", "J", J); + Eigen::Matrix eta1; + eta1 = Eigen::Matrix(J); + + current_statement__ = 2; + eta1 = in__.vector(J); + current_statement__ = 3; + validate_non_negative_index("eta2", "J", J); + Eigen::Matrix eta2; + eta2 = Eigen::Matrix(J); + + current_statement__ = 3; + eta2 = in__.vector(J); + local_scalar_t__ mu_a1; + + current_statement__ = 4; + mu_a1 = in__.scalar(); + local_scalar_t__ mu_a2; + + current_statement__ = 5; + mu_a2 = in__.scalar(); + local_scalar_t__ sigma_a1; + + current_statement__ = 6; + sigma_a1 = in__.scalar(); + current_statement__ = 6; + if (jacobian__) { + current_statement__ = 6; + sigma_a1 = stan::math::lub_constrain(sigma_a1, 0, 100, lp__); + } else { + current_statement__ = 6; + sigma_a1 = stan::math::lub_constrain(sigma_a1, 0, 100); + } + local_scalar_t__ sigma_a2; + + current_statement__ = 7; + sigma_a2 = in__.scalar(); + current_statement__ = 7; + if (jacobian__) { + current_statement__ = 7; + sigma_a2 = stan::math::lub_constrain(sigma_a2, 0, 100, lp__); + } else { + current_statement__ = 7; + sigma_a2 = stan::math::lub_constrain(sigma_a2, 0, 100); + } + local_scalar_t__ sigma_y; + + current_statement__ = 8; + sigma_y = in__.scalar(); + current_statement__ = 8; + if (jacobian__) { + current_statement__ = 8; + sigma_y = stan::math::lub_constrain(sigma_y, 0, 100, lp__); + } else { + current_statement__ = 8; + sigma_y = stan::math::lub_constrain(sigma_y, 0, 100); + } + current_statement__ = 9; + validate_non_negative_index("a1", "J", J); + Eigen::Matrix a1; + a1 = Eigen::Matrix(J); + + lcm_sym30__ = logical_gte(J, 1); + if (lcm_sym30__) { + lcm_sym42__ = std::numeric_limits::quiet_NaN(); + assign(a1, cons_list(index_uni(1), nil_index_list()), lcm_sym42__, + "assigning variable a1"); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + current_statement__ = 9; + assign(a1, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym42__, "assigning variable a1");} + } + current_statement__ = 10; + validate_non_negative_index("a2", "J", J); + Eigen::Matrix a2; + a2 = Eigen::Matrix(J); + + current_statement__ = 10; + if (lcm_sym30__) { + lcm_sym42__ = std::numeric_limits::quiet_NaN(); + assign(a2, cons_list(index_uni(1), nil_index_list()), lcm_sym42__, + "assigning variable a2"); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + current_statement__ = 10; + assign(a2, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym42__, "assigning variable a2");} + } + current_statement__ = 11; + validate_non_negative_index("y_hat", "N", N); + Eigen::Matrix y_hat; + y_hat = Eigen::Matrix(N); + + lcm_sym31__ = logical_gte(N, 1); + if (lcm_sym31__) { + lcm_sym42__ = std::numeric_limits::quiet_NaN(); + assign(y_hat, cons_list(index_uni(1), nil_index_list()), lcm_sym42__, + "assigning variable y_hat"); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 11; + assign(y_hat, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym42__, "assigning variable y_hat");} + } + assign(lcm_sym32__, nil_index_list(), + add((10 * mu_a1), multiply(sigma_a1, eta1)), + "assigning variable lcm_sym32__"); + assign(a1, nil_index_list(), lcm_sym32__, "assigning variable a1"); + assign(lcm_sym33__, nil_index_list(), + add((0.1 * mu_a2), multiply(sigma_a2, eta2)), + "assigning variable lcm_sym33__"); + assign(a2, nil_index_list(), lcm_sym33__, "assigning variable a2"); + current_statement__ = 13; + if (lcm_sym31__) { + current_statement__ = 12; + assign(y_hat, cons_list(index_uni(1), nil_index_list()), + stan::math::fma(lcm_sym33__[(person[(1 - 1)] - 1)], time[(1 - 1)], + stan::math::fma((beta * time[(1 - 1)]), treatment[(1 - 1)], + lcm_sym32__[(person[(1 - 1)] - 1)])), + "assigning variable y_hat"); + for (size_t i = 2; i <= N; ++i) { + current_statement__ = 12; + assign(y_hat, cons_list(index_uni(i), nil_index_list()), + stan::math::fma(lcm_sym33__[(person[(i - 1)] - 1)], + time[(i - 1)], + stan::math::fma((beta * time[(i - 1)]), treatment[(i - 1)], + lcm_sym32__[(person[(i - 1)] - 1)])), + "assigning variable y_hat");} + } + { + current_statement__ = 14; + lp_accum__.add(normal_log(mu_a1, 0, 1)); + current_statement__ = 15; + lp_accum__.add(normal_log(eta1, 0, 1)); + current_statement__ = 16; + lp_accum__.add(normal_log(mu_a2, 0, 1)); + current_statement__ = 17; + lp_accum__.add(normal_log(eta2, 0, 1)); + current_statement__ = 18; + lp_accum__.add(normal_log(beta, 0, 1)); + current_statement__ = 19; + lp_accum__.add(normal_log(y, y_hat, sigma_y)); + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "off_small_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + double lcm_sym29__; + double lcm_sym28__; + double lcm_sym27__; + double lcm_sym26__; + double lcm_sym25__; + double lcm_sym24__; + double lcm_sym23__; + double lcm_sym22__; + double lcm_sym21__; + double lcm_sym20__; + double lcm_sym19__; + double lcm_sym18__; + double lcm_sym17__; + Eigen::Matrix lcm_sym16__; + Eigen::Matrix lcm_sym15__; + int lcm_sym14__; + int lcm_sym13__; + int lcm_sym12__; + int lcm_sym11__; + double beta; + + current_statement__ = 1; + beta = in__.scalar(); + current_statement__ = 2; + validate_non_negative_index("eta1", "J", J); + Eigen::Matrix eta1; + eta1 = Eigen::Matrix(J); + + current_statement__ = 2; + eta1 = in__.vector(J); + current_statement__ = 3; + validate_non_negative_index("eta2", "J", J); + Eigen::Matrix eta2; + eta2 = Eigen::Matrix(J); + + current_statement__ = 3; + eta2 = in__.vector(J); + double mu_a1; + + current_statement__ = 4; + mu_a1 = in__.scalar(); + double mu_a2; + + current_statement__ = 5; + mu_a2 = in__.scalar(); + double sigma_a1; + + current_statement__ = 6; + sigma_a1 = in__.scalar(); + current_statement__ = 6; + sigma_a1 = stan::math::lub_constrain(sigma_a1, 0, 100); + double sigma_a2; + + current_statement__ = 7; + sigma_a2 = in__.scalar(); + current_statement__ = 7; + sigma_a2 = stan::math::lub_constrain(sigma_a2, 0, 100); + double sigma_y; + + current_statement__ = 8; + sigma_y = in__.scalar(); + current_statement__ = 8; + sigma_y = stan::math::lub_constrain(sigma_y, 0, 100); + current_statement__ = 9; + validate_non_negative_index("a1", "J", J); + Eigen::Matrix a1; + a1 = Eigen::Matrix(J); + + lcm_sym11__ = logical_gte(J, 1); + if (lcm_sym11__) { + lcm_sym19__ = std::numeric_limits::quiet_NaN(); + assign(a1, cons_list(index_uni(1), nil_index_list()), lcm_sym19__, + "assigning variable a1"); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + current_statement__ = 9; + assign(a1, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym19__, "assigning variable a1");} + } + current_statement__ = 10; + validate_non_negative_index("a2", "J", J); + Eigen::Matrix a2; + a2 = Eigen::Matrix(J); + + current_statement__ = 10; + if (lcm_sym11__) { + lcm_sym19__ = std::numeric_limits::quiet_NaN(); + assign(a2, cons_list(index_uni(1), nil_index_list()), lcm_sym19__, + "assigning variable a2"); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + current_statement__ = 10; + assign(a2, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym19__, "assigning variable a2");} + } + current_statement__ = 11; + validate_non_negative_index("y_hat", "N", N); + Eigen::Matrix y_hat; + y_hat = Eigen::Matrix(N); + + lcm_sym12__ = logical_gte(N, 1); + if (lcm_sym12__) { + lcm_sym19__ = std::numeric_limits::quiet_NaN(); + assign(y_hat, cons_list(index_uni(1), nil_index_list()), lcm_sym19__, + "assigning variable y_hat"); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 11; + assign(y_hat, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym19__, "assigning variable y_hat");} + } + vars__.push_back(beta); + if (lcm_sym11__) { + vars__.push_back(eta1[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + vars__.push_back(eta1[(sym1__ - 1)]);} + } + if (lcm_sym11__) { + vars__.push_back(eta2[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + vars__.push_back(eta2[(sym1__ - 1)]);} + } + vars__.push_back(mu_a1); + vars__.push_back(mu_a2); + vars__.push_back(sigma_a1); + vars__.push_back(sigma_a2); + vars__.push_back(sigma_y); + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + assign(lcm_sym15__, nil_index_list(), + add((10 * mu_a1), multiply(sigma_a1, eta1)), + "assigning variable lcm_sym15__"); + assign(a1, nil_index_list(), lcm_sym15__, "assigning variable a1"); + assign(lcm_sym16__, nil_index_list(), + add((0.1 * mu_a2), multiply(sigma_a2, eta2)), + "assigning variable lcm_sym16__"); + assign(a2, nil_index_list(), lcm_sym16__, "assigning variable a2"); + current_statement__ = 13; + if (lcm_sym12__) { + current_statement__ = 12; + assign(y_hat, cons_list(index_uni(1), nil_index_list()), + stan::math::fma(lcm_sym16__[(person[(1 - 1)] - 1)], time[(1 - 1)], + stan::math::fma((beta * time[(1 - 1)]), treatment[(1 - 1)], + lcm_sym15__[(person[(1 - 1)] - 1)])), + "assigning variable y_hat"); + for (size_t i = 2; i <= N; ++i) { + current_statement__ = 12; + assign(y_hat, cons_list(index_uni(i), nil_index_list()), + stan::math::fma(lcm_sym16__[(person[(i - 1)] - 1)], + time[(i - 1)], + stan::math::fma((beta * time[(i - 1)]), treatment[(i - 1)], + lcm_sym15__[(person[(i - 1)] - 1)])), + "assigning variable y_hat");} + } + if (lcm_sym11__) { + vars__.push_back(lcm_sym15__[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + vars__.push_back(lcm_sym15__[(sym1__ - 1)]);} + } + if (lcm_sym11__) { + vars__.push_back(lcm_sym16__[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + vars__.push_back(lcm_sym16__[(sym1__ - 1)]);} + } + if (lcm_sym12__) { + vars__.push_back(y_hat[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + vars__.push_back(y_hat[(sym1__ - 1)]);} + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + double lcm_sym10__; + double lcm_sym9__; + double lcm_sym8__; + double lcm_sym7__; + double lcm_sym6__; + double lcm_sym5__; + double lcm_sym4__; + double lcm_sym3__; + int lcm_sym2__; + int lcm_sym1__; + int pos__; + + pos__ = 1; + double beta; + + current_statement__ = 1; + beta = context__.vals_r("beta")[(1 - 1)]; + current_statement__ = 2; + validate_non_negative_index("eta1", "J", J); + Eigen::Matrix eta1; + eta1 = Eigen::Matrix(J); + + { + std::vector eta1_flat__; + current_statement__ = 2; + assign(eta1_flat__, nil_index_list(), context__.vals_r("eta1"), + "assigning variable eta1_flat__"); + current_statement__ = 2; + pos__ = 1; + lcm_sym1__ = logical_gte(J, 1); + if (lcm_sym1__) { + current_statement__ = 2; + assign(eta1, cons_list(index_uni(1), nil_index_list()), + eta1_flat__[(1 - 1)], "assigning variable eta1"); + current_statement__ = 2; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + current_statement__ = 2; + assign(eta1, cons_list(index_uni(sym1__), nil_index_list()), + eta1_flat__[(pos__ - 1)], "assigning variable eta1"); + current_statement__ = 2; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 3; + validate_non_negative_index("eta2", "J", J); + Eigen::Matrix eta2; + eta2 = Eigen::Matrix(J); + + { + std::vector eta2_flat__; + current_statement__ = 3; + assign(eta2_flat__, nil_index_list(), context__.vals_r("eta2"), + "assigning variable eta2_flat__"); + current_statement__ = 3; + pos__ = 1; + current_statement__ = 3; + if (lcm_sym1__) { + current_statement__ = 3; + assign(eta2, cons_list(index_uni(1), nil_index_list()), + eta2_flat__[(1 - 1)], "assigning variable eta2"); + current_statement__ = 3; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + current_statement__ = 3; + assign(eta2, cons_list(index_uni(sym1__), nil_index_list()), + eta2_flat__[(pos__ - 1)], "assigning variable eta2"); + current_statement__ = 3; + pos__ = (pos__ + 1);} + } + } + double mu_a1; + + current_statement__ = 4; + mu_a1 = context__.vals_r("mu_a1")[(1 - 1)]; + double mu_a2; + + current_statement__ = 5; + mu_a2 = context__.vals_r("mu_a2")[(1 - 1)]; + double sigma_a1; + + current_statement__ = 6; + sigma_a1 = context__.vals_r("sigma_a1")[(1 - 1)]; + current_statement__ = 6; + sigma_a1 = stan::math::lub_free(sigma_a1, 0, 100); + double sigma_a2; + + current_statement__ = 7; + sigma_a2 = context__.vals_r("sigma_a2")[(1 - 1)]; + current_statement__ = 7; + sigma_a2 = stan::math::lub_free(sigma_a2, 0, 100); + double sigma_y; + + current_statement__ = 8; + sigma_y = context__.vals_r("sigma_y")[(1 - 1)]; + current_statement__ = 8; + sigma_y = stan::math::lub_free(sigma_y, 0, 100); + vars__.push_back(beta); + if (lcm_sym1__) { + vars__.push_back(eta1[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + vars__.push_back(eta1[(sym1__ - 1)]);} + } + if (lcm_sym1__) { + vars__.push_back(eta2[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= J; ++sym1__) { + vars__.push_back(eta2[(sym1__ - 1)]);} + } + vars__.push_back(mu_a1); + vars__.push_back(mu_a2); + vars__.push_back(sigma_a1); + vars__.push_back(sigma_a2); + vars__.push_back(sigma_y); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("beta"); + names__.push_back("eta1"); + names__.push_back("eta2"); + names__.push_back("mu_a1"); + names__.push_back("mu_a2"); + names__.push_back("sigma_a1"); + names__.push_back("sigma_a2"); + names__.push_back("sigma_y"); + names__.push_back("a1"); + names__.push_back("a2"); + names__.push_back("y_hat"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(J); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(J); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(J); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(J); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(N); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "beta"); + for (size_t sym53__ = 1; sym53__ <= J; ++sym53__) { + { + param_names__.push_back(std::string() + "eta1" + '.' + std::to_string(sym53__)); + }} + for (size_t sym53__ = 1; sym53__ <= J; ++sym53__) { + { + param_names__.push_back(std::string() + "eta2" + '.' + std::to_string(sym53__)); + }} + param_names__.push_back(std::string() + "mu_a1"); + param_names__.push_back(std::string() + "mu_a2"); + param_names__.push_back(std::string() + "sigma_a1"); + param_names__.push_back(std::string() + "sigma_a2"); + param_names__.push_back(std::string() + "sigma_y"); + if (emit_transformed_parameters__) { + for (size_t sym53__ = 1; sym53__ <= J; ++sym53__) { + { + param_names__.push_back(std::string() + "a1" + '.' + std::to_string(sym53__)); + }} + for (size_t sym53__ = 1; sym53__ <= J; ++sym53__) { + { + param_names__.push_back(std::string() + "a2" + '.' + std::to_string(sym53__)); + }} + for (size_t sym53__ = 1; sym53__ <= N; ++sym53__) { + { + param_names__.push_back(std::string() + "y_hat" + '.' + std::to_string(sym53__)); + }} + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "beta"); + for (size_t sym53__ = 1; sym53__ <= J; ++sym53__) { + { + param_names__.push_back(std::string() + "eta1" + '.' + std::to_string(sym53__)); + }} + for (size_t sym53__ = 1; sym53__ <= J; ++sym53__) { + { + param_names__.push_back(std::string() + "eta2" + '.' + std::to_string(sym53__)); + }} + param_names__.push_back(std::string() + "mu_a1"); + param_names__.push_back(std::string() + "mu_a2"); + param_names__.push_back(std::string() + "sigma_a1"); + param_names__.push_back(std::string() + "sigma_a2"); + param_names__.push_back(std::string() + "sigma_y"); + if (emit_transformed_parameters__) { + for (size_t sym53__ = 1; sym53__ <= J; ++sym53__) { + { + param_names__.push_back(std::string() + "a1" + '.' + std::to_string(sym53__)); + }} + for (size_t sym53__ = 1; sym53__ <= J; ++sym53__) { + { + param_names__.push_back(std::string() + "a2" + '.' + std::to_string(sym53__)); + }} + for (size_t sym53__ = 1; sym53__ <= N; ++sym53__) { + { + param_names__.push_back(std::string() + "y_hat" + '.' + std::to_string(sym53__)); + }} + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"eta1\",\"type\":{\"name\":\"vector\",\"length\":" << J << "},\"block\":\"parameters\"},{\"name\":\"eta2\",\"type\":{\"name\":\"vector\",\"length\":" << J << "},\"block\":\"parameters\"},{\"name\":\"mu_a1\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mu_a2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_a1\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_a2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_y\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"a1\",\"type\":{\"name\":\"vector\",\"length\":" << J << "},\"block\":\"transformed_parameters\"},{\"name\":\"a2\",\"type\":{\"name\":\"vector\",\"length\":" << J << "},\"block\":\"transformed_parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"eta1\",\"type\":{\"name\":\"vector\",\"length\":" << J << "},\"block\":\"parameters\"},{\"name\":\"eta2\",\"type\":{\"name\":\"vector\",\"length\":" << J << "},\"block\":\"parameters\"},{\"name\":\"mu_a1\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mu_a2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_a1\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_a2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_y\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"a1\",\"type\":{\"name\":\"vector\",\"length\":" << J << "},\"block\":\"transformed_parameters\"},{\"name\":\"a2\",\"type\":{\"name\":\"vector\",\"length\":" << J << "},\"block\":\"transformed_parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef off_small_model_namespace::off_small_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp optimizations.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace optimizations_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'optimizations.stan', line 20, column 4 to column 15)", + " (in 'optimizations.stan', line 21, column 4 to column 13)", + " (in 'optimizations.stan', line 22, column 4 to column 26)", + " (in 'optimizations.stan', line 23, column 4 to column 23)", + " (in 'optimizations.stan', line 24, column 4 to column 24)", + " (in 'optimizations.stan', line 27, column 4 to column 11)", + " (in 'optimizations.stan', line 5, column 8 to column 20)", + " (in 'optimizations.stan', line 2, column 33 to line 6, column 5)", + " (in 'optimizations.stan', line 9, column 8 to line 10, column 26)", + " (in 'optimizations.stan', line 8, column 20 to line 12, column 5)", + " (in 'optimizations.stan', line 30, column 17 to column 28)", + " (in 'optimizations.stan', line 31, column 33 to line 34, column 5)", + " (in 'optimizations.stan', line 36, column 8 to column 21)", + " (in 'optimizations.stan', line 35, column 4 to line 37, column 5)", + " (in 'optimizations.stan', line 41, column 16 to column 29)", + " (in 'optimizations.stan', line 40, column 12 to line 41, column 29)", + " (in 'optimizations.stan', line 39, column 8 to line 41, column 29)", + " (in 'optimizations.stan', line 38, column 4 to line 41, column 29)", + " (in 'optimizations.stan', line 44, column 10 to column 16)", + " (in 'optimizations.stan', line 43, column 8 to line 44, column 16)", + " (in 'optimizations.stan', line 45, column 8 to column 20)", + " (in 'optimizations.stan', line 42, column 21 to line 46, column 5)", + " (in 'optimizations.stan', line 42, column 4 to line 46, column 5)", + " (in 'optimizations.stan', line 49, column 10 to column 19)", + " (in 'optimizations.stan', line 48, column 8 to line 49, column 19)", + " (in 'optimizations.stan', line 50, column 8 to column 20)", + " (in 'optimizations.stan', line 47, column 21 to line 51, column 5)", + " (in 'optimizations.stan', line 47, column 4 to line 51, column 5)", + " (in 'optimizations.stan', line 54, column 10 to column 19)", + " (in 'optimizations.stan', line 53, column 8 to line 54, column 19)", + " (in 'optimizations.stan', line 55, column 8 to column 20)", + " (in 'optimizations.stan', line 52, column 21 to line 56, column 5)", + " (in 'optimizations.stan', line 52, column 4 to line 56, column 5)", + " (in 'optimizations.stan', line 57, column 4 to column 10)", + " (in 'optimizations.stan', line 58, column 4 to column 16)", + " (in 'optimizations.stan', line 60, column 6 to column 12)", + " (in 'optimizations.stan', line 59, column 4 to line 60, column 12)", + " (in 'optimizations.stan', line 61, column 4 to column 16)", + " (in 'optimizations.stan', line 64, column 4 to column 16)", + " (in 'optimizations.stan', line 65, column 4 to column 16)", + " (in 'optimizations.stan', line 66, column 4 to column 16)", + " (in 'optimizations.stan', line 68, column 6 to column 19)", + " (in 'optimizations.stan', line 69, column 4 to column 16)", + " (in 'optimizations.stan', line 70, column 4 to column 11)", + " (in 'optimizations.stan', line 71, column 4 to column 10)", + " (in 'optimizations.stan', line 72, column 4 to column 16)", + " (in 'optimizations.stan', line 74, column 6 to column 12)", + " (in 'optimizations.stan', line 73, column 4 to line 74, column 12)", + " (in 'optimizations.stan', line 75, column 4 to column 16)", + " (in 'optimizations.stan', line 78, column 4 to column 16)", + " (in 'optimizations.stan', line 80, column 8 to column 19)", + " (in 'optimizations.stan', line 82, column 8 to column 20)", + " (in 'optimizations.stan', line 79, column 4 to line 83, column 5)", + " (in 'optimizations.stan', line 85, column 8 to column 20)", + " (in 'optimizations.stan', line 87, column 8 to column 20)", + " (in 'optimizations.stan', line 84, column 4 to line 88, column 5)", + " (in 'optimizations.stan', line 90, column 11 to column 23)", + " (in 'optimizations.stan', line 90, column 4 to column 23)", + " (in 'optimizations.stan', line 15, column 8 to column 20)", + " (in 'optimizations.stan', line 14, column 18 to line 17, column 5)", + " (in 'optimizations.stan', line 97, column 20 to column 26)", + " (in 'optimizations.stan', line 97, column 4 to column 26)", + " (in 'optimizations.stan', line 98, column 22 to column 28)", + " (in 'optimizations.stan', line 100, column 6 to column 15)", + " (in 'optimizations.stan', line 99, column 4 to line 100, column 15)", + " (in 'optimizations.stan', line 102, column 6 to column 12)", + " (in 'optimizations.stan', line 101, column 4 to line 102, column 12)", + " (in 'optimizations.stan', line 106, column 6 to column 15)", + " (in 'optimizations.stan', line 108, column 6 to column 12)", + " (in 'optimizations.stan', line 112, column 8 to column 20)", + " (in 'optimizations.stan', line 115, column 8 to column 21)", + " (in 'optimizations.stan', line 111, column 4 to line 116, column 5)", + " (in 'optimizations.stan', line 119, column 12 to column 24)", + " (in 'optimizations.stan', line 118, column 8 to line 121, column 9)", + " (in 'optimizations.stan', line 117, column 4 to line 127, column 5)", + " (in 'optimizations.stan', line 128, column 4 to column 14)", + " (in 'optimizations.stan', line 132, column 6 to column 21)", + " (in 'optimizations.stan', line 129, column 4 to line 132, column 21)", + " (in 'optimizations.stan', line 134, column 4 to column 15)", + " (in 'optimizations.stan', line 137, column 8 to column 23)", + " (in 'optimizations.stan', line 138, column 8 to column 24)", + " (in 'optimizations.stan', line 135, column 4 to line 139, column 5)", + " (in 'optimizations.stan', line 140, column 4 to column 25)", + " (in 'optimizations.stan', line 143, column 4 to column 26)", + " (in 'optimizations.stan', line 144, column 4 to column 22)", + " (in 'optimizations.stan', line 146, column 6 to column 28)", + " (in 'optimizations.stan', line 145, column 4 to line 146, column 28)", + " (in 'optimizations.stan', line 147, column 4 to column 23)", + " (in 'optimizations.stan', line 4, column 10 to column 17)", + " (in 'optimizations.stan', line 3, column 8 to line 4, column 17)", + " (in 'optimizations.stan', line 10, column 12 to column 26)", + " (in 'optimizations.stan', line 11, column 8 to column 21)", + " (in 'optimizations.stan', line 16, column 8 to column 18)"}; + + +template +void +nrfun_lp(const T0__& x, const int& y, T_lp__& lp__, T_lp_accum__& lp_accum__, + std::ostream* pstream__) { + using local_scalar_t__ = typename boost::math::tools::promote_args::type; + + try { + int lcm_sym35__; + { + current_statement__ = 90; + if (logical_gt(x, 342)) { + current_statement__ = 89; + return ; + } + current_statement__ = 7; + lp_accum__.add(y); + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct nrfun_lp_functor__ { +template +void +operator()(const T0__& x, const int& y, T_lp__& lp__, + T_lp_accum__& lp_accum__, std::ostream* pstream__) const +{ +return nrfun_lp(x, y, lp__, lp_accum__, pstream__); +} +}; + +int +rfun(const int& y, std::ostream* pstream__) { + using local_scalar_t__ = double; + const static bool propto__ = true; + (void) propto__; + + try { + int lcm_sym38__; + int lcm_sym37__; + int lcm_sym36__; + { + current_statement__ = 9; + if (logical_gt(y, 2)) { + current_statement__ = 91; + return (y + 24); + } + current_statement__ = 92; + return (y + 2); + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct rfun_functor__ { +int +operator()(const int& y, std::ostream* pstream__) const +{ +return rfun(y, pstream__); +} +}; + +template +int +rfun_lp(T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__) { + using local_scalar_t__ = double; + + try { + { + current_statement__ = 59; + lp_accum__.add(2); + current_statement__ = 93; + return 24; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + +} + +struct rfun_lp_functor__ { +template +int +operator()(T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__) const +{ +return rfun_lp(lp__, lp_accum__, pstream__); +} +}; + +class optimizations_model : public model_base_crtp { + + private: + int pos__; + + public: + ~optimizations_model() { } + + std::string model_name() const { return "optimizations_model"; } + + optimizations_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "optimizations_model_namespace::optimizations_model"; + (void) function__; // suppress unused var warning + + try { + + pos__ = 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + num_params_r__ += 1; + num_params_r__ += 1; + current_statement__ = 3; + validate_non_negative_index("x_matrix", "3", 3); + current_statement__ = 3; + validate_non_negative_index("x_matrix", "2", 2); + num_params_r__ += 3 * 2; + current_statement__ = 4; + validate_non_negative_index("x_vector", "2", 2); + num_params_r__ += 2; + current_statement__ = 5; + validate_non_negative_index("x_cov", "2", 2); + current_statement__ = 5; + validate_non_negative_index("x_cov", "2", 2); + num_params_r__ += 3; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "optimizations_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + double lcm_sym79__; + int lcm_sym78__; + int lcm_sym77__; + int lcm_sym76__; + int lcm_sym75__; + int lcm_sym74__; + int lcm_sym73__; + int lcm_sym72__; + int lcm_sym71__; + int lcm_sym70__; + int lcm_sym69__; + int lcm_sym68__; + int lcm_sym67__; + int lcm_sym66__; + local_scalar_t__ theta; + + current_statement__ = 1; + theta = in__.scalar(); + local_scalar_t__ phi; + + current_statement__ = 2; + phi = in__.scalar(); + current_statement__ = 3; + validate_non_negative_index("x_matrix", "3", 3); + current_statement__ = 3; + validate_non_negative_index("x_matrix", "2", 2); + Eigen::Matrix x_matrix; + x_matrix = Eigen::Matrix(3, 2); + + current_statement__ = 3; + x_matrix = in__.matrix(3, 2); + current_statement__ = 4; + validate_non_negative_index("x_vector", "2", 2); + Eigen::Matrix x_vector; + x_vector = Eigen::Matrix(2); + + current_statement__ = 4; + x_vector = in__.vector(2); + current_statement__ = 5; + validate_non_negative_index("x_cov", "2", 2); + current_statement__ = 5; + validate_non_negative_index("x_cov", "2", 2); + Eigen::Matrix x_cov; + x_cov = Eigen::Matrix(2, 2); + + Eigen::Matrix x_cov_in__; + x_cov_in__ = Eigen::Matrix(3); + + current_statement__ = 5; + x_cov_in__ = in__.vector(3); + current_statement__ = 5; + if (jacobian__) { + current_statement__ = 5; + assign(x_cov, nil_index_list(), + stan::math::cov_matrix_constrain(x_cov_in__, 2, lp__), + "assigning variable x_cov"); + } else { + current_statement__ = 5; + assign(x_cov, nil_index_list(), + stan::math::cov_matrix_constrain(x_cov_in__, 2), + "assigning variable x_cov"); + } + { + double x; + + int inline_sym1__; + + for (size_t inline_sym2__ = 1; inline_sym2__ <= 1; ++inline_sym2__) { + current_statement__ = 7; + lp_accum__.add(3);} + int inline_sym3__; + int inline_sym4__; + + for (size_t inline_sym5__ = 1; inline_sym5__ <= 1; ++inline_sym5__) { + { + inline_sym3__ = 27; + break; + } + inline_sym3__ = 5; + break;} + if (pstream__) { + stan_print(pstream__, inline_sym3__); + stan_print(pstream__, "\n"); + } + int inline_sym6__; + int inline_sym7__; + + for (size_t inline_sym8__ = 1; inline_sym8__ <= 1; ++inline_sym8__) { + { + inline_sym6__ = 28; + break; + } + inline_sym6__ = 6; + break;} + if (inline_sym6__) { + current_statement__ = 11; + if (pstream__) { + stan_print(pstream__, "a"); + stan_print(pstream__, "\n"); + } + } + int inline_sym9__; + int inline_sym12__; + int inline_sym10__; + + for (size_t inline_sym11__ = 1; inline_sym11__ <= 1; ++inline_sym11__) { + { + inline_sym9__ = 31; + break; + } + inline_sym9__ = 9; + break;} + int inline_sym13__; + + for (size_t inline_sym14__ = 1; inline_sym14__ <= 1; ++inline_sym14__) { + { + inline_sym12__ = 29; + break; + } + inline_sym12__ = 7; + break;} + if (logical_gte(inline_sym12__, inline_sym9__)) { + { + int inline_sym15__; + int inline_sym16__; + + for (size_t inline_sym17__ = 1; inline_sym17__ <= 1; + ++inline_sym17__) { + { + inline_sym15__ = 32; + break; + } + inline_sym15__ = 10; + break;} + lp_accum__.add(inline_sym15__); + int inline_sym18__; + + for (size_t inline_sym19__ = 1; inline_sym19__ <= 1; + ++inline_sym19__) { + current_statement__ = 7; + lp_accum__.add(3);} + } + int inline_sym13__; + + lcm_sym75__ = (inline_sym9__ + 1); + for (size_t inline_sym14__ = 1; inline_sym14__ <= 1; + ++inline_sym14__) { + { + inline_sym12__ = 29; + lcm_sym75__ = (inline_sym9__ + 1); + break; + } + inline_sym12__ = 7; + lcm_sym75__ = (inline_sym9__ + 1); + break;} + for (size_t i = lcm_sym75__; i <= inline_sym12__; ++i) { + { + int inline_sym15__; + int inline_sym16__; + + for (size_t inline_sym17__ = 1; inline_sym17__ <= 1; + ++inline_sym17__) { + { + inline_sym15__ = 32; + break; + } + inline_sym15__ = 10; + break;} + lp_accum__.add(inline_sym15__); + int inline_sym18__; + + for (size_t inline_sym19__ = 1; inline_sym19__ <= 1; + ++inline_sym19__) { + current_statement__ = 7; + lp_accum__.add(3);} + } + int inline_sym13__; + + for (size_t inline_sym14__ = 1; inline_sym14__ <= 1; + ++inline_sym14__) { + { + inline_sym12__ = 29; + break; + } + inline_sym12__ = 7; + break;}} + } + { + current_statement__ = 13; + lp_accum__.add(53); + { + current_statement__ = 13; + lp_accum__.add(53); + } + { + current_statement__ = 13; + lp_accum__.add(53); + } + { + current_statement__ = 13; + lp_accum__.add(53); + } + { + current_statement__ = 13; + lp_accum__.add(53); + } + } + { + { + { + current_statement__ = 15; + lp_accum__.add(53); + { + current_statement__ = 15; + lp_accum__.add(53); + } + } + { + lcm_sym78__ = (2 * 2); + if (logical_gte(lcm_sym78__, 2)) { + lcm_sym76__ = (2 + 1); + lp_accum__.add(53); + for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { + current_statement__ = 15; + lp_accum__.add(53);} + } + } + { + lcm_sym78__ = (3 * 2); + if (logical_gte(lcm_sym78__, 3)) { + lcm_sym76__ = (3 + 1); + lp_accum__.add(53); + for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { + current_statement__ = 15; + lp_accum__.add(53);} + } + } + } + { + lcm_sym74__ = (2 + 2); + if (logical_gte(lcm_sym74__, 2)) { + lcm_sym77__ = (2 * 2); + if (logical_gte(lcm_sym77__, 2)) { + { + lcm_sym73__ = (2 + 1); + lp_accum__.add(53); + for (size_t k = lcm_sym73__; k <= lcm_sym77__; ++k) { + current_statement__ = 15; + lp_accum__.add(53);} + } + } else { + lcm_sym73__ = (2 + 1); + } + for (size_t j = lcm_sym73__; j <= lcm_sym74__; ++j) { + lcm_sym78__ = (j * 2); + if (logical_gte(lcm_sym78__, j)) { + lcm_sym76__ = (j + 1); + lp_accum__.add(53); + for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { + current_statement__ = 15; + lp_accum__.add(53);} + } } + } + } + { + lcm_sym74__ = (3 + 2); + if (logical_gte(lcm_sym74__, 3)) { + lcm_sym77__ = (3 * 2); + if (logical_gte(lcm_sym77__, 3)) { + { + lcm_sym73__ = (3 + 1); + lp_accum__.add(53); + for (size_t k = lcm_sym73__; k <= lcm_sym77__; ++k) { + current_statement__ = 15; + lp_accum__.add(53);} + } + } else { + lcm_sym73__ = (3 + 1); + } + for (size_t j = lcm_sym73__; j <= lcm_sym74__; ++j) { + lcm_sym78__ = (j * 2); + if (logical_gte(lcm_sym78__, j)) { + lcm_sym76__ = (j + 1); + lp_accum__.add(53); + for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { + current_statement__ = 15; + lp_accum__.add(53);} + } } + } + } + { + lcm_sym74__ = (4 + 2); + if (logical_gte(lcm_sym74__, 4)) { + lcm_sym77__ = (4 * 2); + if (logical_gte(lcm_sym77__, 4)) { + { + lcm_sym73__ = (4 + 1); + lp_accum__.add(53); + for (size_t k = lcm_sym73__; k <= lcm_sym77__; ++k) { + current_statement__ = 15; + lp_accum__.add(53);} + } + } else { + lcm_sym73__ = (4 + 1); + } + for (size_t j = lcm_sym73__; j <= lcm_sym74__; ++j) { + lcm_sym78__ = (j * 2); + if (logical_gte(lcm_sym78__, j)) { + lcm_sym76__ = (j + 1); + lp_accum__.add(53); + for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { + current_statement__ = 15; + lp_accum__.add(53);} + } } + } + } + { + lcm_sym74__ = (5 + 2); + if (logical_gte(lcm_sym74__, 5)) { + lcm_sym77__ = (5 * 2); + if (logical_gte(lcm_sym77__, 5)) { + { + lcm_sym73__ = (5 + 1); + lp_accum__.add(53); + for (size_t k = lcm_sym73__; k <= lcm_sym77__; ++k) { + current_statement__ = 15; + lp_accum__.add(53);} + } + } else { + lcm_sym73__ = (5 + 1); + } + for (size_t j = lcm_sym73__; j <= lcm_sym74__; ++j) { + lcm_sym78__ = (j * 2); + if (logical_gte(lcm_sym78__, j)) { + lcm_sym76__ = (j + 1); + lp_accum__.add(53); + for (size_t k = lcm_sym76__; k <= lcm_sym78__; ++k) { + current_statement__ = 15; + lp_accum__.add(53);} + } } + } + } + } + current_statement__ = 23; + for (size_t i = 1; i <= 5; ++i) { + current_statement__ = 20; + if (logical_gt(i, 4)) { + break; + } + current_statement__ = 21; + lp_accum__.add(2);} + current_statement__ = 28; + for (size_t i = 1; i <= 5; ++i) { + current_statement__ = 25; + if (logical_gt(i, 4)) { + continue; + } + current_statement__ = 26; + lp_accum__.add(2);} + current_statement__ = 33; + for (size_t i = 1; i <= 5; ++i) { + current_statement__ = 30; + if (logical_gt(i, 4)) { + continue; + } + current_statement__ = 31; + lp_accum__.add(2);} + current_statement__ = 34; + x = 3; + current_statement__ = 35; + lp_accum__.add(3); + current_statement__ = 37; + if (logical_gt(theta, 2)) { + current_statement__ = 36; + x = 2; + } + current_statement__ = 38; + lp_accum__.add(x); + current_statement__ = 39; + lp_accum__.add(247); + current_statement__ = 40; + x = 576; + current_statement__ = 41; + lp_accum__.add(576); + lcm_sym72__ = logical_gt(theta, 46); + if (lcm_sym72__) { + current_statement__ = 42; + x = 5880; + } + current_statement__ = 43; + lp_accum__.add(x); + double z; + + current_statement__ = 45; + z = x; + current_statement__ = 46; + lp_accum__.add(x); + current_statement__ = 48; + if (lcm_sym72__) { + current_statement__ = 47; + z = x; + } + current_statement__ = 49; + lp_accum__.add(z); + current_statement__ = 50; + lp_accum__.add(2); + { + double y; + + current_statement__ = 52; + lp_accum__.add(24); + } + { + double y; + + current_statement__ = 55; + lp_accum__.add(245); + } + { + current_statement__ = 57; + lp_accum__.add(2); + } + int inline_sym20__; + int inline_sym21__; + + for (size_t inline_sym22__ = 1; inline_sym22__ <= 1; ++inline_sym22__) { + current_statement__ = 59; + lp_accum__.add(2); + break;} + current_statement__ = 62; + while (576) { + break; + } + int inline_sym23__; + int inline_sym24__; + + for (size_t inline_sym25__ = 1; inline_sym25__ <= 1; ++inline_sym25__) { + current_statement__ = 59; + lp_accum__.add(2); + inline_sym23__ = 24; + break;} + while (inline_sym23__) { + { + break; + } + int inline_sym24__; + + for (size_t inline_sym25__ = 1; inline_sym25__ <= 1; + ++inline_sym25__) { + current_statement__ = 59; + lp_accum__.add(2); + inline_sym23__ = 24; + break;} + } + current_statement__ = 65; + for (size_t i = 31; i <= 225; ++i) { continue;} + current_statement__ = 67; + for (size_t i = 31; i <= 225; ++i) { break;} + int inline_sym26__; + int inline_sym27__; + + for (size_t inline_sym28__ = 1; inline_sym28__ <= 1; ++inline_sym28__) { + current_statement__ = 59; + lp_accum__.add(2); + inline_sym26__ = 24; + break;} + for (size_t i = inline_sym26__; i <= 225; ++i) { continue;} + int inline_sym29__; + int inline_sym30__; + + for (size_t inline_sym31__ = 1; inline_sym31__ <= 1; ++inline_sym31__) { + current_statement__ = 59; + lp_accum__.add(2); + inline_sym29__ = 24; + break;} + for (size_t i = inline_sym29__; i <= 225; ++i) { break;} + int inline_sym32__; + int inline_sym33__; + + for (size_t inline_sym34__ = 1; inline_sym34__ <= 1; ++inline_sym34__) { + current_statement__ = 59; + lp_accum__.add(2); + break;} + { + current_statement__ = 70; + lp_accum__.add(1); + current_statement__ = 71; + lp_accum__.add(24); + } + { + { + current_statement__ = 73; + lp_accum__.add(1); + } + } + double temp; + + { + current_statement__ = 77; + if (pstream__) { + stan_print(pstream__, "hello"); + stan_print(pstream__, "\n"); + } + } + double temp2; + + { + current_statement__ = 80; + lp_accum__.add(4); + current_statement__ = 81; + lp_accum__.add(6); + { + current_statement__ = 80; + lp_accum__.add(4); + current_statement__ = 81; + lp_accum__.add(6); + } + } + double dataonlyvar; + + current_statement__ = 83; + dataonlyvar = 3; + current_statement__ = 84; + lp_accum__.add(dataonlyvar); + local_scalar_t__ paramvar; + + { + current_statement__ = 86; + paramvar = (theta * 34); + } + current_statement__ = 88; + lp_accum__.add(paramvar); + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "optimizations_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + double lcm_sym65__; + double lcm_sym64__; + double lcm_sym63__; + double lcm_sym62__; + double lcm_sym61__; + double lcm_sym60__; + double lcm_sym59__; + double lcm_sym58__; + double lcm_sym57__; + double lcm_sym56__; + int lcm_sym55__; + int lcm_sym54__; + double theta; + + current_statement__ = 1; + theta = in__.scalar(); + double phi; + + current_statement__ = 2; + phi = in__.scalar(); + current_statement__ = 3; + validate_non_negative_index("x_matrix", "3", 3); + current_statement__ = 3; + validate_non_negative_index("x_matrix", "2", 2); + Eigen::Matrix x_matrix; + x_matrix = Eigen::Matrix(3, 2); + + current_statement__ = 3; + x_matrix = in__.matrix(3, 2); + current_statement__ = 4; + validate_non_negative_index("x_vector", "2", 2); + Eigen::Matrix x_vector; + x_vector = Eigen::Matrix(2); + + current_statement__ = 4; + x_vector = in__.vector(2); + current_statement__ = 5; + validate_non_negative_index("x_cov", "2", 2); + current_statement__ = 5; + validate_non_negative_index("x_cov", "2", 2); + Eigen::Matrix x_cov; + x_cov = Eigen::Matrix(2, 2); + + Eigen::Matrix x_cov_in__; + x_cov_in__ = Eigen::Matrix(3); + + current_statement__ = 5; + x_cov_in__ = in__.vector(3); + current_statement__ = 5; + assign(x_cov, nil_index_list(), + stan::math::cov_matrix_constrain(x_cov_in__, 2), + "assigning variable x_cov"); + vars__.push_back(theta); + vars__.push_back(phi); + { + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(2), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); + } + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(3), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); + } + } + { + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), "x_matrix")); + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(2), + cons_list(index_uni(2), nil_index_list())), "x_matrix")); + } + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(3), + cons_list(index_uni(2), nil_index_list())), "x_matrix")); + } + } + } + } + { + vars__.push_back(x_vector[(1 - 1)]); + { + vars__.push_back(x_vector[(2 - 1)]); + } + } + { + { + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "x_cov")); + { + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(2), + cons_list(index_uni(1), nil_index_list())), "x_cov")); + } + } + { + { + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), "x_cov")); + { + vars__.push_back( + rvalue(x_cov, + cons_list(index_uni(2), + cons_list(index_uni(2), nil_index_list())), "x_cov")); + } + } + } + } + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + double lcm_sym53__; + double lcm_sym52__; + double lcm_sym51__; + double lcm_sym50__; + double lcm_sym49__; + double lcm_sym48__; + double lcm_sym47__; + double lcm_sym46__; + double lcm_sym45__; + double lcm_sym44__; + double lcm_sym43__; + double lcm_sym42__; + double lcm_sym41__; + double lcm_sym40__; + int lcm_sym39__; + int pos__; + + pos__ = 1; + double theta; + + current_statement__ = 1; + theta = context__.vals_r("theta")[(1 - 1)]; + double phi; + + current_statement__ = 2; + phi = context__.vals_r("phi")[(1 - 1)]; + current_statement__ = 3; + validate_non_negative_index("x_matrix", "3", 3); + current_statement__ = 3; + validate_non_negative_index("x_matrix", "2", 2); + Eigen::Matrix x_matrix; + x_matrix = Eigen::Matrix(3, 2); + + { + std::vector x_matrix_flat__; + current_statement__ = 3; + assign(x_matrix_flat__, nil_index_list(), + context__.vals_r("x_matrix"), "assigning variable x_matrix_flat__"); + current_statement__ = 3; + pos__ = 1; + { + { + current_statement__ = 3; + assign(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + x_matrix_flat__[(1 - 1)], "assigning variable x_matrix"); + current_statement__ = 3; + pos__ = 2; + { + current_statement__ = 3; + assign(x_matrix, + cons_list(index_uni(2), + cons_list(index_uni(1), nil_index_list())), + x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); + current_statement__ = 3; + pos__ = (pos__ + 1); + } + { + current_statement__ = 3; + assign(x_matrix, + cons_list(index_uni(3), + cons_list(index_uni(1), nil_index_list())), + x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); + current_statement__ = 3; + pos__ = (pos__ + 1); + } + } + { + { + current_statement__ = 3; + assign(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), + x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); + current_statement__ = 3; + pos__ = (pos__ + 1); + { + current_statement__ = 3; + assign(x_matrix, + cons_list(index_uni(2), + cons_list(index_uni(2), nil_index_list())), + x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); + current_statement__ = 3; + pos__ = (pos__ + 1); + } + { + current_statement__ = 3; + assign(x_matrix, + cons_list(index_uni(3), + cons_list(index_uni(2), nil_index_list())), + x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); + current_statement__ = 3; + pos__ = (pos__ + 1); + } + } + } + } + } + current_statement__ = 4; + validate_non_negative_index("x_vector", "2", 2); + Eigen::Matrix x_vector; + x_vector = Eigen::Matrix(2); + + { + std::vector x_vector_flat__; + current_statement__ = 4; + assign(x_vector_flat__, nil_index_list(), + context__.vals_r("x_vector"), "assigning variable x_vector_flat__"); + current_statement__ = 4; + pos__ = 1; + { + current_statement__ = 4; + assign(x_vector, cons_list(index_uni(1), nil_index_list()), + x_vector_flat__[(1 - 1)], "assigning variable x_vector"); + current_statement__ = 4; + pos__ = 2; + { + current_statement__ = 4; + assign(x_vector, cons_list(index_uni(2), nil_index_list()), + x_vector_flat__[(pos__ - 1)], "assigning variable x_vector"); + current_statement__ = 4; + pos__ = (pos__ + 1); + } + } + } + current_statement__ = 5; + validate_non_negative_index("x_cov", "2", 2); + current_statement__ = 5; + validate_non_negative_index("x_cov", "2", 2); + Eigen::Matrix x_cov; + x_cov = Eigen::Matrix(2, 2); + + { + std::vector x_cov_flat__; + current_statement__ = 5; + assign(x_cov_flat__, nil_index_list(), context__.vals_r("x_cov"), + "assigning variable x_cov_flat__"); + current_statement__ = 5; + pos__ = 1; + { + { + current_statement__ = 5; + assign(x_cov, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), + x_cov_flat__[(1 - 1)], "assigning variable x_cov"); + current_statement__ = 5; + pos__ = 2; + { + current_statement__ = 5; + assign(x_cov, + cons_list(index_uni(2), + cons_list(index_uni(1), nil_index_list())), + x_cov_flat__[(pos__ - 1)], "assigning variable x_cov"); + current_statement__ = 5; + pos__ = (pos__ + 1); + } + } + { + { + current_statement__ = 5; + assign(x_cov, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), + x_cov_flat__[(pos__ - 1)], "assigning variable x_cov"); + current_statement__ = 5; + pos__ = (pos__ + 1); + { + current_statement__ = 5; + assign(x_cov, + cons_list(index_uni(2), + cons_list(index_uni(2), nil_index_list())), + x_cov_flat__[(pos__ - 1)], "assigning variable x_cov"); + current_statement__ = 5; + pos__ = (pos__ + 1); + } + } + } + } + } + current_statement__ = 5; + validate_non_negative_index("x_cov_free__", + "(2 + ((2 * (2 - 1)) / 2))", 3); + Eigen::Matrix x_cov_free__; + x_cov_free__ = Eigen::Matrix(3); + + current_statement__ = 5; + assign(x_cov_free__, nil_index_list(), + stan::math::cov_matrix_free(x_cov), "assigning variable x_cov_free__"); + vars__.push_back(theta); + vars__.push_back(phi); + { + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(2), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); + } + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(3), + cons_list(index_uni(1), nil_index_list())), "x_matrix")); + } + } + { + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(1), + cons_list(index_uni(2), nil_index_list())), "x_matrix")); + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(2), + cons_list(index_uni(2), nil_index_list())), "x_matrix")); + } + { + vars__.push_back( + rvalue(x_matrix, + cons_list(index_uni(3), + cons_list(index_uni(2), nil_index_list())), "x_matrix")); + } + } + } + } + { + vars__.push_back(x_vector[(1 - 1)]); + { + vars__.push_back(x_vector[(2 - 1)]); + } + } + { + vars__.push_back(x_cov_free__[(1 - 1)]); + { + vars__.push_back(x_cov_free__[(2 - 1)]); + } + { + vars__.push_back(x_cov_free__[(3 - 1)]); + } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("theta"); + names__.push_back("phi"); + names__.push_back("x_matrix"); + names__.push_back("x_vector"); + names__.push_back("x_cov"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(3); + + dims__.push_back(2); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(2); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(2); + + dims__.push_back(2); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "theta"); + param_names__.push_back(std::string() + "phi"); + for (size_t sym80__ = 1; sym80__ <= 2; ++sym80__) { + { + for (size_t sym81__ = 1; sym81__ <= 3; ++sym81__) { + { + param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym81__) + '.' + std::to_string(sym80__)); + }} + }} + for (size_t sym80__ = 1; sym80__ <= 2; ++sym80__) { + { + param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym80__)); + }} + for (size_t sym80__ = 1; sym80__ <= 2; ++sym80__) { + { + for (size_t sym81__ = 1; sym81__ <= 2; ++sym81__) { + { + param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym81__) + '.' + std::to_string(sym80__)); + }} + }} + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + param_names__.push_back(std::string() + "theta"); + param_names__.push_back(std::string() + "phi"); + for (size_t sym80__ = 1; sym80__ <= 2; ++sym80__) { + { + for (size_t sym81__ = 1; sym81__ <= 3; ++sym81__) { + { + param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym81__) + '.' + std::to_string(sym80__)); + }} + }} + for (size_t sym80__ = 1; sym80__ <= 2; ++sym80__) { + { + param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym80__)); + }} + for (size_t sym80__ = 1; sym80__ <= 3; ++sym80__) { + { + param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym80__)); + }} + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"x_matrix\",\"type\":{\"name\":\"matrix\",\"rows\":" << 3 << ",\"cols\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"x_vector\",\"type\":{\"name\":\"vector\",\"length\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"x_cov\",\"type\":{\"name\":\"matrix\",\"rows\":" << 2 << ",\"cols\":" << 2 << "},\"block\":\"parameters\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"x_matrix\",\"type\":{\"name\":\"matrix\",\"rows\":" << 3 << ",\"cols\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"x_vector\",\"type\":{\"name\":\"vector\",\"length\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"x_cov\",\"type\":{\"name\":\"vector\",\"length\":" << 3 << "},\"block\":\"parameters\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef optimizations_model_namespace::optimizations_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp partial-eval.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace partial_eval_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'partial-eval.stan', line 10, column 2 to column 19)", + " (in 'partial-eval.stan', line 11, column 2 to column 17)", + " (in 'partial-eval.stan', line 12, column 2 to column 12)", + " (in 'partial-eval.stan', line 13, column 2 to column 34)", + " (in 'partial-eval.stan', line 14, column 2 to column 34)", + " (in 'partial-eval.stan', line 17, column 2 to column 18)", + " (in 'partial-eval.stan', line 20, column 4 to line 21, column 42)", + " (in 'partial-eval.stan', line 19, column 2 to line 21, column 42)", + " (in 'partial-eval.stan', line 24, column 2 to column 22)", + " (in 'partial-eval.stan', line 25, column 2 to column 34)", + " (in 'partial-eval.stan', line 26, column 2 to column 24)", + " (in 'partial-eval.stan', line 27, column 2 to column 29)", + " (in 'partial-eval.stan', line 2, column 2 to column 17)", + " (in 'partial-eval.stan', line 3, column 2 to column 22)", + " (in 'partial-eval.stan', line 4, column 2 to column 36)", + " (in 'partial-eval.stan', line 5, column 2 to column 21)", + " (in 'partial-eval.stan', line 6, column 2 to column 39)", + " (in 'partial-eval.stan', line 7, column 2 to column 14)"}; + + + +class partial_eval_model : public model_base_crtp { + + private: + double lcm_sym41__; + double lcm_sym40__; + double lcm_sym39__; + double lcm_sym38__; + double lcm_sym37__; + double lcm_sym36__; + int lcm_sym35__; + int lcm_sym34__; + int lcm_sym33__; + int lcm_sym32__; + int pos__; + int N; + int n_pair; + std::vector pair; + Eigen::Matrix pre_test; + Eigen::Matrix treatment; + Eigen::Matrix y; + + public: + ~partial_eval_model() { } + + std::string model_name() const { return "partial_eval_model"; } + + partial_eval_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "partial_eval_model_namespace::partial_eval_model"; + (void) function__; // suppress unused var warning + + try { + + + + + + + + + + + + pos__ = 1; + context__.validate_dims("data initialization","N","int", + context__.to_vec()); + + current_statement__ = 13; + N = context__.vals_i("N")[(1 - 1)]; + context__.validate_dims("data initialization","n_pair","int", + context__.to_vec()); + + current_statement__ = 14; + n_pair = context__.vals_i("n_pair")[(1 - 1)]; + current_statement__ = 15; + validate_non_negative_index("pair", "N", N); + context__.validate_dims("data initialization","pair","int", + context__.to_vec(N)); + pair = std::vector(N, 0); + + current_statement__ = 15; + assign(pair, nil_index_list(), context__.vals_i("pair"), + "assigning variable pair"); + current_statement__ = 16; + validate_non_negative_index("pre_test", "N", N); + context__.validate_dims("data initialization","pre_test","double", + context__.to_vec(N)); + pre_test = Eigen::Matrix(N); + + { + std::vector pre_test_flat__; + current_statement__ = 16; + assign(pre_test_flat__, nil_index_list(), + context__.vals_r("pre_test"), "assigning variable pre_test_flat__"); + current_statement__ = 16; + pos__ = 1; + lcm_sym32__ = logical_gte(N, 1); + if (lcm_sym32__) { + current_statement__ = 16; + assign(pre_test, cons_list(index_uni(1), nil_index_list()), + pre_test_flat__[(1 - 1)], "assigning variable pre_test"); + current_statement__ = 16; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 16; + assign(pre_test, cons_list(index_uni(sym1__), nil_index_list()), + pre_test_flat__[(pos__ - 1)], "assigning variable pre_test"); + current_statement__ = 16; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 17; + validate_non_negative_index("treatment", "N", N); + context__.validate_dims("data initialization","treatment","double", + context__.to_vec(N)); + treatment = Eigen::Matrix(N); + + { + std::vector treatment_flat__; + current_statement__ = 17; + assign(treatment_flat__, nil_index_list(), + context__.vals_r("treatment"), + "assigning variable treatment_flat__"); + current_statement__ = 17; + pos__ = 1; + current_statement__ = 17; + if (lcm_sym32__) { + current_statement__ = 17; + assign(treatment, cons_list(index_uni(1), nil_index_list()), + treatment_flat__[(1 - 1)], "assigning variable treatment"); + current_statement__ = 17; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 17; + assign(treatment, cons_list(index_uni(sym1__), nil_index_list()), + treatment_flat__[(pos__ - 1)], "assigning variable treatment"); + current_statement__ = 17; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 18; + validate_non_negative_index("y", "N", N); + context__.validate_dims("data initialization","y","double", + context__.to_vec(N)); + y = Eigen::Matrix(N); + + { + std::vector y_flat__; + current_statement__ = 18; + assign(y_flat__, nil_index_list(), context__.vals_r("y"), + "assigning variable y_flat__"); + current_statement__ = 18; + pos__ = 1; + current_statement__ = 18; + if (lcm_sym32__) { + current_statement__ = 18; + assign(y, cons_list(index_uni(1), nil_index_list()), + y_flat__[(1 - 1)], "assigning variable y"); + current_statement__ = 18; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 18; + assign(y, cons_list(index_uni(sym1__), nil_index_list()), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 18; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 13; + current_statement__ = 13; + check_greater_or_equal(function__, "N", N, 0); + current_statement__ = 14; + current_statement__ = 14; + check_greater_or_equal(function__, "n_pair", n_pair, 0); + current_statement__ = 15; + if (lcm_sym32__) { + current_statement__ = 15; + current_statement__ = 15; + check_greater_or_equal(function__, "pair[sym1__]", pair[(1 - 1)], 1); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 15; + current_statement__ = 15; + check_greater_or_equal(function__, "pair[sym1__]", + pair[(sym1__ - 1)], 1);} + } + current_statement__ = 15; + if (lcm_sym32__) { + current_statement__ = 15; + current_statement__ = 15; + check_less_or_equal(function__, "pair[sym1__]", pair[(1 - 1)], n_pair); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 15; + current_statement__ = 15; + check_less_or_equal(function__, "pair[sym1__]", pair[(sym1__ - 1)], + n_pair);} + } + current_statement__ = 17; + current_statement__ = 17; + check_greater_or_equal(function__, "treatment", treatment, 0); + current_statement__ = 17; + current_statement__ = 17; + check_less_or_equal(function__, "treatment", treatment, 1); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + num_params_r__ = 0U; + + try { + current_statement__ = 1; + validate_non_negative_index("a", "n_pair", n_pair); + num_params_r__ += n_pair; + current_statement__ = 2; + validate_non_negative_index("beta", "2", 2); + num_params_r__ += 2; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "partial_eval_model_namespace::log_prob"; +(void) function__; // suppress unused var warning + + stan::io::reader in__(params_r__, params_i__); + + try { + double lcm_sym31__; + double lcm_sym30__; + double lcm_sym29__; + double lcm_sym28__; + double lcm_sym27__; + double lcm_sym26__; + double lcm_sym25__; + int lcm_sym24__; + current_statement__ = 1; + validate_non_negative_index("a", "n_pair", n_pair); + Eigen::Matrix a; + a = Eigen::Matrix(n_pair); + + current_statement__ = 1; + a = in__.vector(n_pair); + current_statement__ = 2; + validate_non_negative_index("beta", "2", 2); + Eigen::Matrix beta; + beta = Eigen::Matrix(2); + + current_statement__ = 2; + beta = in__.vector(2); + local_scalar_t__ mu_a; + + current_statement__ = 3; + mu_a = in__.scalar(); + local_scalar_t__ sigma_a; + + current_statement__ = 4; + sigma_a = in__.scalar(); + current_statement__ = 4; + if (jacobian__) { + current_statement__ = 4; + sigma_a = stan::math::lub_constrain(sigma_a, 0, 100, lp__); + } else { + current_statement__ = 4; + sigma_a = stan::math::lub_constrain(sigma_a, 0, 100); + } + local_scalar_t__ sigma_y; + + current_statement__ = 5; + sigma_y = in__.scalar(); + current_statement__ = 5; + if (jacobian__) { + current_statement__ = 5; + sigma_y = stan::math::lub_constrain(sigma_y, 0, 100, lp__); + } else { + current_statement__ = 5; + sigma_y = stan::math::lub_constrain(sigma_y, 0, 100); + } + current_statement__ = 6; + validate_non_negative_index("y_hat", "N", N); + Eigen::Matrix y_hat; + y_hat = Eigen::Matrix(N); + + lcm_sym24__ = logical_gte(N, 1); + if (lcm_sym24__) { + lcm_sym31__ = std::numeric_limits::quiet_NaN(); + assign(y_hat, cons_list(index_uni(1), nil_index_list()), lcm_sym31__, + "assigning variable y_hat"); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 6; + assign(y_hat, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym31__, "assigning variable y_hat");} + } + current_statement__ = 8; + if (lcm_sym24__) { + current_statement__ = 7; + assign(y_hat, cons_list(index_uni(1), nil_index_list()), + stan::math::fma(beta[(2 - 1)], pre_test[(1 - 1)], + stan::math::fma(beta[(1 - 1)], treatment[(1 - 1)], + a[(pair[(1 - 1)] - 1)])), "assigning variable y_hat"); + for (size_t i = 2; i <= N; ++i) { + current_statement__ = 7; + assign(y_hat, cons_list(index_uni(i), nil_index_list()), + stan::math::fma(beta[(2 - 1)], pre_test[(i - 1)], + stan::math::fma(beta[(1 - 1)], treatment[(i - 1)], + a[(pair[(i - 1)] - 1)])), "assigning variable y_hat");} + } + { + current_statement__ = 9; + lp_accum__.add(normal_log(mu_a, 0, 1)); + current_statement__ = 10; + lp_accum__.add(normal_log(a, (100 * mu_a), sigma_a)); + current_statement__ = 11; + lp_accum__.add(normal_log(beta, 0, 100)); + current_statement__ = 12; + lp_accum__.add(normal_log(y, y_hat, sigma_y)); + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() + + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { + typedef double local_scalar_t__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "partial_eval_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + + try { + double lcm_sym23__; + double lcm_sym22__; + double lcm_sym21__; + double lcm_sym20__; + double lcm_sym19__; + double lcm_sym18__; + double lcm_sym17__; + double lcm_sym16__; + double lcm_sym15__; + int lcm_sym14__; + int lcm_sym13__; + int lcm_sym12__; + int lcm_sym11__; + current_statement__ = 1; + validate_non_negative_index("a", "n_pair", n_pair); + Eigen::Matrix a; + a = Eigen::Matrix(n_pair); + + current_statement__ = 1; + a = in__.vector(n_pair); + current_statement__ = 2; + validate_non_negative_index("beta", "2", 2); + Eigen::Matrix beta; + beta = Eigen::Matrix(2); + + current_statement__ = 2; + beta = in__.vector(2); + double mu_a; + + current_statement__ = 3; + mu_a = in__.scalar(); + double sigma_a; + + current_statement__ = 4; + sigma_a = in__.scalar(); + current_statement__ = 4; + sigma_a = stan::math::lub_constrain(sigma_a, 0, 100); + double sigma_y; + + current_statement__ = 5; + sigma_y = in__.scalar(); + current_statement__ = 5; + sigma_y = stan::math::lub_constrain(sigma_y, 0, 100); + current_statement__ = 6; + validate_non_negative_index("y_hat", "N", N); + Eigen::Matrix y_hat; + y_hat = Eigen::Matrix(N); + + lcm_sym11__ = logical_gte(N, 1); + if (lcm_sym11__) { + lcm_sym17__ = std::numeric_limits::quiet_NaN(); + assign(y_hat, cons_list(index_uni(1), nil_index_list()), lcm_sym17__, + "assigning variable y_hat"); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + current_statement__ = 6; + assign(y_hat, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym17__, "assigning variable y_hat");} + } + if (logical_gte(n_pair, 1)) { + vars__.push_back(a[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_pair; ++sym1__) { + vars__.push_back(a[(sym1__ - 1)]);} + } + { + vars__.push_back(beta[(1 - 1)]); + { + vars__.push_back(beta[(2 - 1)]); + } + } + vars__.push_back(mu_a); + vars__.push_back(sigma_a); + vars__.push_back(sigma_y); + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + current_statement__ = 8; + if (lcm_sym11__) { + current_statement__ = 7; + assign(y_hat, cons_list(index_uni(1), nil_index_list()), + stan::math::fma(beta[(2 - 1)], pre_test[(1 - 1)], + stan::math::fma(beta[(1 - 1)], treatment[(1 - 1)], + a[(pair[(1 - 1)] - 1)])), "assigning variable y_hat"); + for (size_t i = 2; i <= N; ++i) { + current_statement__ = 7; + assign(y_hat, cons_list(index_uni(i), nil_index_list()), + stan::math::fma(beta[(2 - 1)], pre_test[(i - 1)], + stan::math::fma(beta[(1 - 1)], treatment[(i - 1)], + a[(pair[(i - 1)] - 1)])), "assigning variable y_hat");} + } + if (lcm_sym11__) { + vars__.push_back(y_hat[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= N; ++sym1__) { + vars__.push_back(y_hat[(sym1__ - 1)]);} + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + double lcm_sym10__; + double lcm_sym9__; + double lcm_sym8__; + double lcm_sym7__; + double lcm_sym6__; + double lcm_sym5__; + double lcm_sym4__; + double lcm_sym3__; + int lcm_sym2__; + int lcm_sym1__; + int pos__; + + pos__ = 1; + current_statement__ = 1; + validate_non_negative_index("a", "n_pair", n_pair); + Eigen::Matrix a; + a = Eigen::Matrix(n_pair); + + { + std::vector a_flat__; + current_statement__ = 1; + assign(a_flat__, nil_index_list(), context__.vals_r("a"), + "assigning variable a_flat__"); + current_statement__ = 1; + pos__ = 1; + lcm_sym1__ = logical_gte(n_pair, 1); + if (lcm_sym1__) { + current_statement__ = 1; + assign(a, cons_list(index_uni(1), nil_index_list()), + a_flat__[(1 - 1)], "assigning variable a"); + current_statement__ = 1; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= n_pair; ++sym1__) { + current_statement__ = 1; + assign(a, cons_list(index_uni(sym1__), nil_index_list()), + a_flat__[(pos__ - 1)], "assigning variable a"); + current_statement__ = 1; + pos__ = (pos__ + 1);} + } + } + current_statement__ = 2; + validate_non_negative_index("beta", "2", 2); + Eigen::Matrix beta; + beta = Eigen::Matrix(2); + + { + std::vector beta_flat__; + current_statement__ = 2; + assign(beta_flat__, nil_index_list(), context__.vals_r("beta"), + "assigning variable beta_flat__"); + current_statement__ = 2; + pos__ = 1; + { + current_statement__ = 2; + assign(beta, cons_list(index_uni(1), nil_index_list()), + beta_flat__[(1 - 1)], "assigning variable beta"); + current_statement__ = 2; + pos__ = 2; + { + current_statement__ = 2; + assign(beta, cons_list(index_uni(2), nil_index_list()), + beta_flat__[(pos__ - 1)], "assigning variable beta"); + current_statement__ = 2; + pos__ = (pos__ + 1); + } + } + } + double mu_a; + + current_statement__ = 3; + mu_a = context__.vals_r("mu_a")[(1 - 1)]; + double sigma_a; + + current_statement__ = 4; + sigma_a = context__.vals_r("sigma_a")[(1 - 1)]; + current_statement__ = 4; + sigma_a = stan::math::lub_free(sigma_a, 0, 100); + double sigma_y; + + current_statement__ = 5; + sigma_y = context__.vals_r("sigma_y")[(1 - 1)]; + current_statement__ = 5; + sigma_y = stan::math::lub_free(sigma_y, 0, 100); + if (lcm_sym1__) { + vars__.push_back(a[(1 - 1)]); + for (size_t sym1__ = 2; sym1__ <= n_pair; ++sym1__) { + vars__.push_back(a[(sym1__ - 1)]);} + } + { + vars__.push_back(beta[(1 - 1)]); + { + vars__.push_back(beta[(2 - 1)]); + } + } + vars__.push_back(mu_a); + vars__.push_back(sigma_a); + vars__.push_back(sigma_y); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits() + + void get_param_names(std::vector& names__) const { + + names__.resize(0); + names__.push_back("a"); + names__.push_back("beta"); + names__.push_back("mu_a"); + names__.push_back("sigma_a"); + names__.push_back("sigma_y"); + names__.push_back("y_hat"); + } // get_param_names() + + void get_dims(std::vector>& dimss__) const { + dimss__.resize(0); + std::vector dims__; + dims__.push_back(n_pair); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(2); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(N); + dimss__.push_back(dims__); + dims__.resize(0); + + } // get_dims() + + void constrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + for (size_t sym42__ = 1; sym42__ <= n_pair; ++sym42__) { + { + param_names__.push_back(std::string() + "a" + '.' + std::to_string(sym42__)); + }} + for (size_t sym42__ = 1; sym42__ <= 2; ++sym42__) { + { + param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym42__)); + }} + param_names__.push_back(std::string() + "mu_a"); + param_names__.push_back(std::string() + "sigma_a"); + param_names__.push_back(std::string() + "sigma_y"); + if (emit_transformed_parameters__) { + for (size_t sym42__ = 1; sym42__ <= N; ++sym42__) { + { + param_names__.push_back(std::string() + "y_hat" + '.' + std::to_string(sym42__)); + }} + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + void unconstrained_param_names(std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const { + + for (size_t sym42__ = 1; sym42__ <= n_pair; ++sym42__) { + { + param_names__.push_back(std::string() + "a" + '.' + std::to_string(sym42__)); + }} + for (size_t sym42__ = 1; sym42__ <= 2; ++sym42__) { + { + param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym42__)); + }} + param_names__.push_back(std::string() + "mu_a"); + param_names__.push_back(std::string() + "sigma_a"); + param_names__.push_back(std::string() + "sigma_y"); + if (emit_transformed_parameters__) { + for (size_t sym42__ = 1; sym42__ <= N; ++sym42__) { + { + param_names__.push_back(std::string() + "y_hat" + '.' + std::to_string(sym42__)); + }} + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + + std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"a\",\"type\":{\"name\":\"vector\",\"length\":" << n_pair << "},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"mu_a\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_a\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_y\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"a\",\"type\":{\"name\":\"vector\",\"length\":" << n_pair << "},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"mu_a\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_a\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_y\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + void write_array(RNG& base_rng__, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream = 0) const { + std::vector params_r_vec(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r_vec[i] = params_r(i); + std::vector vars_vec; + std::vector params_i_vec; + write_array(base_rng__, params_r_vec, params_i_vec, vars_vec, + emit_transformed_parameters__, emit_generated_quantities__, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) + vars(i) = vars_vec[i]; + } + + template + T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = 0) const { + std::vector vec_params_r; + vec_params_r.reserve(params_r.size()); + for (int i = 0; i < params_r.size(); ++i) + vec_params_r.push_back(params_r(i)); + std::vector vec_params_i; + return log_prob(vec_params_r, vec_params_i, pstream); + } + + void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream__) const { + std::vector params_r_vec; + std::vector params_i_vec; + transform_inits(context, params_i_vec, params_r_vec, pstream__); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) + params_r(i) = params_r_vec[i]; + } + +}; +} +typedef partial_eval_model_namespace::partial_eval_model stan_model; + +#ifndef USING_R + +// Boilerplate +stan::model::model_base& new_model( + stan::io::var_context& data_context, + unsigned int seed, + std::ostream* msg_stream) { + stan_model* m = new stan_model(data_context, seed, msg_stream); + return *m; +} + +#endif + + + + $ ../../../../../install/default/bin/stanc --O 2 --print-cpp stalled1-failure.stan + +// Code generated by %%NAME%% %%VERSION%% +#include +namespace stalled1_failure_model_namespace { + +template +std::vector resize_to_match__(std::vector& dst, const std::vector& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.rows(), src.cols()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} + +template +Eigen::Matrix +resize_to_match__(Eigen::Matrix& dst, const Eigen::Matrix& src) { + dst.resize(src.size()); + return dst; +} +std::vector to_doubles__(std::initializer_list x) { + return x; +} + +std::vector to_vars__(std::initializer_list x) { + return x; +} + +inline void validate_positive_index(const char* var_name, const char* expr, + int val) { + if (val < 1) { + std::stringstream msg; + msg << "Found dimension size less than one in simplex declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + +inline void validate_unit_vector_index(const char* var_name, const char* expr, + int val) { + if (val <= 1) { + std::stringstream msg; + if (val == 1) { + msg << "Found dimension size one in unit vector declaration." + << " One-dimensional unit vector is discrete" + << " but the target distribution must be continuous." + << " variable=" << var_name << "; dimension size expression=" << expr; + } else { + msg << "Found dimension size less than one in unit vector declaration" + << "; variable=" << var_name << "; dimension size expression=" << expr + << "; expression value=" << val; + } + std::string msg_str(msg.str()); + throw std::invalid_argument(msg_str.c_str()); + } +} + + +using std::istream; +using std::string; +using std::stringstream; +using std::vector; +using std::pow; +using stan::io::dump; +using stan::math::lgamma; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; +using namespace stan::math; + +static int current_statement__ = 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'stalled1-failure.stan', line 30, column 4 to column 16)", + " (in 'stalled1-failure.stan', line 31, column 4 to column 16)", + " (in 'stalled1-failure.stan', line 32, column 4 to column 16)", + " (in 'stalled1-failure.stan', line 33, column 4 to column 17)", + " (in 'stalled1-failure.stan', line 34, column 4 to column 22)", + " (in 'stalled1-failure.stan', line 35, column 4 to column 19)", + " (in 'stalled1-failure.stan', line 39, column 4 to column 15)", + " (in 'stalled1-failure.stan', line 44, column 3 to column 31)", + " (in 'stalled1-failure.stan', line 45, column 3 to column 31)", + " (in 'stalled1-failure.stan', line 46, column 3 to column 31)", + " (in 'stalled1-failure.stan', line 47, column 3 to column 32)", + " (in 'stalled1-failure.stan', line 48, column 3 to column 31)", + " (in 'stalled1-failure.stan', line 50, column 6 to column 32)", + " (in 'stalled1-failure.stan', line 51, column 6 to column 103)", + " (in 'stalled1-failure.stan', line 49, column 18 to line 52, column 4)", + " (in 'stalled1-failure.stan', line 49, column 3 to line 52, column 4)", + " (in 'stalled1-failure.stan', line 15, column 4 to column 19)", + " (in 'stalled1-failure.stan', line 16, column 4 to column 22)", + " (in 'stalled1-failure.stan', line 17, column 4 to column 22)", + " (in 'stalled1-failure.stan', line 18, column 4 to column 17)", + " (in 'stalled1-failure.stan', line 19, column 4 to column 17)", + " (in 'stalled1-failure.stan', line 23, column 4 to column 10)", + " (in 'stalled1-failure.stan', line 24, column 4 to column 19)", + " (in 'stalled1-failure.stan', line 25, column 4 to column 11)", + " (in 'stalled1-failure.stan', line 26, column 4 to column 21)"}; + + + +class stalled1_failure_model : public model_base_crtp { + + private: + double lcm_sym41__; + double lcm_sym40__; + double lcm_sym39__; + double lcm_sym38__; + int lcm_sym37__; + int lcm_sym36__; + int lcm_sym35__; + int lcm_sym34__; + double lcm_sym33__; + int lcm_sym32__; + int lcm_sym31__; + Eigen::Matrix lcm_sym30__; + int pos__; + int I; + std::vector n; + std::vector N; + Eigen::Matrix x1; + Eigen::Matrix x2; + int K; + Eigen::Matrix x1x2; + + public: + ~stalled1_failure_model() { } + + std::string model_name() const { return "stalled1_failure_model"; } + + stalled1_failure_model(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + typedef double local_scalar_t__; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "stalled1_failure_model_namespace::stalled1_failure_model"; + (void) function__; // suppress unused var warning + + try { + + + + + + + + + + + + + + pos__ = 1; + context__.validate_dims("data initialization","I","int", + context__.to_vec()); + + current_statement__ = 17; + I = context__.vals_i("I")[(1 - 1)]; + current_statement__ = 18; + validate_non_negative_index("n", "I", I); + context__.validate_dims("data initialization","n","int", + context__.to_vec(I)); + n = std::vector(I, 0); + + current_statement__ = 18; + assign(n, nil_index_list(), context__.vals_i("n"), + "assigning variable n"); + current_statement__ = 19; + validate_non_negative_index("N", "I", I); + context__.validate_dims("data initialization","N","int", + context__.to_vec(I)); + N = std::vector(I, 0); + + current_statement__ = 19; + assign(N, nil_index_list(), context__.vals_i("N"), + "assigning variable N"); + current_statement__ = 20; + validate_non_negative_index("x1", "I", I); + context__.validate_dims("data initialization","x1","double", + context__.to_vec(I)); + x1 = Eigen::Matrix(I); + + { + std::vector x1_flat__; + current_statement__ = 20; + assign(x1_flat__, nil_index_list(), context__.vals_r("x1"), + "assigning variable x1_flat__"); + current_statement__ = 20; + pos__ = 1; + lcm_sym31__ = logical_gte(I, 1); + if (lcm_sym31__) { + current_statement__ = 20; + assign(x1, cons_list(index_uni(1), nil_index_list()), + x1_flat__[(1 - 1)], "assigning variable x1"); + current_statement__ = 20; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= I; ++sym1__) { + current_statement__ = 20; + assign(x1, cons_list(index_uni(sym1__), nil_index_list()), + x1_flat__[(pos__ - 1)], "assigning variable x1"); + current_statement__ = 20; + pos__ = (pos__ + 1);} } - current_statement__ = 43; - lp_accum__.add(x); - double z; - - current_statement__ = 45; - z = x; - current_statement__ = 46; - lp_accum__.add(x); - current_statement__ = 48; - if (lcm_sym72__) { - current_statement__ = 47; - z = x; + } + current_statement__ = 21; + validate_non_negative_index("x2", "I", I); + context__.validate_dims("data initialization","x2","double", + context__.to_vec(I)); + x2 = Eigen::Matrix(I); + + { + std::vector x2_flat__; + current_statement__ = 21; + assign(x2_flat__, nil_index_list(), context__.vals_r("x2"), + "assigning variable x2_flat__"); + current_statement__ = 21; + pos__ = 1; + current_statement__ = 21; + if (lcm_sym31__) { + current_statement__ = 21; + assign(x2, cons_list(index_uni(1), nil_index_list()), + x2_flat__[(1 - 1)], "assigning variable x2"); + current_statement__ = 21; + pos__ = 2; + for (size_t sym1__ = 2; sym1__ <= I; ++sym1__) { + current_statement__ = 21; + assign(x2, cons_list(index_uni(sym1__), nil_index_list()), + x2_flat__[(pos__ - 1)], "assigning variable x2"); + current_statement__ = 21; + pos__ = (pos__ + 1);} } - current_statement__ = 49; - lp_accum__.add(z); - current_statement__ = 50; - lp_accum__.add(2); - { - double y; - - current_statement__ = 52; - lp_accum__.add(24); - } - { - double y; - - current_statement__ = 55; - lp_accum__.add(245); - } - { - current_statement__ = 57; - lp_accum__.add(2); - } - int inline_sym20__; - int inline_sym21__; - - for (size_t inline_sym22__ = 1; inline_sym22__ <= 1; ++inline_sym22__) { - current_statement__ = 59; - lp_accum__.add(2); - break;} - current_statement__ = 62; - while (576) { - break; - } - int inline_sym23__; - int inline_sym24__; - - for (size_t inline_sym25__ = 1; inline_sym25__ <= 1; ++inline_sym25__) { - current_statement__ = 59; - lp_accum__.add(2); - inline_sym23__ = 24; - break;} - while (inline_sym23__) { - { - break; - } - int inline_sym24__; - - for (size_t inline_sym25__ = 1; inline_sym25__ <= 1; - ++inline_sym25__) { - current_statement__ = 59; - lp_accum__.add(2); - inline_sym23__ = 24; - break;} - } - current_statement__ = 65; - for (size_t i = 31; i <= 225; ++i) { continue;} - current_statement__ = 67; - for (size_t i = 31; i <= 225; ++i) { break;} - int inline_sym26__; - int inline_sym27__; - - for (size_t inline_sym28__ = 1; inline_sym28__ <= 1; ++inline_sym28__) { - current_statement__ = 59; - lp_accum__.add(2); - inline_sym26__ = 24; - break;} - for (size_t i = inline_sym26__; i <= 225; ++i) { continue;} - int inline_sym29__; - int inline_sym30__; - - for (size_t inline_sym31__ = 1; inline_sym31__ <= 1; ++inline_sym31__) { - current_statement__ = 59; - lp_accum__.add(2); - inline_sym29__ = 24; - break;} - for (size_t i = inline_sym29__; i <= 225; ++i) { break;} - int inline_sym32__; - int inline_sym33__; - - for (size_t inline_sym34__ = 1; inline_sym34__ <= 1; ++inline_sym34__) { - current_statement__ = 59; - lp_accum__.add(2); - break;} - { - current_statement__ = 70; - lp_accum__.add(1); - current_statement__ = 71; - lp_accum__.add(24); - } - { - { - current_statement__ = 73; - lp_accum__.add(1); - } - } - double temp; - - { - current_statement__ = 77; - if (pstream__) { - stan_print(pstream__, "hello"); - stan_print(pstream__, "\n"); - } - } - double temp2; - - { - current_statement__ = 80; - lp_accum__.add(4); - current_statement__ = 81; - lp_accum__.add(6); - { - current_statement__ = 80; - lp_accum__.add(4); - current_statement__ = 81; - lp_accum__.add(6); - } + } + + current_statement__ = 23; + validate_non_negative_index("x1x2", "I", I); + x1x2 = Eigen::Matrix(I); + + current_statement__ = 23; + if (lcm_sym31__) { + lcm_sym33__ = std::numeric_limits::quiet_NaN(); + assign(x1x2, cons_list(index_uni(1), nil_index_list()), lcm_sym33__, + "assigning variable x1x2"); + for (size_t sym1__ = 2; sym1__ <= I; ++sym1__) { + current_statement__ = 23; + assign(x1x2, cons_list(index_uni(sym1__), nil_index_list()), + lcm_sym33__, "assigning variable x1x2");} + } + current_statement__ = 24; + K = 8; + current_statement__ = 25; + assign(x1x2, nil_index_list(), elt_multiply(x1, x2), + "assigning variable x1x2"); + current_statement__ = 17; + current_statement__ = 17; + check_greater_or_equal(function__, "I", I, 0); + current_statement__ = 18; + if (lcm_sym31__) { + current_statement__ = 18; + current_statement__ = 18; + check_greater_or_equal(function__, "n[sym1__]", n[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= I; ++sym1__) { + current_statement__ = 18; + current_statement__ = 18; + check_greater_or_equal(function__, "n[sym1__]", n[(sym1__ - 1)], 0); } - double dataonlyvar; - - current_statement__ = 83; - dataonlyvar = 3; - current_statement__ = 84; - lp_accum__.add(dataonlyvar); - local_scalar_t__ paramvar; - - { - current_statement__ = 86; - paramvar = (theta * 34); + } + current_statement__ = 19; + if (lcm_sym31__) { + current_statement__ = 19; + current_statement__ = 19; + check_greater_or_equal(function__, "N[sym1__]", N[(1 - 1)], 0); + for (size_t sym1__ = 2; sym1__ <= I; ++sym1__) { + current_statement__ = 19; + current_statement__ = 19; + check_greater_or_equal(function__, "N[sym1__]", N[(sym1__ - 1)], 0); } - current_statement__ = 88; - lp_accum__.add(paramvar); - } + } } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); // Next line prevents compiler griping about no return throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); } - lp_accum__.add(lp__); - return lp_accum__.sum(); - } // log_prob() + num_params_r__ = 0U; - template - void write_array(RNG& base_rng__, std::vector& params_r__, - std::vector& params_i__, std::vector& vars__, - bool emit_transformed_parameters__ = true, - bool emit_generated_quantities__ = true, - std::ostream* pstream__ = 0) const { - typedef double local_scalar_t__; - vars__.resize(0); - stan::io::reader in__(params_r__, params_i__); - static const char* function__ = "optimizations_model_namespace::write_array"; + try { + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + num_params_r__ += 1; + current_statement__ = 6; + validate_non_negative_index("b", "I", I); + current_statement__ = 6; + validate_non_negative_index("b", "K", K); + num_params_r__ += I * K; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } + template + T__ log_prob(std::vector& params_r__, std::vector& params_i__, + std::ostream* pstream__ = 0) const { + typedef T__ local_scalar_t__; + T__ lp__(0.0); + stan::math::accumulator lp_accum__; + static const char* function__ = "stalled1_failure_model_namespace::log_prob"; (void) function__; // suppress unused var warning - (void) function__; // suppress unused var warning - - double lp__ = 0.0; - (void) lp__; // dummy to suppress unused var warning - stan::math::accumulator lp_accum__; + stan::io::reader in__(params_r__, params_i__); try { - double lcm_sym65__; - double lcm_sym64__; - double lcm_sym63__; - double lcm_sym62__; - double lcm_sym61__; - double lcm_sym60__; - double lcm_sym59__; - double lcm_sym58__; - double lcm_sym57__; - double lcm_sym56__; - int lcm_sym55__; - int lcm_sym54__; - double theta; + double lcm_sym29__; + double lcm_sym28__; + double lcm_sym27__; + double lcm_sym26__; + double lcm_sym25__; + double lcm_sym24__; + double lcm_sym23__; + double lcm_sym22__; + double lcm_sym21__; + double lcm_sym20__; + int lcm_sym19__; + local_scalar_t__ lcm_sym18__; + local_scalar_t__ alpha0; current_statement__ = 1; - theta = in__.scalar(); - double phi; + alpha0 = in__.scalar(); + local_scalar_t__ alpha1; current_statement__ = 2; - phi = in__.scalar(); - current_statement__ = 3; - validate_non_negative_index("x_matrix", "3", 3); - current_statement__ = 3; - validate_non_negative_index("x_matrix", "2", 2); - Eigen::Matrix x_matrix; - x_matrix = Eigen::Matrix(3, 2); + alpha1 = in__.scalar(); + local_scalar_t__ alpha2; current_statement__ = 3; - x_matrix = in__.matrix(3, 2); - current_statement__ = 4; - validate_non_negative_index("x_vector", "2", 2); - Eigen::Matrix x_vector; - x_vector = Eigen::Matrix(2); - - current_statement__ = 4; - x_vector = in__.vector(2); - current_statement__ = 5; - validate_non_negative_index("x_cov", "2", 2); - current_statement__ = 5; - validate_non_negative_index("x_cov", "2", 2); - Eigen::Matrix x_cov; - x_cov = Eigen::Matrix(2, 2); + alpha2 = in__.scalar(); + local_scalar_t__ alpha12; - Eigen::Matrix x_cov_in__; - x_cov_in__ = Eigen::Matrix(3); + current_statement__ = 4; + alpha12 = in__.scalar(); + local_scalar_t__ tau; current_statement__ = 5; - x_cov_in__ = in__.vector(3); + tau = in__.scalar(); current_statement__ = 5; - assign(x_cov, nil_index_list(), - stan::math::cov_matrix_constrain(x_cov_in__, 2), - "assigning variable x_cov"); - vars__.push_back(theta); - vars__.push_back(phi); - { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), "x_matrix")); - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), "x_matrix")); - } - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(3), - cons_list(index_uni(1), nil_index_list())), "x_matrix")); - } - } - { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), "x_matrix")); - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(2), - cons_list(index_uni(2), nil_index_list())), "x_matrix")); - } - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(3), - cons_list(index_uni(2), nil_index_list())), "x_matrix")); - } - } - } - } - { - vars__.push_back(x_vector[(1 - 1)]); - { - vars__.push_back(x_vector[(2 - 1)]); - } + if (jacobian__) { + current_statement__ = 5; + tau = stan::math::lb_constrain(tau, 0, lp__); + } else { + current_statement__ = 5; + tau = stan::math::lb_constrain(tau, 0); } + current_statement__ = 6; + validate_non_negative_index("b", "I", I); + current_statement__ = 6; + validate_non_negative_index("b", "K", 8); + std::vector> b; + b = std::vector>(I, Eigen::Matrix(8)); + + lcm_sym19__ = logical_gte(I, 1); + if (lcm_sym19__) { + current_statement__ = 6; + assign(b, cons_list(index_uni(1), nil_index_list()), in__.vector(8), + "assigning variable b"); + for (size_t sym1__ = 2; sym1__ <= I; ++sym1__) { + current_statement__ = 6; + assign(b, cons_list(index_uni(sym1__), nil_index_list()), + in__.vector(8), "assigning variable b");} + } + local_scalar_t__ sigma; + + current_statement__ = 7; + sigma = std::numeric_limits::quiet_NaN(); + lcm_sym18__ = (1 / stan::math::sqrt(tau)); + sigma = lcm_sym18__; { - { - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), "x_cov")); - { - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), "x_cov")); - } - } - { - { - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), "x_cov")); - { - vars__.push_back( - rvalue(x_cov, - cons_list(index_uni(2), - cons_list(index_uni(2), nil_index_list())), "x_cov")); - } - } - } + current_statement__ = 8; + lp_accum__.add(normal_log(alpha0, 0.0, 1.0E3)); + current_statement__ = 9; + lp_accum__.add(normal_log(alpha1, 0.0, 1.0E3)); + current_statement__ = 10; + lp_accum__.add(normal_log(alpha2, 0.0, 1.0E3)); + current_statement__ = 11; + lp_accum__.add(normal_log(alpha12, 0.0, 1.0E3)); + current_statement__ = 12; + lp_accum__.add(gamma_log(tau, 1.0E-3, 1.0E-3)); + current_statement__ = 16; + if (lcm_sym19__) { + current_statement__ = 13; + lp_accum__.add(normal_log(b[(1 - 1)], 0.0, lcm_sym18__)); + current_statement__ = 14; + lp_accum__.add( + binomial_logit_log(n[(1 - 1)], N[(1 - 1)], + add( + stan::math::fma(alpha12, elt_multiply(x1, x2)[(1 - 1)], + stan::math::fma(alpha2, x2[(1 - 1)], + stan::math::fma(alpha1, x1[(1 - 1)], alpha0))), + b[(1 - 1)]))); + for (size_t i = 2; i <= I; ++i) { + current_statement__ = 13; + lp_accum__.add(normal_log(b[(i - 1)], 0.0, lcm_sym18__)); + current_statement__ = 14; + lp_accum__.add( + binomial_logit_log(n[(i - 1)], N[(i - 1)], + add( + stan::math::fma(alpha12, elt_multiply(x1, x2)[(i - 1)], + stan::math::fma(alpha2, x2[(i - 1)], + stan::math::fma(alpha1, x1[(i - 1)], alpha0))), + b[(i - 1)])));} + } } - if (logical_negation((primitive_value(emit_transformed_parameters__) || - primitive_value(emit_generated_quantities__)))) { - return ; - } - if (logical_negation(emit_generated_quantities__)) { - return ; - } } catch (const std::exception& e) { stan::lang::rethrow_located(e, locations_array__[current_statement__]); // Next line prevents compiler griping about no return throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); } - } // write_array() + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // log_prob() - void transform_inits(const stan::io::var_context& context__, - std::vector& params_i__, - std::vector& vars__, std::ostream* pstream__) const { + template + void write_array(RNG& base_rng__, std::vector& params_r__, + std::vector& params_i__, std::vector& vars__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true, + std::ostream* pstream__ = 0) const { typedef double local_scalar_t__; vars__.resize(0); - vars__.reserve(num_params_r__); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "stalled1_failure_model_namespace::write_array"; +(void) function__; // suppress unused var warning + + (void) function__; // suppress unused var warning + + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; try { - double lcm_sym53__; - double lcm_sym52__; - double lcm_sym51__; - double lcm_sym50__; - double lcm_sym49__; - double lcm_sym48__; - double lcm_sym47__; - double lcm_sym46__; - double lcm_sym45__; - double lcm_sym44__; - double lcm_sym43__; - double lcm_sym42__; - double lcm_sym41__; - double lcm_sym40__; - int lcm_sym39__; - int pos__; - - pos__ = 1; - double theta; + double lcm_sym17__; + double lcm_sym16__; + double lcm_sym15__; + double lcm_sym14__; + double lcm_sym13__; + int lcm_sym12__; + int lcm_sym11__; + int lcm_sym10__; + double lcm_sym9__; + double alpha0; current_statement__ = 1; - theta = context__.vals_r("theta")[(1 - 1)]; - double phi; + alpha0 = in__.scalar(); + double alpha1; current_statement__ = 2; - phi = context__.vals_r("phi")[(1 - 1)]; - current_statement__ = 3; - validate_non_negative_index("x_matrix", "3", 3); + alpha1 = in__.scalar(); + double alpha2; + current_statement__ = 3; - validate_non_negative_index("x_matrix", "2", 2); - Eigen::Matrix x_matrix; - x_matrix = Eigen::Matrix(3, 2); + alpha2 = in__.scalar(); + double alpha12; - { - std::vector x_matrix_flat__; - current_statement__ = 3; - assign(x_matrix_flat__, nil_index_list(), - context__.vals_r("x_matrix"), "assigning variable x_matrix_flat__"); - current_statement__ = 3; - pos__ = 1; - { - { - current_statement__ = 3; - assign(x_matrix, - cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), - x_matrix_flat__[(1 - 1)], "assigning variable x_matrix"); - current_statement__ = 3; - pos__ = 2; - { - current_statement__ = 3; - assign(x_matrix, - cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), - x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); - current_statement__ = 3; - pos__ = (pos__ + 1); - } - { - current_statement__ = 3; - assign(x_matrix, - cons_list(index_uni(3), - cons_list(index_uni(1), nil_index_list())), - x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); - current_statement__ = 3; - pos__ = (pos__ + 1); - } - } - { - { - current_statement__ = 3; - assign(x_matrix, - cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), - x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); - current_statement__ = 3; - pos__ = (pos__ + 1); - { - current_statement__ = 3; - assign(x_matrix, - cons_list(index_uni(2), - cons_list(index_uni(2), nil_index_list())), - x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); - current_statement__ = 3; - pos__ = (pos__ + 1); - } - { - current_statement__ = 3; - assign(x_matrix, - cons_list(index_uni(3), - cons_list(index_uni(2), nil_index_list())), - x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix"); - current_statement__ = 3; - pos__ = (pos__ + 1); - } - } - } - } - } current_statement__ = 4; - validate_non_negative_index("x_vector", "2", 2); - Eigen::Matrix x_vector; - x_vector = Eigen::Matrix(2); + alpha12 = in__.scalar(); + double tau; + + current_statement__ = 5; + tau = in__.scalar(); + current_statement__ = 5; + tau = stan::math::lb_constrain(tau, 0); + current_statement__ = 6; + validate_non_negative_index("b", "I", I); + current_statement__ = 6; + validate_non_negative_index("b", "K", 8); + std::vector> b; + b = std::vector>(I, Eigen::Matrix(8)); + lcm_sym10__ = logical_gte(I, 1); + if (lcm_sym10__) { + current_statement__ = 6; + assign(b, cons_list(index_uni(1), nil_index_list()), in__.vector(8), + "assigning variable b"); + for (size_t sym1__ = 2; sym1__ <= I; ++sym1__) { + current_statement__ = 6; + assign(b, cons_list(index_uni(sym1__), nil_index_list()), + in__.vector(8), "assigning variable b");} + } + double sigma; + + current_statement__ = 7; + sigma = std::numeric_limits::quiet_NaN(); + vars__.push_back(alpha0); + vars__.push_back(alpha1); + vars__.push_back(alpha2); + vars__.push_back(alpha12); + vars__.push_back(tau); { - std::vector x_vector_flat__; - current_statement__ = 4; - assign(x_vector_flat__, nil_index_list(), - context__.vals_r("x_vector"), "assigning variable x_vector_flat__"); - current_statement__ = 4; - pos__ = 1; + if (lcm_sym10__) { + vars__.push_back(b[(1 - 1)][(1 - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(b[(sym2__ - 1)][(1 - 1)]);} + } { - current_statement__ = 4; - assign(x_vector, cons_list(index_uni(1), nil_index_list()), - x_vector_flat__[(1 - 1)], "assigning variable x_vector"); - current_statement__ = 4; - pos__ = 2; - { - current_statement__ = 4; - assign(x_vector, cons_list(index_uni(2), nil_index_list()), - x_vector_flat__[(pos__ - 1)], "assigning variable x_vector"); - current_statement__ = 4; - pos__ = (pos__ + 1); - } + if (lcm_sym10__) { + vars__.push_back(b[(1 - 1)][(2 - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(b[(sym2__ - 1)][(2 - 1)]);} + } + } + { + if (lcm_sym10__) { + vars__.push_back(b[(1 - 1)][(3 - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(b[(sym2__ - 1)][(3 - 1)]);} + } + } + { + if (lcm_sym10__) { + vars__.push_back(b[(1 - 1)][(4 - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(b[(sym2__ - 1)][(4 - 1)]);} + } + } + { + if (lcm_sym10__) { + vars__.push_back(b[(1 - 1)][(5 - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(b[(sym2__ - 1)][(5 - 1)]);} + } + } + { + if (lcm_sym10__) { + vars__.push_back(b[(1 - 1)][(6 - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(b[(sym2__ - 1)][(6 - 1)]);} + } + } + { + if (lcm_sym10__) { + vars__.push_back(b[(1 - 1)][(7 - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(b[(sym2__ - 1)][(7 - 1)]);} + } + } + { + if (lcm_sym10__) { + vars__.push_back(b[(1 - 1)][(8 - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(b[(sym2__ - 1)][(8 - 1)]);} + } } } + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + lcm_sym9__ = (1 / stan::math::sqrt(tau)); + sigma = lcm_sym9__; + vars__.push_back(lcm_sym9__); + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // write_array() + + void transform_inits(const stan::io::var_context& context__, + std::vector& params_i__, + std::vector& vars__, std::ostream* pstream__) const { + typedef double local_scalar_t__; + vars__.resize(0); + vars__.reserve(num_params_r__); + + try { + double lcm_sym8__; + double lcm_sym7__; + double lcm_sym6__; + double lcm_sym5__; + double lcm_sym4__; + double lcm_sym3__; + int lcm_sym2__; + int lcm_sym1__; + int pos__; + + pos__ = 1; + double alpha0; + + current_statement__ = 1; + alpha0 = context__.vals_r("alpha0")[(1 - 1)]; + double alpha1; + + current_statement__ = 2; + alpha1 = context__.vals_r("alpha1")[(1 - 1)]; + double alpha2; + + current_statement__ = 3; + alpha2 = context__.vals_r("alpha2")[(1 - 1)]; + double alpha12; + + current_statement__ = 4; + alpha12 = context__.vals_r("alpha12")[(1 - 1)]; + double tau; + current_statement__ = 5; - validate_non_negative_index("x_cov", "2", 2); + tau = context__.vals_r("tau")[(1 - 1)]; current_statement__ = 5; - validate_non_negative_index("x_cov", "2", 2); - Eigen::Matrix x_cov; - x_cov = Eigen::Matrix(2, 2); + tau = stan::math::lb_free(tau, 0); + current_statement__ = 6; + validate_non_negative_index("b", "I", I); + current_statement__ = 6; + validate_non_negative_index("b", "K", 8); + std::vector> b; + b = std::vector>(I, Eigen::Matrix(8)); { - std::vector x_cov_flat__; - current_statement__ = 5; - assign(x_cov_flat__, nil_index_list(), context__.vals_r("x_cov"), - "assigning variable x_cov_flat__"); - current_statement__ = 5; + std::vector b_flat__; + current_statement__ = 6; + assign(b_flat__, nil_index_list(), context__.vals_r("b"), + "assigning variable b_flat__"); + current_statement__ = 6; pos__ = 1; { - { - current_statement__ = 5; - assign(x_cov, + lcm_sym1__ = logical_gte(I, 1); + if (lcm_sym1__) { + current_statement__ = 6; + assign(b, cons_list(index_uni(1), cons_list(index_uni(1), nil_index_list())), - x_cov_flat__[(1 - 1)], "assigning variable x_cov"); - current_statement__ = 5; + b_flat__[(1 - 1)], "assigning variable b"); + current_statement__ = 6; pos__ = 2; - { - current_statement__ = 5; - assign(x_cov, - cons_list(index_uni(2), + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + current_statement__ = 6; + assign(b, + cons_list(index_uni(sym2__), cons_list(index_uni(1), nil_index_list())), - x_cov_flat__[(pos__ - 1)], "assigning variable x_cov"); - current_statement__ = 5; - pos__ = (pos__ + 1); - } - } + b_flat__[(pos__ - 1)], "assigning variable b"); + current_statement__ = 6; + pos__ = (pos__ + 1);} + } { - { - current_statement__ = 5; - assign(x_cov, + current_statement__ = 6; + if (lcm_sym1__) { + current_statement__ = 6; + assign(b, cons_list(index_uni(1), cons_list(index_uni(2), nil_index_list())), - x_cov_flat__[(pos__ - 1)], "assigning variable x_cov"); - current_statement__ = 5; + b_flat__[(pos__ - 1)], "assigning variable b"); + current_statement__ = 6; pos__ = (pos__ + 1); - { - current_statement__ = 5; - assign(x_cov, - cons_list(index_uni(2), + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + current_statement__ = 6; + assign(b, + cons_list(index_uni(sym2__), cons_list(index_uni(2), nil_index_list())), - x_cov_flat__[(pos__ - 1)], "assigning variable x_cov"); - current_statement__ = 5; - pos__ = (pos__ + 1); - } - } + b_flat__[(pos__ - 1)], "assigning variable b"); + current_statement__ = 6; + pos__ = (pos__ + 1);} + } } - } - } - current_statement__ = 5; - validate_non_negative_index("x_cov_free__", - "(2 + ((2 * (2 - 1)) / 2))", 3); - Eigen::Matrix x_cov_free__; - x_cov_free__ = Eigen::Matrix(3); - - current_statement__ = 5; - assign(x_cov_free__, nil_index_list(), - stan::math::cov_matrix_free(x_cov), "assigning variable x_cov_free__"); - vars__.push_back(theta); - vars__.push_back(phi); - { - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(1), - cons_list(index_uni(1), nil_index_list())), "x_matrix")); { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(2), - cons_list(index_uni(1), nil_index_list())), "x_matrix")); + current_statement__ = 6; + if (lcm_sym1__) { + current_statement__ = 6; + assign(b, + cons_list(index_uni(1), + cons_list(index_uni(3), nil_index_list())), + b_flat__[(pos__ - 1)], "assigning variable b"); + current_statement__ = 6; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + current_statement__ = 6; + assign(b, + cons_list(index_uni(sym2__), + cons_list(index_uni(3), nil_index_list())), + b_flat__[(pos__ - 1)], "assigning variable b"); + current_statement__ = 6; + pos__ = (pos__ + 1);} + } } { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(3), - cons_list(index_uni(1), nil_index_list())), "x_matrix")); + current_statement__ = 6; + if (lcm_sym1__) { + current_statement__ = 6; + assign(b, + cons_list(index_uni(1), + cons_list(index_uni(4), nil_index_list())), + b_flat__[(pos__ - 1)], "assigning variable b"); + current_statement__ = 6; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + current_statement__ = 6; + assign(b, + cons_list(index_uni(sym2__), + cons_list(index_uni(4), nil_index_list())), + b_flat__[(pos__ - 1)], "assigning variable b"); + current_statement__ = 6; + pos__ = (pos__ + 1);} + } } - } - { { - vars__.push_back( - rvalue(x_matrix, + current_statement__ = 6; + if (lcm_sym1__) { + current_statement__ = 6; + assign(b, cons_list(index_uni(1), - cons_list(index_uni(2), nil_index_list())), "x_matrix")); - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(2), - cons_list(index_uni(2), nil_index_list())), "x_matrix")); - } - { - vars__.push_back( - rvalue(x_matrix, - cons_list(index_uni(3), - cons_list(index_uni(2), nil_index_list())), "x_matrix")); - } + cons_list(index_uni(5), nil_index_list())), + b_flat__[(pos__ - 1)], "assigning variable b"); + current_statement__ = 6; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + current_statement__ = 6; + assign(b, + cons_list(index_uni(sym2__), + cons_list(index_uni(5), nil_index_list())), + b_flat__[(pos__ - 1)], "assigning variable b"); + current_statement__ = 6; + pos__ = (pos__ + 1);} + } + } + { + current_statement__ = 6; + if (lcm_sym1__) { + current_statement__ = 6; + assign(b, + cons_list(index_uni(1), + cons_list(index_uni(6), nil_index_list())), + b_flat__[(pos__ - 1)], "assigning variable b"); + current_statement__ = 6; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + current_statement__ = 6; + assign(b, + cons_list(index_uni(sym2__), + cons_list(index_uni(6), nil_index_list())), + b_flat__[(pos__ - 1)], "assigning variable b"); + current_statement__ = 6; + pos__ = (pos__ + 1);} + } + } + { + current_statement__ = 6; + if (lcm_sym1__) { + current_statement__ = 6; + assign(b, + cons_list(index_uni(1), + cons_list(index_uni(7), nil_index_list())), + b_flat__[(pos__ - 1)], "assigning variable b"); + current_statement__ = 6; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + current_statement__ = 6; + assign(b, + cons_list(index_uni(sym2__), + cons_list(index_uni(7), nil_index_list())), + b_flat__[(pos__ - 1)], "assigning variable b"); + current_statement__ = 6; + pos__ = (pos__ + 1);} + } + } + { + current_statement__ = 6; + if (lcm_sym1__) { + current_statement__ = 6; + assign(b, + cons_list(index_uni(1), + cons_list(index_uni(8), nil_index_list())), + b_flat__[(pos__ - 1)], "assigning variable b"); + current_statement__ = 6; + pos__ = (pos__ + 1); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + current_statement__ = 6; + assign(b, + cons_list(index_uni(sym2__), + cons_list(index_uni(8), nil_index_list())), + b_flat__[(pos__ - 1)], "assigning variable b"); + current_statement__ = 6; + pos__ = (pos__ + 1);} + } } } } + vars__.push_back(alpha0); + vars__.push_back(alpha1); + vars__.push_back(alpha2); + vars__.push_back(alpha12); + vars__.push_back(tau); { - vars__.push_back(x_vector[(1 - 1)]); + lcm_sym1__ = logical_gte(I, 1); + if (lcm_sym1__) { + vars__.push_back(b[(1 - 1)][(1 - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(b[(sym2__ - 1)][(1 - 1)]);} + } { - vars__.push_back(x_vector[(2 - 1)]); + if (lcm_sym1__) { + vars__.push_back(b[(1 - 1)][(2 - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(b[(sym2__ - 1)][(2 - 1)]);} + } } - } - { - vars__.push_back(x_cov_free__[(1 - 1)]); { - vars__.push_back(x_cov_free__[(2 - 1)]); + if (lcm_sym1__) { + vars__.push_back(b[(1 - 1)][(3 - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(b[(sym2__ - 1)][(3 - 1)]);} + } } { - vars__.push_back(x_cov_free__[(3 - 1)]); + if (lcm_sym1__) { + vars__.push_back(b[(1 - 1)][(4 - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(b[(sym2__ - 1)][(4 - 1)]);} + } + } + { + if (lcm_sym1__) { + vars__.push_back(b[(1 - 1)][(5 - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(b[(sym2__ - 1)][(5 - 1)]);} + } + } + { + if (lcm_sym1__) { + vars__.push_back(b[(1 - 1)][(6 - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(b[(sym2__ - 1)][(6 - 1)]);} + } + } + { + if (lcm_sym1__) { + vars__.push_back(b[(1 - 1)][(7 - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(b[(sym2__ - 1)][(7 - 1)]);} + } + } + { + if (lcm_sym1__) { + vars__.push_back(b[(1 - 1)][(8 - 1)]); + for (size_t sym2__ = 2; sym2__ <= I; ++sym2__) { + vars__.push_back(b[(sym2__ - 1)][(8 - 1)]);} + } } } } catch (const std::exception& e) { @@ -1319,11 +32686,13 @@ class optimizations_model : public model_base_crtp { void get_param_names(std::vector& names__) const { names__.resize(0); - names__.push_back("theta"); - names__.push_back("phi"); - names__.push_back("x_matrix"); - names__.push_back("x_vector"); - names__.push_back("x_cov"); + names__.push_back("alpha0"); + names__.push_back("alpha1"); + names__.push_back("alpha2"); + names__.push_back("alpha12"); + names__.push_back("tau"); + names__.push_back("b"); + names__.push_back("sigma"); } // get_param_names() void get_dims(std::vector>& dimss__) const { @@ -1333,17 +32702,17 @@ class optimizations_model : public model_base_crtp { dims__.resize(0); dimss__.push_back(dims__); dims__.resize(0); - dims__.push_back(3); - - dims__.push_back(2); dimss__.push_back(dims__); dims__.resize(0); - dims__.push_back(2); dimss__.push_back(dims__); dims__.resize(0); - dims__.push_back(2); + dimss__.push_back(dims__); + dims__.resize(0); + dims__.push_back(I); - dims__.push_back(2); + dims__.push_back(K); + dimss__.push_back(dims__); + dims__.resize(0); dimss__.push_back(dims__); dims__.resize(0); @@ -1353,28 +32722,20 @@ class optimizations_model : public model_base_crtp { bool emit_transformed_parameters__ = true, bool emit_generated_quantities__ = true) const { - param_names__.push_back(std::string() + "theta"); - param_names__.push_back(std::string() + "phi"); - for (size_t sym80__ = 1; sym80__ <= 2; ++sym80__) { - { - for (size_t sym81__ = 1; sym81__ <= 3; ++sym81__) { - { - param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym81__) + '.' + std::to_string(sym80__)); - }} - }} - for (size_t sym80__ = 1; sym80__ <= 2; ++sym80__) { - { - param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym80__)); - }} - for (size_t sym80__ = 1; sym80__ <= 2; ++sym80__) { + param_names__.push_back(std::string() + "alpha0"); + param_names__.push_back(std::string() + "alpha1"); + param_names__.push_back(std::string() + "alpha2"); + param_names__.push_back(std::string() + "alpha12"); + param_names__.push_back(std::string() + "tau"); + for (size_t sym42__ = 1; sym42__ <= K; ++sym42__) { { - for (size_t sym81__ = 1; sym81__ <= 2; ++sym81__) { + for (size_t sym43__ = 1; sym43__ <= I; ++sym43__) { { - param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym81__) + '.' + std::to_string(sym80__)); + param_names__.push_back(std::string() + "b" + '.' + std::to_string(sym43__) + '.' + std::to_string(sym42__)); }} }} if (emit_transformed_parameters__) { - + param_names__.push_back(std::string() + "sigma"); } if (emit_generated_quantities__) { @@ -1387,25 +32748,20 @@ class optimizations_model : public model_base_crtp { bool emit_transformed_parameters__ = true, bool emit_generated_quantities__ = true) const { - param_names__.push_back(std::string() + "theta"); - param_names__.push_back(std::string() + "phi"); - for (size_t sym80__ = 1; sym80__ <= 2; ++sym80__) { + param_names__.push_back(std::string() + "alpha0"); + param_names__.push_back(std::string() + "alpha1"); + param_names__.push_back(std::string() + "alpha2"); + param_names__.push_back(std::string() + "alpha12"); + param_names__.push_back(std::string() + "tau"); + for (size_t sym42__ = 1; sym42__ <= K; ++sym42__) { { - for (size_t sym81__ = 1; sym81__ <= 3; ++sym81__) { + for (size_t sym43__ = 1; sym43__ <= I; ++sym43__) { { - param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym81__) + '.' + std::to_string(sym80__)); + param_names__.push_back(std::string() + "b" + '.' + std::to_string(sym43__) + '.' + std::to_string(sym42__)); }} }} - for (size_t sym80__ = 1; sym80__ <= 2; ++sym80__) { - { - param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym80__)); - }} - for (size_t sym80__ = 1; sym80__ <= 3; ++sym80__) { - { - param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym80__)); - }} if (emit_transformed_parameters__) { - + param_names__.push_back(std::string() + "sigma"); } if (emit_generated_quantities__) { @@ -1416,13 +32772,13 @@ class optimizations_model : public model_base_crtp { std::string get_constrained_sizedtypes() const { stringstream s__; - s__ << "[{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"x_matrix\",\"type\":{\"name\":\"matrix\",\"rows\":" << 3 << ",\"cols\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"x_vector\",\"type\":{\"name\":\"vector\",\"length\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"x_cov\",\"type\":{\"name\":\"matrix\",\"rows\":" << 2 << ",\"cols\":" << 2 << "},\"block\":\"parameters\"}]"; + s__ << "[{\"name\":\"alpha0\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"alpha1\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"alpha2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"alpha12\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"tau\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"array\",\"length\":" << I << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"}]"; return s__.str(); } // get_constrained_sizedtypes() std::string get_unconstrained_sizedtypes() const { stringstream s__; - s__ << "[{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"x_matrix\",\"type\":{\"name\":\"matrix\",\"rows\":" << 3 << ",\"cols\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"x_vector\",\"type\":{\"name\":\"vector\",\"length\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"x_cov\",\"type\":{\"name\":\"vector\",\"length\":" << 3 << "},\"block\":\"parameters\"}]"; + s__ << "[{\"name\":\"alpha0\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"alpha1\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"alpha2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"alpha12\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"tau\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"array\",\"length\":" << I << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"}]"; return s__.str(); } // get_unconstrained_sizedtypes() @@ -1471,7 +32827,7 @@ class optimizations_model : public model_base_crtp { }; } -typedef optimizations_model_namespace::optimizations_model stan_model; +typedef stalled1_failure_model_namespace::stalled1_failure_model stan_model; #ifndef USING_R @@ -1488,3 +32844,169 @@ stan::model::model_base& new_model( + +Warning: deprecated language construct used in 'stalled1-failure.stan', line 1, column 0: + ------------------------------------------------- + 1: # Using Data Cloning to Calculate MLEs for the Seeds Model in vol1 + ^ + 2: # http://www.openbugs.net/Examples/DataCloning.html + 3: + ------------------------------------------------- + +Comments beginning with # are deprecated. Please use // in place of # for line comments. + + +Warning: deprecated language construct used in 'stalled1-failure.stan', line 2, column 0: + ------------------------------------------------- + 1: # Using Data Cloning to Calculate MLEs for the Seeds Model in vol1 + 2: # http://www.openbugs.net/Examples/DataCloning.html + ^ + 3: + 4: # The basic idea is that we raise the likelihood in the + ------------------------------------------------- + +Comments beginning with # are deprecated. Please use // in place of # for line comments. + + +Warning: deprecated language construct used in 'stalled1-failure.stan', line 4, column 0: + ------------------------------------------------- + 2: # http://www.openbugs.net/Examples/DataCloning.html + 3: + 4: # The basic idea is that we raise the likelihood in the + ^ + 5: # posterior to the power of K so that the posterior + 6: # estimates would concentrate on the MLE estimates. + ------------------------------------------------- + +Comments beginning with # are deprecated. Please use // in place of # for line comments. + + +Warning: deprecated language construct used in 'stalled1-failure.stan', line 5, column 0: + ------------------------------------------------- + 3: + 4: # The basic idea is that we raise the likelihood in the + 5: # posterior to the power of K so that the posterior + ^ + 6: # estimates would concentrate on the MLE estimates. + 7: # Reference: + ------------------------------------------------- + +Comments beginning with # are deprecated. Please use // in place of # for line comments. + + +Warning: deprecated language construct used in 'stalled1-failure.stan', line 6, column 0: + ------------------------------------------------- + 4: # The basic idea is that we raise the likelihood in the + 5: # posterior to the power of K so that the posterior + 6: # estimates would concentrate on the MLE estimates. + ^ + 7: # Reference: + 8: # Ecology Letters + ------------------------------------------------- + +Comments beginning with # are deprecated. Please use // in place of # for line comments. + + +Warning: deprecated language construct used in 'stalled1-failure.stan', line 7, column 0: + ------------------------------------------------- + 5: # posterior to the power of K so that the posterior + 6: # estimates would concentrate on the MLE estimates. + 7: # Reference: + ^ + 8: # Ecology Letters + 9: # Subhash R. Lele Brian Dennis Frithjof Lutscher + ------------------------------------------------- + +Comments beginning with # are deprecated. Please use // in place of # for line comments. + + +Warning: deprecated language construct used in 'stalled1-failure.stan', line 8, column 0: + ------------------------------------------------- + 6: # estimates would concentrate on the MLE estimates. + 7: # Reference: + 8: # Ecology Letters + ^ + 9: # Subhash R. Lele Brian Dennis Frithjof Lutscher + 10: # DOI: 10.1111/j.1461-0248.2007.01047.x + ------------------------------------------------- + +Comments beginning with # are deprecated. Please use // in place of # for line comments. + + +Warning: deprecated language construct used in 'stalled1-failure.stan', line 9, column 0: + ------------------------------------------------- + 7: # Reference: + 8: # Ecology Letters + 9: # Subhash R. Lele Brian Dennis Frithjof Lutscher + ^ + 10: # DOI: 10.1111/j.1461-0248.2007.01047.x + 11: # http://onlinelibrary.wiley.com/doi/10.1111/j.1461-0248.2007.01047.x/abstract + ------------------------------------------------- + +Comments beginning with # are deprecated. Please use // in place of # for line comments. + + +Warning: deprecated language construct used in 'stalled1-failure.stan', line 10, column 0: + ------------------------------------------------- + 8: # Ecology Letters + 9: # Subhash R. Lele Brian Dennis Frithjof Lutscher + 10: # DOI: 10.1111/j.1461-0248.2007.01047.x + ^ + 11: # http://onlinelibrary.wiley.com/doi/10.1111/j.1461-0248.2007.01047.x/abstract + 12: + ------------------------------------------------- + +Comments beginning with # are deprecated. Please use // in place of # for line comments. + + +Warning: deprecated language construct used in 'stalled1-failure.stan', line 11, column 0: + ------------------------------------------------- + 9: # Subhash R. Lele Brian Dennis Frithjof Lutscher + 10: # DOI: 10.1111/j.1461-0248.2007.01047.x + 11: # http://onlinelibrary.wiley.com/doi/10.1111/j.1461-0248.2007.01047.x/abstract + ^ + 12: + 13: + ------------------------------------------------- + +Comments beginning with # are deprecated. Please use // in place of # for line comments. + + +Warning: deprecated language construct used in 'stalled1-failure.stan', line 25, column 7: + ------------------------------------------------- + 23: int K; + 24: vector[I] x1x2; + 25: K <- 8; // {1, 2, 4, 8, 16, 32, 64, 128, 256} + ^ + 26: x1x2 <- x1 .* x2; + 27: } + ------------------------------------------------- + +assignment operator <- is deprecated in the Stan language; use = instead. + + +Warning: deprecated language construct used in 'stalled1-failure.stan', line 26, column 10: + ------------------------------------------------- + 24: vector[I] x1x2; + 25: K <- 8; // {1, 2, 4, 8, 16, 32, 64, 128, 256} + 26: x1x2 <- x1 .* x2; + ^ + 27: } + 28: + ------------------------------------------------- + +assignment operator <- is deprecated in the Stan language; use = instead. + + +Warning: deprecated language construct used in 'stalled1-failure.stan', line 40, column 11: + ------------------------------------------------- + 38: transformed parameters { + 39: real sigma; + 40: sigma <- 1 / sqrt(tau); + ^ + 41: } + 42: + ------------------------------------------------- + +assignment operator <- is deprecated in the Stan language; use = instead. + diff --git a/test/integration/good/compiler-optimizations/dune b/test/integration/good/compiler-optimizations/dune index 11e53d1e67..cf41a81287 100644 --- a/test/integration/good/compiler-optimizations/dune +++ b/test/integration/good/compiler-optimizations/dune @@ -1,6 +1,30 @@ (rule (targets cpp.output) - (deps (package stanc) (:stanfiles optimizations.stan)) + (deps (package stanc) (:stanfiles + optimizations.stan + expr-prop-fail8.stan + lcm-experiment2.stan + expr-prop-fail7.stan + expr-prop-experiment2.stan + lcm-experiment.stan + expr-prop-fail6.stan + expr-prop-experiment.stan + expr-prop-fail5.stan + expr-prop-fail4.stan + lcm-fails2.stan + lcm-fails.stan + expr-prop-fail3.stan + expr-prop-fail2.stan + inlining-fail2.stan + dce-fail.stan + partial-eval.stan + copy_fail.stan + fails-test.stan + off-small.stan + off-dce.stan + stalled1-failure.stan + expr-prop-fail.stan + ad-level-failing.stan)) (action (with-stdout-to %{targets} (run %{bin:run_bin_on_args} "%{bin:stanc} --O 2 --print-cpp" %{stanfiles})))) From 13ff8911e681a00476ce59c5bf79bd92c58699b5 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Sat, 25 Apr 2020 12:24:59 -0400 Subject: [PATCH 22/27] Separated the notion of duplicatable and deletable expressions, which were 'side effecting' expressions Expression propagation needs to know if an expression can be duplicated, and DCE and LCM need to know if an expression can be removed (or done fewer times). Treating them both as the same set was a conservative approximation. --- src/analysis_and_optimization/Optimize.ml | 56 +++++++++++++---------- src/stanc/stanc.ml | 4 ++ 2 files changed, 37 insertions(+), 23 deletions(-) diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml index 28b1a8a46a..6ae8ef803c 100644 --- a/src/analysis_and_optimization/Optimize.ml +++ b/src/analysis_and_optimization/Optimize.ml @@ -599,13 +599,20 @@ let propagation let constant_propagation = propagation Monotone_framework.constant_propagation_transfer -let rec can_side_effect_expr (e : Expr.Typed.t) = +let rec expr_any pred (e : Expr.Typed.t) = match e.pattern with - | Var _ | Lit (_, _) -> false - | FunApp (t, f, es) -> + | Indexed (e, is) -> + expr_any pred e || List.exists ~f:(idx_any pred) is + | _ -> + pred e || Expr.Fixed.Pattern.fold (accum_any pred) false e.pattern +and idx_any pred (i : Expr.Typed.t Index.t) = + Index.fold (accum_any pred) false i +and accum_any pred b e = b || expr_any pred e + +let can_side_effect_top_expr (e : Expr.Typed.t) = + match e.pattern with + | FunApp (t, f, _) -> String.suffix f 3 = "_lp" - || String.suffix f 4 = "_rng" - || List.exists ~f:can_side_effect_expr es || (t = CompilerInternal && f = Internal_fun.to_string FnReadParam) || (t = CompilerInternal && f = Internal_fun.to_string FnReadData) || (t = CompilerInternal && f = Internal_fun.to_string FnWriteParam) @@ -615,21 +622,24 @@ let rec can_side_effect_expr (e : Expr.Typed.t) = || (t = CompilerInternal && f = Internal_fun.to_string FnValidateSizeSimplex) || (t = CompilerInternal && f = Internal_fun.to_string FnValidateSizeUnitVector) || (t = CompilerInternal && f = Internal_fun.to_string FnUnconstrain) - | TernaryIf (e1, e2, e3) -> List.exists ~f:can_side_effect_expr [e1; e2; e3] - | Indexed (e, is) -> - can_side_effect_expr e || List.exists ~f:can_side_effect_idx is - | EAnd (e1, e2) | EOr (e1, e2) -> List.exists ~f:can_side_effect_expr [e1; e2] + | _ -> false -and can_side_effect_idx (i : Expr.Typed.t Index.t) = - match i with - | All -> false - | Single e | Upfrom e | MultiIndex e -> can_side_effect_expr e - | Between (e1, e2) -> can_side_effect_expr e1 || can_side_effect_expr e2 +let cannot_duplicate_expr (e : Expr.Typed.t) = + let pred e = can_side_effect_top_expr e || ( + match e.pattern with + | FunApp (_, f, _) -> + String.suffix f 4 = "_rng" + | _ -> false + ) + in expr_any pred e + +let cannot_remove_expr (e : Expr.Typed.t) = + expr_any can_side_effect_top_expr e let expression_propagation mir = let res = propagation - (Monotone_framework.expression_propagation_transfer can_side_effect_expr) + (Monotone_framework.expression_propagation_transfer cannot_duplicate_expr) mir in let _ = if Monotone_framework.exprop_debug then ( @@ -676,15 +686,15 @@ let dead_code_elimination (mir : Program.Typed.t) = in match stmt with | Stmt.Fixed.Pattern.Assignment ((x, _, []), rhs) -> - if Set.Poly.mem live_variables_s x || can_side_effect_expr rhs then + if Set.Poly.mem live_variables_s x || cannot_remove_expr rhs then stmt else Skip | Assignment ((x, _, is), rhs) -> if Set.Poly.mem live_variables_s x - || can_side_effect_expr rhs - || List.exists ~f:can_side_effect_idx is + || cannot_remove_expr rhs + || List.exists ~f:(idx_any cannot_remove_expr) is then stmt else Skip (* NOTE: we never get rid of declarations as we might not be able to @@ -698,7 +708,7 @@ let dead_code_elimination (mir : Program.Typed.t) = | IfElse (e, b1, b2) -> ( if (* TODO: check if e has side effects, like print, reject, then don't optimize? *) - (not (can_side_effect_expr e)) + (not (cannot_remove_expr e)) && b1.Stmt.Fixed.pattern = Skip && ( Option.map ~f:(fun Stmt.Fixed.({pattern; _}) -> pattern) b2 = Some Skip @@ -712,15 +722,15 @@ let dead_code_elimination (mir : Program.Typed.t) = | Lit (_, _) -> b1.pattern | _ -> IfElse (e, b1, b2) ) | While (e, b) -> ( - if (not (can_side_effect_expr e)) && b.pattern = Break then Skip + if (not (cannot_remove_expr e)) && b.pattern = Break then Skip else match e.pattern with | Lit (Int, "0") | Lit (Real, "0.0") -> Skip | _ -> While (e, b) ) | For {loopvar; lower; upper; body} -> if - (not (can_side_effect_expr lower)) - && (not (can_side_effect_expr upper)) + (not (cannot_remove_expr lower)) + && (not (cannot_remove_expr upper)) && is_skip_break_continue body.pattern then Skip else For {loopvar; lower; upper; body} @@ -803,7 +813,7 @@ let lazy_code_motion (mir : Program.Typed.t) = match e.pattern with | Lit (_, _) -> accum | Var _ -> accum - | _ when can_side_effect_expr e -> + | _ when cannot_duplicate_expr e -> (* Immovable expressions might have movable subexpressions *) Expr.Fixed.Pattern.fold collect_expressions accum e.pattern | _ -> Map.set accum ~key:e ~data:(Gensym.generate ~prefix:"lcm_" ()) diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index 0bbb30fba2..12aa470a5a 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -164,6 +164,10 @@ let optimization_settings lvl : Optimize.optimization_settings = { max_safe with lazy_code_motion = true ; expression_propagation = true + ; function_inlining = true + ; dead_code_elimination = true + ; optimize_ad_levels = true + ; partial_evaluation = true } | _ -> raise (Failure ("Unsupported optimization level " ^ string_of_int lvl)) From b8cae40943fc0179ddd16ea79ab7ebc23184d4c2 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Sat, 25 Apr 2020 12:26:46 -0400 Subject: [PATCH 23/27] Adding forgotten test files --- .../ad-level-failing.stan | 71 +++++ .../compiler-optimizations/copy_fail.stan | 111 ++++++++ .../good/compiler-optimizations/dce-fail.stan | 71 +++++ .../expr-prop-experiment.stan | 15 + .../expr-prop-experiment2.stan | 15 + .../expr-prop-fail.stan | 20 ++ .../expr-prop-fail2.stan | 14 + .../expr-prop-fail3.stan | 48 ++++ .../expr-prop-fail4.stan | 50 ++++ .../expr-prop-fail5.stan | 127 +++++++++ .../expr-prop-fail6.stan | 264 ++++++++++++++++++ .../expr-prop-fail7.stan | 47 ++++ .../expr-prop-fail8.stan | 28 ++ .../compiler-optimizations/fails-test.stan | 111 ++++++++ .../inlining-fail2.stan | 262 +++++++++++++++++ .../lcm-experiment.stan | 14 + .../lcm-experiment2.stan | 12 + .../compiler-optimizations/lcm-fails.stan | 10 + .../compiler-optimizations/lcm-fails2.stan | 109 ++++++++ .../good/compiler-optimizations/off-dce.stan | 75 +++++ .../compiler-optimizations/off-small.stan | 40 +++ .../compiler-optimizations/partial-eval.stan | 28 ++ .../stalled1-failure.stan | 53 ++++ 23 files changed, 1595 insertions(+) create mode 100644 test/integration/good/compiler-optimizations/ad-level-failing.stan create mode 100644 test/integration/good/compiler-optimizations/copy_fail.stan create mode 100644 test/integration/good/compiler-optimizations/dce-fail.stan create mode 100644 test/integration/good/compiler-optimizations/expr-prop-experiment.stan create mode 100644 test/integration/good/compiler-optimizations/expr-prop-experiment2.stan create mode 100644 test/integration/good/compiler-optimizations/expr-prop-fail.stan create mode 100644 test/integration/good/compiler-optimizations/expr-prop-fail2.stan create mode 100644 test/integration/good/compiler-optimizations/expr-prop-fail3.stan create mode 100644 test/integration/good/compiler-optimizations/expr-prop-fail4.stan create mode 100644 test/integration/good/compiler-optimizations/expr-prop-fail5.stan create mode 100644 test/integration/good/compiler-optimizations/expr-prop-fail6.stan create mode 100644 test/integration/good/compiler-optimizations/expr-prop-fail7.stan create mode 100644 test/integration/good/compiler-optimizations/expr-prop-fail8.stan create mode 100644 test/integration/good/compiler-optimizations/fails-test.stan create mode 100644 test/integration/good/compiler-optimizations/inlining-fail2.stan create mode 100644 test/integration/good/compiler-optimizations/lcm-experiment.stan create mode 100644 test/integration/good/compiler-optimizations/lcm-experiment2.stan create mode 100644 test/integration/good/compiler-optimizations/lcm-fails.stan create mode 100644 test/integration/good/compiler-optimizations/lcm-fails2.stan create mode 100644 test/integration/good/compiler-optimizations/off-dce.stan create mode 100644 test/integration/good/compiler-optimizations/off-small.stan create mode 100644 test/integration/good/compiler-optimizations/partial-eval.stan create mode 100644 test/integration/good/compiler-optimizations/stalled1-failure.stan diff --git a/test/integration/good/compiler-optimizations/ad-level-failing.stan b/test/integration/good/compiler-optimizations/ad-level-failing.stan new file mode 100644 index 0000000000..0a2d47734d --- /dev/null +++ b/test/integration/good/compiler-optimizations/ad-level-failing.stan @@ -0,0 +1,71 @@ +// Simple SIR model inspired by the presentation in +// http://www.ncbi.nlm.nih.gov/pmc/articles/PMC3380087/pdf/nihms372789.pdf + +functions { + + // theta[1] = beta, water contact rate + // theta[2] = kappa, C_{50} + // theta[3] = gamma, recovery rate + // theta[4] = xi, bacteria production rate + // theta[5] = delta, bacteria removal rate + real[] simple_SIR(real t, + real[] y, + real[] theta, + real[] x_r, + int[] x_i) { + + real dydt[4]; + + dydt[1] = - theta[1] * y[4] / (y[4] + theta[2]) * y[1]; + dydt[2] = theta[1] * y[4] / (y[4] + theta[2]) * y[1] - theta[3] * y[2]; + dydt[3] = theta[3] * y[2]; + dydt[4] = theta[4] * y[2] - theta[5] * y[4]; + + return dydt; + } +} + +data { + int N_t; + real t[N_t]; + real y0[4]; + int stoi_hat[N_t]; + real B_hat[N_t]; +} + +transformed data { + real t0 = 0; + real kappa = 1000000; + + real x_r[0]; + int x_i[0]; +} + +parameters { + real beta; + real gamma; + real xi; + real delta; +} + +transformed parameters { + real y[N_t, 4]; + { + real theta[5] = {beta, kappa, gamma, xi, delta}; + y = integrate_ode_rk45(simple_SIR, y0, t0, t, theta, x_r, x_i); + } +} + +model { + beta ~ cauchy(0, 2.5); + gamma ~ cauchy(0, 1); + xi ~ cauchy(0, 25); + delta ~ cauchy(0, 1); + + stoi_hat[1] ~ poisson(y0[1] - y[1, 1]); + for (n in 2:N_t) + stoi_hat[n] ~ poisson(y[n - 1, 1] - y[n, 1]); + + B_hat ~ lognormal(log(col(to_matrix(y), 4)), 0.15); + +} diff --git a/test/integration/good/compiler-optimizations/copy_fail.stan b/test/integration/good/compiler-optimizations/copy_fail.stan new file mode 100644 index 0000000000..a8742e5b37 --- /dev/null +++ b/test/integration/good/compiler-optimizations/copy_fail.stan @@ -0,0 +1,111 @@ +// This models is derived from section 12.3 of "Stan Modeling Language +// User's Guide and Reference Manual" + +functions { + int first_capture(int[] y_i) { + for (k in 1:size(y_i)) + if (y_i[k]) + return k; + return 0; + } + + int last_capture(int[] y_i) { + for (k_rev in 0:(size(y_i) - 1)) { + // Compoud declaration was enabled in Stan 2.13 + int k = size(y_i) - k_rev; + // int k; + // k = size(y_i) - k_rev; + if (y_i[k]) + return k; + } + return 0; + } + + matrix prob_uncaptured(int nind, int n_occasions, + matrix p, matrix phi) { + matrix[nind, n_occasions] chi; + + for (i in 1:nind) { + chi[i, n_occasions] = 1.0; + for (t in 1:(n_occasions - 1)) { + // Compoud declaration was enabled in Stan 2.13 + int t_curr = n_occasions - t; + int t_next = t_curr + 1; + /* + int t_curr; + int t_next; + + t_curr = n_occasions - t; + t_next = t_curr + 1; + */ + chi[i, t_curr] = (1 - phi[i, t_curr]) + + phi[i, t_curr] * (1 - p[i, t_next - 1]) * chi[i, t_next]; + } + } + return chi; + } +} + +data { + int nind; // Number of individuals + int n_occasions; // Number of capture occasions + int y[nind, n_occasions]; // Capture-history + int max_age; // Maximum age + int x[nind, n_occasions - 1]; // Age +} + +transformed data { + int n_occ_minus_1 = n_occasions - 1; + // int n_occ_minus_1; + int first[nind]; + int last[nind]; + + // n_occ_minus_1 = n_occasions - 1; + for (i in 1:nind) + first[i] = first_capture(y[i]); + for (i in 1:nind) + last[i] = last_capture(y[i]); +} + +parameters { + real mean_p; // Mean recapture + vector[max_age] beta; // Mean survival +} + +transformed parameters { + matrix[nind, n_occ_minus_1] phi; // Survival + matrix[nind, n_occ_minus_1] p; // Recapture + matrix[nind, n_occasions] chi; + + // Constraints + for (i in 1:nind) { + for (t in 1:(first[i] - 1)) { + phi[i, t] = 0; + p[i, t] = 0; + } + for (t in first[i]:n_occ_minus_1) { + phi[i, t] = beta[x[i, t]]; + p[i, t] = mean_p; + } + } + + chi = prob_uncaptured(nind, n_occasions, p, phi); +} + +model { + // Priors + // Uniform priors are implicitly defined. + // beta ~ uniform(0, 1); + // mean_p ~ uniform(0, 1); + + // Likelihood + for (i in 1:nind) { + if (first[i] > 0) { + for (t in (first[i] + 1):last[i]) { + 1 ~ bernoulli(phi[i, t - 1]); + y[i, t] ~ bernoulli(p[i, t - 1]); + } + 1 ~ bernoulli(chi[i, last[i]]); + } + } +} diff --git a/test/integration/good/compiler-optimizations/dce-fail.stan b/test/integration/good/compiler-optimizations/dce-fail.stan new file mode 100644 index 0000000000..196819a222 --- /dev/null +++ b/test/integration/good/compiler-optimizations/dce-fail.stan @@ -0,0 +1,71 @@ +data { + int N; + int n_age; + int n_edu; + int n_region; + int n_state; + + int female[N]; + int black[N]; + int age[N]; + int edu[N]; + int region[n_state]; + int state[N]; + int y[N]; + vector[n_state] v_prev; +} +parameters { + real sigma; + real sigma_age; + real sigma_edu; + real sigma_state; + real sigma_region; + real sigma_age_edu; + + real b_0; + real b_female; + real b_black; + real b_female_black; + + real b_v_prev; + + vector[n_age] b_age; + vector[n_edu] b_edu; + vector[n_region] b_region; + matrix[n_age,n_edu] b_age_edu; + + vector[n_state] b_hat; +} +model { + vector[N] p; + vector[n_state] b_state_hat; + + b_0 ~ normal(0, 100); + b_female ~ normal(0, 100); + b_black ~ normal(0, 100); + b_female_black ~ normal(0, 100); + + b_age ~ normal(0, sigma_age); + b_edu ~ normal(0, sigma_edu); + b_region ~ normal(0, sigma_region); + + for (j in 1:n_age) { + for (i in 1:n_edu) + b_age_edu[j,i] ~ normal(0, sigma_age_edu); + } + + b_v_prev ~ normal(0, 100); + + for (j in 1:n_state) + b_state_hat[j] = b_region[region[j]] + b_v_prev * v_prev[j]; + + b_hat ~ normal(b_state_hat, sigma_state); + + for (i in 1:N) + p[i] = fmax(0, fmin(1, inv_logit(b_0 + b_female*female[i] + + b_black*black[i] + b_female_black*female[i]*black[i] + + b_age[age[i]] + b_edu[edu[i]] + b_age_edu[age[i],edu[i]] + + b_hat[state[i]]))); + + y ~ bernoulli(p); +} diff --git a/test/integration/good/compiler-optimizations/expr-prop-experiment.stan b/test/integration/good/compiler-optimizations/expr-prop-experiment.stan new file mode 100644 index 0000000000..448f3ff717 --- /dev/null +++ b/test/integration/good/compiler-optimizations/expr-prop-experiment.stan @@ -0,0 +1,15 @@ +data { + int j; +} +transformed data { + real z; + real x; + real y; + real i = normal_rng(5, 1); + z = i * j; + x = normal_rng(z, 1); + i = normal_rng(5, 1); + y = normal_rng(z, 1); +} +model { +} diff --git a/test/integration/good/compiler-optimizations/expr-prop-experiment2.stan b/test/integration/good/compiler-optimizations/expr-prop-experiment2.stan new file mode 100644 index 0000000000..d6b9dadee6 --- /dev/null +++ b/test/integration/good/compiler-optimizations/expr-prop-experiment2.stan @@ -0,0 +1,15 @@ +data { + int j; +} +transformed data { + real z = 1; + real y; + { + real x = normal_rng(123, 1); + z = x * 2; + y = normal_rng(z, 1); + } + y = normal_rng(z, 1); +} +model { +} diff --git a/test/integration/good/compiler-optimizations/expr-prop-fail.stan b/test/integration/good/compiler-optimizations/expr-prop-fail.stan new file mode 100644 index 0000000000..02e45fc3f2 --- /dev/null +++ b/test/integration/good/compiler-optimizations/expr-prop-fail.stan @@ -0,0 +1,20 @@ +data { + int N; + vector[N] y; +} + +parameters { + ordered[2] mu; + real sigma[2]; + real theta; +} + +model { + sigma ~ normal(0, 2); + mu ~ normal(0, 2); + theta ~ beta(5, 5); + for (n in 1:N) + target += log_mix(theta, + normal_lpdf(y[n] | mu[1], sigma[1]), + normal_lpdf(y[n] | mu[2], sigma[2])); +} diff --git a/test/integration/good/compiler-optimizations/expr-prop-fail2.stan b/test/integration/good/compiler-optimizations/expr-prop-fail2.stan new file mode 100644 index 0000000000..d8101c7274 --- /dev/null +++ b/test/integration/good/compiler-optimizations/expr-prop-fail2.stan @@ -0,0 +1,14 @@ +data { + int J; // number of schools + real y[J]; // estimated treatment effect (school j) + real sigma[J]; // std err of effect estimate (school j) +} +parameters { + real mu; + real theta[J]; + real tau; +} +model { + theta ~ normal(mu, tau); + y ~ normal(theta,sigma); +} diff --git a/test/integration/good/compiler-optimizations/expr-prop-fail3.stan b/test/integration/good/compiler-optimizations/expr-prop-fail3.stan new file mode 100644 index 0000000000..fb1643e192 --- /dev/null +++ b/test/integration/good/compiler-optimizations/expr-prop-fail3.stan @@ -0,0 +1,48 @@ +data { + int N; + int n_age; + int n_age_edu; + int n_edu; + int n_region_full; + int n_state; + int age[N]; + int age_edu[N]; + vector[N] black; + int edu[N]; + vector[N] female; + int region_full[N]; + int state[N]; + vector[N] v_prev_full; + int y[N]; +} +parameters { + vector[n_age] a; + vector[n_edu] b; + vector[n_age_edu] c; + vector[n_state] d; + vector[n_region_full] e; + vector[5] beta; + real sigma_a; + real sigma_b; + real sigma_c; + real sigma_d; + real sigma_e; +} +transformed parameters { + vector[N] y_hat; + + for (i in 1:N) + y_hat[i] = beta[1] + beta[2] * black[i] + beta[3] * female[i] + + beta[5] * female[i] * black[i] + + beta[4] * v_prev_full[i] + a[age[i]] + b[edu[i]] + + c[age_edu[i]] + d[state[i]] + e[region_full[i]]; +} +model { + a ~ normal (0, sigma_a); + b ~ normal (0, sigma_b); + c ~ normal (0, sigma_c); + d ~ normal (0, sigma_d); + e ~ normal (0, sigma_e); + beta ~ normal(0, 100); + y ~ bernoulli_logit(y_hat); +} diff --git a/test/integration/good/compiler-optimizations/expr-prop-fail4.stan b/test/integration/good/compiler-optimizations/expr-prop-fail4.stan new file mode 100644 index 0000000000..524e12a47c --- /dev/null +++ b/test/integration/good/compiler-optimizations/expr-prop-fail4.stan @@ -0,0 +1,50 @@ +data { + int N; + int N_edges; + int node1[N_edges]; // node1[i] adjacent to node2[i] + int node2[N_edges]; // and node1[i] < node2[i] + vector[N] E; // exposure +} +transformed data { + vector[N] log_E = log(E); +} +parameters { + real tau_phi; // precision of spatial effects + vector[N - 1] phi_std_raw; // raw, standardized spatial effects +} +transformed parameters { + real sigma_phi = inv(sqrt(tau_phi)); // convert precision to sigma + vector[N] phi; + phi[1:(N - 1)] = phi_std_raw; + phi[N] = -sum(phi_std_raw); + phi = phi * sigma_phi; // non-centered parameterization +} +model { + target += -0.5 * dot_self(phi[node1] - phi[node2]); + tau_phi ~ gamma(1, 1); // Carlin WinBUGS priors +} +generated quantities { + real beta0; // intercept + real beta1; // slope + real tau_theta; // precision of heterogeneous effects + real sigma_theta; + vector[N] theta; + vector[N] theta_std; + + vector[N] x; + int y[N]; + + beta0 = normal_rng(0, 1); + beta1 = normal_rng(0, 1); + for (i in 1:N) { + theta_std[i] = normal_rng(0, 1); + } + tau_theta = gamma_rng(3.2761, 1.81); // Carlin WinBUGS priors + sigma_theta = inv(sqrt(tau_theta)); // convert precision to sigma + theta = theta_std * sigma_theta; // non-centered parameterization + + for (i in 1:N) { + x[i] = normal_rng(0, 1); + y[i] = poisson_log_rng(log_E[i] + beta0 + beta1 * x[i] + phi[i] + theta[i]); + } +} diff --git a/test/integration/good/compiler-optimizations/expr-prop-fail5.stan b/test/integration/good/compiler-optimizations/expr-prop-fail5.stan new file mode 100644 index 0000000000..91fd21f843 --- /dev/null +++ b/test/integration/good/compiler-optimizations/expr-prop-fail5.stan @@ -0,0 +1,127 @@ +// This models is derived from section 12.3 of "Stan Modeling Language +// User's Guide and Reference Manual" + +functions { + int first_capture(int[] y_i) { + for (k in 1:size(y_i)) + if (y_i[k]) + return k; + return 0; + } + + int last_capture(int[] y_i) { + for (k_rev in 0:(size(y_i) - 1)) { + // Compoud declaration was enabled in Stan 2.13 + int k = size(y_i) - k_rev; + // int k; + // k = size(y_i) - k_rev; + if (y_i[k]) + return k; + } + return 0; + } + + matrix prob_uncaptured(int nind, int n_occasions, + matrix p, matrix phi) { + matrix[nind, n_occasions] chi; + + for (i in 1:nind) { + chi[i, n_occasions] = 1.0; + for (t in 1:(n_occasions - 1)) { + // Compoud declaration was enabled in Stan 2.13 + int t_curr = n_occasions - t; + int t_next = t_curr + 1; + /* + int t_curr; + int t_next; + + t_curr = n_occasions - t; + t_next = t_curr + 1; + */ + t_curr = n_occasions - t; + t_next = t_curr + 1; + chi[i, t_curr] = (1 - phi[i, t_curr]) + + phi[i, t_curr] * (1 - p[i, t_next - 1]) * chi[i, t_next]; + } + } + return chi; + } +} + +data { + int nind; // Number of individuals + int n_occasions; // Number of capture occasions + int y[nind, n_occasions]; // Capture-history +} + +transformed data { + int n_occ_minus_1 = n_occasions - 1; + // int n_occ_minus_1; + int first[nind]; + int last[nind]; + + // n_occ_minus_1 = n_occasions - 1; + for (i in 1:nind) + first[i] = first_capture(y[i]); + for (i in 1:nind) + last[i] = last_capture(y[i]); +} + +parameters { + real mean_phi; // Mean survival + real mean_p; // Mean recapture + vector[nind] epsilon; + real sigma; + // In case a weakly informative prior is used + // real sigma; +} + +transformed parameters { + matrix[nind, n_occ_minus_1] phi; + matrix[nind, n_occ_minus_1] p; + matrix[nind, n_occasions] chi; + real mu; + + // Constraints + mu = logit(mean_phi); + for (i in 1:nind) { + for (t in 1:(first[i] - 1)) { + phi[i, t] = 0; + p[i, t] = 0; + } + for (t in first[i]:n_occ_minus_1) { + phi[i, t] = inv_logit(mu + epsilon[i]); + p[i, t] = mean_p; + } + } + + chi = prob_uncaptured(nind, n_occasions, p, phi); +} + +model { + // Priors + // Uniform priors are implicitly defined. + // mean_phi ~ uniform(0, 1); + // mean_p ~ uniform(0, 1); + // sigma ~ uniform(0, 5); + // In case a weaily informative prior is used + // sigma ~ normal(2.5, 1.25); + epsilon ~ normal(0, sigma); + + // Likelihood + for (i in 1:nind) { + if (first[i] > 0) { + for (t in (first[i] + 1):last[i]) { + 1 ~ bernoulli(phi[i, t - 1]); + y[i, t] ~ bernoulli(p[i, t - 1]); + } + 1 ~ bernoulli(chi[i, last[i]]); + } + } +} + +generated quantities { + real sigma2; + + sigma2 = square(sigma); +} diff --git a/test/integration/good/compiler-optimizations/expr-prop-fail6.stan b/test/integration/good/compiler-optimizations/expr-prop-fail6.stan new file mode 100644 index 0000000000..2eefa1c3ba --- /dev/null +++ b/test/integration/good/compiler-optimizations/expr-prop-fail6.stan @@ -0,0 +1,264 @@ +// JS model using the superpopulation parameterization + +functions { + // These functions are derived from Section 12.3 of + // Stan Modeling Language User's Guide and Reference Manual + + /** + * Return a integer value of first capture occasion + * + * @param y_i Integer array of capture history + * + * @return Integer value of first capture occasion + */ + int first_capture(int[] y_i) { + for (k in 1:size(y_i)) + if (y_i[k]) + return k; + return 0; + } + + /** + * Return a integer value of last capture occasion + * + * @param y_i Integer array of capture history + * + * @return Integer value of last capture occasion + */ + int last_capture(int[] y_i) { + for (k_rev in 0:(size(y_i) - 1)) { + int k = size(y_i) - k_rev; + + if (y_i[k]) + return k; + } + return 0; + } + + /** + * Return a matrix of uncaptured probabilities + * + * @param p Matrix of detection probabilities for each individual + * and capture occasion + * @param phi Matrix of survival probabilities for each individual + * and capture occasion + * + * @return Matrix of uncaptured probabilities + */ + matrix prob_uncaptured(matrix p, matrix phi) { + int n_ind = rows(p); + int n_occasions = cols(p); + matrix[n_ind, n_occasions] chi; + + for (i in 1:n_ind) { + chi[i, n_occasions] = 1.0; + for (t in 1:(n_occasions - 1)) { + int t_curr = n_occasions - t; + int t_next = t_curr + 1; + + chi[i, t_curr] = (1 - phi[i, t_curr]) + + phi[i, t_curr] * (1 - p[i, t_next]) * chi[i, t_next]; + } + } + return chi; + } + + /** + * Calculate log likelihood of a Jolly-Seber model + * under the superpopulation parameterization + * + * @param y Integer array of capture history + * @param first Integer array of first capture occasions + * @param last Integer array of last capture occasions + * @param p Matrix of detection probabilities + * @param phi Matrix of survival probabilities + * @param psi Real value of inclusion probability + * @param nu Vector of entry probabilities + * @param chi Matrix of uncapture probabilities + */ + void js_super_lp(int[,] y, int[] first, int[] last, + matrix p, matrix phi, real psi, + vector nu, matrix chi) { + int n_ind = dims(y)[1]; + int n_occasions = dims(y)[2]; + vector[n_occasions] qnu = 1.0 - nu; + + for (i in 1:n_ind) { + vector[n_occasions] qp = 1.0 - p[i]'; + + if (first[i]) { // Observed + // Included + 1 ~ bernoulli(psi); + + // Until first capture + if (first[i] == 1) { + 1 ~ bernoulli(nu[1] * p[i, 1]); + } else { // first[i] >= 2 + vector[first[i]] lp; + + // Entered at 1st occasion + lp[1] = bernoulli_lpmf(1 | nu[1]) + + bernoulli_lpmf(1 | prod(qp[1:(first[i] - 1)])) + + bernoulli_lpmf(1 | prod(phi[i, 1:(first[i] - 1)])) + + bernoulli_lpmf(1 | p[i, first[i]]); + // Entered at t-th occasion (1 < t < first[i]) + for (t in 2:(first[i] - 1)) + lp[t] = bernoulli_lpmf(1 | prod(qnu[1:(t - 1)])) + + bernoulli_lpmf(1 | nu[t]) + + bernoulli_lpmf(1 | prod(qp[t:(first[i] - 1)])) + + bernoulli_lpmf(1 | prod(phi[i, t:(first[i] - 1)])) + + bernoulli_lpmf(1 | p[i, first[i]]); + lp[first[i]] = bernoulli_lpmf(1 | prod(qnu[1:(first[i] - 1)])) + + bernoulli_lpmf(1 | nu[first[i]]) + + bernoulli_lpmf(1 | p[i, first[i]]); + target += log_sum_exp(lp); + } + // Until last capture + for (t in (first[i] + 1):last[i]) { + 1 ~ bernoulli(phi[i, t - 1]); // Survived + y[i, t] ~ bernoulli(p[i, t]); // Capture/Non-capture + } + // Subsequent occasions + 1 ~ bernoulli(chi[i, last[i]]); + } else { // Never observed + vector[n_occasions+1] lp; + + // Entered at 1st occasion, but never captured + lp[1] = bernoulli_lpmf(1 | psi) + + bernoulli_lpmf(1 | nu[1]) + + bernoulli_lpmf(0 | p[i, 1]) + + bernoulli_lpmf(1 | chi[i, 1]); + // Entered at t-th occation (t > 1), but never captured + for (t in 2:n_occasions) + lp[t] = bernoulli_lpmf(1 | psi) + + bernoulli_lpmf(1 | prod(qnu[1:(t - 1)])) + + bernoulli_lpmf(1 | nu[t]) + + bernoulli_lpmf(0 | p[i, t]) + + bernoulli_lpmf(1 | chi[i, t]); + // Never captured + lp[n_occasions + 1] = bernoulli_lpmf(0 | psi); + target += log_sum_exp(lp); + } + } + } +} + +data { + int M; // Augmented sample size + int n_occasions; // Number of capture occasions + int y[M, n_occasions]; // Augmented capture-history +} + +transformed data { + int first[M]; + int last[M]; + + for (i in 1:M) + first[i] = first_capture(y[i]); + for (i in 1:M) + last[i] = last_capture(y[i]); +} + +parameters { + real mean_phi; // Mean survival + real mean_p; // Mean capture + real psi; // Inclusion probability + vector[n_occasions] beta; + vector[M] epsilon; + real sigma; + // In case of using a weakly informative prior + // real sigma; +} + +transformed parameters { + matrix[M, n_occasions - 1] phi; + matrix[M, n_occasions] p; + simplex[n_occasions] b; // Entry probability + vector[n_occasions] nu; + matrix[M, n_occasions] chi; + + // Constraints + phi = rep_matrix(mean_phi, M, n_occasions - 1); + for (t in 1:n_occasions) + p[, t] = inv_logit(logit(mean_p) + epsilon); + + + // Dirichlet prior for entry probabilities + // beta ~ gamma(1, 1); // => model block + b = beta / sum(beta); + + // Convert entry probs to conditional entry probs + { + real cum_b = b[1]; + + nu[1] = b[1]; + for (t in 2:(n_occasions - 1)) { + nu[t] = b[t] / (1.0 - cum_b); + cum_b = cum_b + b[t]; + } + nu[n_occasions] = 1.0; + } + + // Uncaptured probability + chi = prob_uncaptured(p, phi); +} + +model { + // Priors + // Uniform priors are implicitly defined. + // In case of using a weakly informative prior on sigma + // sigma ~ normal(2.5, 1.25); + epsilon ~ normal(0, sigma); + beta ~ gamma(1, 1); + + // Likelihood + js_super_lp(y, first, last, p, phi, psi, nu, chi); +} + +generated quantities { + real sigma2; + int Nsuper; // Superpopulation size + int N[n_occasions]; // Actual population size + int B[n_occasions]; // Number of entries + int z[M, n_occasions]; // Deflated latent state + + sigma2 = square(sigma); + + // Generate w[] and z[] + for (i in 1:M) { + int q = 1; + if (bernoulli_rng(psi)) { // Included + z[i, 1] = bernoulli_rng(nu[1]); + for (t in 2:n_occasions) { + q = q * (1 - z[i, t - 1]); + z[i, t] = bernoulli_rng(z[i, t - 1] * phi[i, t - 1] + + q * nu[t]); + } + } else { // Not included + z[i, ] = rep_array(0, n_occasions); + } + } + + // Calculate derived population parameters + { + int recruit[M, n_occasions] = rep_array(0, M, n_occasions); + int Nind[M]; + int Nalive[M]; + + for (i in 1:M) { + int f = first_capture(z[i, ]); + + if (f > 0) + recruit[i, f] = 1; + } + for (t in 1:n_occasions) { + N[t] = sum(z[, t]); + B[t] = sum(recruit[, t]); + } + for (i in 1:M) { + Nind[i] = sum(z[i]); + Nalive[i] = (Nind[i] > 0); + } + Nsuper = sum(Nalive); + } +} diff --git a/test/integration/good/compiler-optimizations/expr-prop-fail7.stan b/test/integration/good/compiler-optimizations/expr-prop-fail7.stan new file mode 100644 index 0000000000..336803cdc2 --- /dev/null +++ b/test/integration/good/compiler-optimizations/expr-prop-fail7.stan @@ -0,0 +1,47 @@ +/* + * Implementation of Dawid and Skene's model for measurement error + * among categoical raters. The model is extended for Bayes fixed priors. + * Discrete parameters for category of items marginalized out with their + * expectation returned on the log scale in derived quantity log_q_z. + * + * Dawid, A. P., & Skene, A. M. (1979). Maximum likelihood estimation + * of observer error-rates using the EM algorithm. Applied statistics, + * 20--28. + */ +data { + int K; // number of categories + int I; // number of items + int J; // number of coders + int y[I,J]; // label for observation n + vector[K] alpha; // prior for prevalence (positive) + vector[K] beta[K]; // prior for coder responses (positive) +} +parameters { + simplex[K] pi; // prevalence of categories + simplex[K] theta[J,K]; // response of anotator j to category k +} +model { + // log prior: log p(theta, pi) + pi ~ dirichlet(alpha); + for (j in 1:J) + for (k in 1:K) + theta[j, k] ~ dirichlet(beta[k]); + + // log marginal likelihood: log p(y | theta, pi) + for (i in 1:I) { + vector[K] log_q = log(pi); + for (j in 1:J) + log_q += to_vector(log(theta[j, , y[i, j]])); + target += log_sum_exp(log_q); + } +} +generated quantities { + // normalized log posterior: log Pr[z | y] + vector[K] log_Pr_z[I]; + for (i in 1:I) { + vector[K] log_q = log(pi); + for (j in 1:J) + log_q += to_vector(log(theta[j, , y[i, j]])); + log_Pr_z[i] = log_q - log_sum_exp(log_q); + } +} diff --git a/test/integration/good/compiler-optimizations/expr-prop-fail8.stan b/test/integration/good/compiler-optimizations/expr-prop-fail8.stan new file mode 100644 index 0000000000..8ed40997e6 --- /dev/null +++ b/test/integration/good/compiler-optimizations/expr-prop-fail8.stan @@ -0,0 +1,28 @@ +data { + int N; + int N_edges; + int node1[N_edges]; // node1[i] adjacent to node2[i] + int node2[N_edges]; // and node1[i] < node2[i] + + int y[N]; // count outcomes + vector[N] x; // predictor +} +parameters { + real beta0; // intercept + real beta1; // slope + + real tau_theta; // precision of heterogeneous effects + real tau_phi; // precision of spatial effects + + vector[N] theta_std; // standardized heterogeneous effects + vector[N] phi_std_raw; // raw, standardized spatial effects +} +transformed parameters { + real sigma_phi = inv(sqrt(tau_phi)); + vector[N] phi; + phi[1:N] = phi_std_raw; + phi = phi * sigma_phi; +} +model { + target += dot_self(phi[node1]); +} diff --git a/test/integration/good/compiler-optimizations/fails-test.stan b/test/integration/good/compiler-optimizations/fails-test.stan new file mode 100644 index 0000000000..a8742e5b37 --- /dev/null +++ b/test/integration/good/compiler-optimizations/fails-test.stan @@ -0,0 +1,111 @@ +// This models is derived from section 12.3 of "Stan Modeling Language +// User's Guide and Reference Manual" + +functions { + int first_capture(int[] y_i) { + for (k in 1:size(y_i)) + if (y_i[k]) + return k; + return 0; + } + + int last_capture(int[] y_i) { + for (k_rev in 0:(size(y_i) - 1)) { + // Compoud declaration was enabled in Stan 2.13 + int k = size(y_i) - k_rev; + // int k; + // k = size(y_i) - k_rev; + if (y_i[k]) + return k; + } + return 0; + } + + matrix prob_uncaptured(int nind, int n_occasions, + matrix p, matrix phi) { + matrix[nind, n_occasions] chi; + + for (i in 1:nind) { + chi[i, n_occasions] = 1.0; + for (t in 1:(n_occasions - 1)) { + // Compoud declaration was enabled in Stan 2.13 + int t_curr = n_occasions - t; + int t_next = t_curr + 1; + /* + int t_curr; + int t_next; + + t_curr = n_occasions - t; + t_next = t_curr + 1; + */ + chi[i, t_curr] = (1 - phi[i, t_curr]) + + phi[i, t_curr] * (1 - p[i, t_next - 1]) * chi[i, t_next]; + } + } + return chi; + } +} + +data { + int nind; // Number of individuals + int n_occasions; // Number of capture occasions + int y[nind, n_occasions]; // Capture-history + int max_age; // Maximum age + int x[nind, n_occasions - 1]; // Age +} + +transformed data { + int n_occ_minus_1 = n_occasions - 1; + // int n_occ_minus_1; + int first[nind]; + int last[nind]; + + // n_occ_minus_1 = n_occasions - 1; + for (i in 1:nind) + first[i] = first_capture(y[i]); + for (i in 1:nind) + last[i] = last_capture(y[i]); +} + +parameters { + real mean_p; // Mean recapture + vector[max_age] beta; // Mean survival +} + +transformed parameters { + matrix[nind, n_occ_minus_1] phi; // Survival + matrix[nind, n_occ_minus_1] p; // Recapture + matrix[nind, n_occasions] chi; + + // Constraints + for (i in 1:nind) { + for (t in 1:(first[i] - 1)) { + phi[i, t] = 0; + p[i, t] = 0; + } + for (t in first[i]:n_occ_minus_1) { + phi[i, t] = beta[x[i, t]]; + p[i, t] = mean_p; + } + } + + chi = prob_uncaptured(nind, n_occasions, p, phi); +} + +model { + // Priors + // Uniform priors are implicitly defined. + // beta ~ uniform(0, 1); + // mean_p ~ uniform(0, 1); + + // Likelihood + for (i in 1:nind) { + if (first[i] > 0) { + for (t in (first[i] + 1):last[i]) { + 1 ~ bernoulli(phi[i, t - 1]); + y[i, t] ~ bernoulli(p[i, t - 1]); + } + 1 ~ bernoulli(chi[i, last[i]]); + } + } +} diff --git a/test/integration/good/compiler-optimizations/inlining-fail2.stan b/test/integration/good/compiler-optimizations/inlining-fail2.stan new file mode 100644 index 0000000000..4bcbdb310f --- /dev/null +++ b/test/integration/good/compiler-optimizations/inlining-fail2.stan @@ -0,0 +1,262 @@ +// Jolly-Seber model as a restricted occupancy model + +functions { + // These functions are derived from Section 12.3 of + // Stan Modeling Language User's Guide and Reference Manual + + /** + * Return a integer value of first capture occasion + * + * @param y_i Integer array of capture history + * + * @return Integer value of first capture occasion + */ + int first_capture(int[] y_i) { + for (k in 1:size(y_i)) + if (y_i[k]) + return k; + return 0; + } + + /** + * Return a integer value of last capture occasion + * + * @param y_i Integer array of capture history + * + * @return Integer value of last capture occasion + */ + int last_capture(int[] y_i) { + for (k_rev in 0:(size(y_i) - 1)) { + int k = size(y_i) - k_rev; + + if (y_i[k]) + return k; + } + return 0; + } + + /** + * Return a matrix of uncaptured probabilities + * + * @param p Matrix of detection probabilities for each individual + * and capture occasion + * @param phi Matrix of survival probabilities for each individual + * and capture occasion + * + * @return Matrix of uncaptured probabilities + */ + matrix prob_uncaptured(matrix p, matrix phi) { + int n_ind = rows(p); + int n_occasions = cols(p); + matrix[n_ind, n_occasions] chi; + + for (i in 1:n_ind) { + chi[i, n_occasions] = 1.0; + for (t in 1:(n_occasions - 1)) { + int t_curr = n_occasions - t; + int t_next = t_curr + 1; + + chi[i, t_curr] = (1 - phi[i, t_curr]) + + phi[i, t_curr] * (1 - p[i, t_next]) * chi[i, t_next]; + } + } + return chi; + } + + /** + * Calculate log likelihood of a Jolly-Seber model + * + * @param y Integer array of capture history + * @param first Integer array of first capture occasions + * @param last Integer array of last capture occasions + * @param p Matrix of detection probabilities + * @param phi Matrix of survival probabilities + * @param gamma Vector of removal entry probabilities + * @param chi Matrix of uncapture probabilities + */ + void jolly_seber_lp(int[,] y, int[] first, int[] last, + matrix p, matrix phi, vector gamma, + matrix chi) { + int n_ind = dims(y)[1]; + int n_occasions = dims(y)[2]; + vector[n_occasions] qgamma = 1.0 - gamma; + + for (i in 1:n_ind) { + vector[n_occasions] qp = 1.0 - p[i]'; + + if (first[i]) { // Captured + // Until first capture + if (first[i] == 1) { + 1 ~ bernoulli(gamma[1] * p[i, 1]); + } else { + vector[first[i]] lp; + + // Entered at 1st occasion + lp[1] = bernoulli_lpmf(1 | gamma[1]) + + bernoulli_lpmf(1 | prod(qp[1:(first[i] - 1)])) + + bernoulli_lpmf(1 | prod(phi[i, 1:(first[i] - 1)])) + + bernoulli_lpmf(1 | p[i, first[i]]); + // Entered at t-th occasion (1 < t < first[i]) + for (t in 2:(first[i] - 1)) + lp[t] = bernoulli_lpmf(1 | prod(qgamma[1:(t - 1)])) + + bernoulli_lpmf(1 | gamma[t]) + + bernoulli_lpmf(1 | prod(qp[t:(first[i] - 1)])) + + bernoulli_lpmf(1 | prod(phi[i, t:(first[i] - 1)])) + + bernoulli_lpmf(1 | p[i, first[i]]); + lp[first[i]] = bernoulli_lpmf(1 | prod(qgamma[1:(first[i] - 1)])) + + bernoulli_lpmf(1 | gamma[first[i]]) + + bernoulli_lpmf(1 | p[i, first[i]]); + target += log_sum_exp(lp); + } + // Until last capture + for (t in (first[i] + 1):last[i]) { + 1 ~ bernoulli(phi[i, t - 1]); // Survived + y[i, t] ~ bernoulli(p[i, t]); // Capture/Non-capture + } + // Subsequent occasions + 1 ~ bernoulli(chi[i, last[i]]); + } else { // Never captured + vector[n_occasions+1] lp; + + // Entered at 1st occasion, but never captured + lp[1] = bernoulli_lpmf(1 | gamma[1]) + + bernoulli_lpmf(0 | p[i, 1]) + + bernoulli_lpmf(1 | chi[i, 1]); + // Entered at t-th occasion, but never captured + for (t in 2:n_occasions) + lp[t] = bernoulli_lpmf(1 | prod(qgamma[1:(t - 1)])) + + bernoulli_lpmf(1 | gamma[t]) + + bernoulli_lpmf(0 | p[i, t]) + + bernoulli_lpmf(1 | chi[i, t]); + // Never entered + lp[n_occasions + 1] = bernoulli_lpmf(1 | prod(qgamma)); + target += log_sum_exp(lp); + } + } + } + + /** + * Returns delta, where + * delta[n] = gamma[n] * PROD_{m < n} (1 - gamma[m]) + * (Thanks to Dr. Carpenter) + * + * @param gamma Vector of probability sequence + * + * @return Vector of complementary probability sequence + */ + vector seq_cprob(vector gamma) { + int N = rows(gamma); + vector[N] log_cprob; + real log_residual_prob = 0; + + for (n in 1:N) { + log_cprob[n] = log(gamma[n]) + log_residual_prob; + log_residual_prob = log_residual_prob + log(1 - gamma[n]); + } + return exp(log_cprob); + } +} + +data { + int M; // Augmented sample size + int n_occasions; // Number of capture occasions + int y[M, n_occasions]; // Augmented capture-history +} + +transformed data { + int first[M]; + int last[M]; + + for (i in 1:M) + first[i] = first_capture(y[i]); + for (i in 1:M) + last[i] = last_capture(y[i]); +} + +parameters { + real mean_phi; // Mean survival + real mean_p; // Mean capture + vector[n_occasions] gamma; // Removal entry probability + vector[n_occasions-1] epsilon; + real sigma; + // In case of using a weakly informative prior + // real sigma; +} + +transformed parameters { + matrix[M, n_occasions - 1] phi; + matrix[M, n_occasions] p; + matrix[M, n_occasions] chi; + + // Constraints + for (t in 1:(n_occasions - 1)) + for (i in 1:M) + phi[i, t] = inv_logit(logit(mean_phi) + epsilon[t]); + p = rep_matrix(mean_p, M, n_occasions); + + // Uncaptured probability + chi = prob_uncaptured(p, phi); +} + +model { + // Priors + // Uniform priors are implicitly defined. + // In case of using a weakly informative prior on sigma + // sigma ~ normal(2.5, 1.25); + epsilon ~ normal(0, sigma); + + // Likelihood + jolly_seber_lp(y, first, last, p, phi, gamma, chi); +} + +generated quantities { + real sigma2; + real psi; // Inclusion probability + vector[n_occasions] b; // Entry probability + int Nsuper; // Superpopulation size + int N[n_occasions]; // Actual population size + int B[n_occasions]; // Number of entries + int z[M, n_occasions]; // Latent state + + // Generate z[] + for (i in 1:M) { + int q = 1; + real mu2; + + z[i, 1] = bernoulli_rng(gamma[1]); + for (t in 2:n_occasions) { + q = q * (1 - z[i, t - 1]); + mu2 = phi[i, t - 1] * z[i, t - 1] + + gamma[t] * q; + z[i, t] = bernoulli_rng(mu2); + } + } + + // Calculate derived population parameters + { + vector[n_occasions] cprob = seq_cprob(gamma); + int recruit[M, n_occasions] = rep_array(0, M, n_occasions); + int Nind[M]; + int Nalive[M]; + + sigma2 = square(sigma); + psi = sum(cprob); + b = cprob / psi; + + for (i in 1:M) { + int f = first_capture(z[i, ]); + + if (f > 0) + recruit[i, f] = 1; + } + for (t in 1:n_occasions) { + N[t] = sum(z[, t]); + B[t] = sum(recruit[, t]); + } + for (i in 1:M) { + Nind[i] = sum(z[i]); + Nalive[i] = 1 - !Nind[i]; + } + Nsuper = sum(Nalive); + } +} diff --git a/test/integration/good/compiler-optimizations/lcm-experiment.stan b/test/integration/good/compiler-optimizations/lcm-experiment.stan new file mode 100644 index 0000000000..025b36c3e8 --- /dev/null +++ b/test/integration/good/compiler-optimizations/lcm-experiment.stan @@ -0,0 +1,14 @@ +data { + int j; +} +transformed data { + real z = 1; + real x; + { + x = normal_rng(123, 1); + z = normal_rng(sqrt(j)*2+1, 1); + } + real i = normal_rng(sqrt(j)*2+1, 1); +} +model { +} diff --git a/test/integration/good/compiler-optimizations/lcm-experiment2.stan b/test/integration/good/compiler-optimizations/lcm-experiment2.stan new file mode 100644 index 0000000000..45bb907fda --- /dev/null +++ b/test/integration/good/compiler-optimizations/lcm-experiment2.stan @@ -0,0 +1,12 @@ +parameters { + real x; +} +model { + real y = log(x); + for (j in 1:1) { + y += 1; + } + if (1 > 0) + y += 1; + target += y; +} diff --git a/test/integration/good/compiler-optimizations/lcm-fails.stan b/test/integration/good/compiler-optimizations/lcm-fails.stan new file mode 100644 index 0000000000..b6b9fc5d4d --- /dev/null +++ b/test/integration/good/compiler-optimizations/lcm-fails.stan @@ -0,0 +1,10 @@ +data { + int J; // number of schools + real y[J]; // estimated treatment effect (school j) +} +parameters { + real theta[J]; +} +model { + y ~ normal(theta,1); +} diff --git a/test/integration/good/compiler-optimizations/lcm-fails2.stan b/test/integration/good/compiler-optimizations/lcm-fails2.stan new file mode 100644 index 0000000000..ab5a3ff4a4 --- /dev/null +++ b/test/integration/good/compiler-optimizations/lcm-fails2.stan @@ -0,0 +1,109 @@ +// This models is derived from section 12.3 of "Stan Modeling Language +// User's Guide and Reference Manual" + +functions { + int first_capture(int[] y_i) { + for (k in 1:size(y_i)) + if (y_i[k]) + return k; + return 0; + } + + int last_capture(int[] y_i) { + for (k_rev in 0:(size(y_i) - 1)) { + // Compoud declaration was enabled in Stan 2.13 + int k = size(y_i) - k_rev; + // int k; + // k = size(y_i) - k_rev; + if (y_i[k]) + return k; + } + return 0; + } + + matrix prob_uncaptured(int nind, int n_occasions, + matrix p, matrix phi) { + matrix[nind, n_occasions] chi; + + for (i in 1:nind) { + chi[i, n_occasions] = 1.0; + for (t in 1:(n_occasions - 1)) { + // Compoud declaration was enabled in Stan 2.13 + int t_curr = n_occasions - t; + int t_next = t_curr + 1; + /* + int t_curr; + int t_next; + + t_curr = n_occasions - t; + t_next = t_curr + 1; + */ + chi[i, t_curr] = (1 - phi[i, t_curr]) + + phi[i, t_curr] * (1 - p[i, t_next - 1]) * chi[i, t_next]; + } + } + return chi; + } +} + +data { + int nind; // Number of individuals + int n_occasions; // Number of capture occasions + int y[nind, n_occasions]; // Capture-history +} + +transformed data { + int n_occ_minus_1 = n_occasions - 1; + // int n_occ_minus_1; + int first[nind]; + int last[nind]; + + // n_occ_minus_1 = n_occasions - 1; + for (i in 1:nind) + first[i] = first_capture(y[i]); + for (i in 1:nind) + last[i] = last_capture(y[i]); +} + +parameters { + real mean_phi; // Mean survival + real mean_p; // Mean recapture +} + +transformed parameters { + matrix[nind, n_occ_minus_1] phi; + matrix[nind, n_occ_minus_1] p; + matrix[nind, n_occasions] chi; + + // Constraints + for (i in 1:nind) { + for (t in 1:(first[i] - 1)) { + phi[i, t] = 0; + p[i, t] = 0; + } + for (t in first[i]:n_occ_minus_1) { + phi[i, t] = mean_phi; + p[i, t] = mean_p; + } + } + + chi = prob_uncaptured(nind, n_occasions, p, phi); +} + +model { + // Priors + // Uniform priors are implicitly defined. + // mean_phi ~ uniform(0, 1); + // mean_p ~ uniform(0, 1); + + // Likelihood + for (i in 1:nind) { + if (first[i] > 0) { + for (t in (first[i] + 1):last[i]) { + 1 ~ bernoulli(phi[i, t - 1]); + y[i, t] ~ bernoulli(p[i, t - 1]); + } + 1 ~ bernoulli(chi[i, last[i]]); + } + } +} diff --git a/test/integration/good/compiler-optimizations/off-dce.stan b/test/integration/good/compiler-optimizations/off-dce.stan new file mode 100644 index 0000000000..5200dbfd0b --- /dev/null +++ b/test/integration/good/compiler-optimizations/off-dce.stan @@ -0,0 +1,75 @@ +// Site-occupancy models with covariates + +data { + int R; // Number of sites + int T; // Number of temporal replications + int y[R, T]; // Observation + vector[R] X; // Covariate +} + +transformed data { + int sum_y[R]; // Number of occupation for each site + int occ_obs; // Number of observed occupied sites + + occ_obs = 0; + for (i in 1:R) { + sum_y[i] = sum(y[i]); + if (sum_y[i]) + occ_obs = occ_obs + 1; + } +} + +parameters { + real alpha_occ; + real beta_occ; + real alpha_p; + real beta_p; +} + +transformed parameters { + vector[R] logit_psi; // Logit occupancy probability + matrix[R, T] logit_p; // Logit detection probability + + logit_psi = alpha_occ + beta_occ * X; + logit_p = rep_matrix(alpha_p + beta_p * X, T); +} + +model { + // Priors + // Improper flat priors are implicitly used on + // alpha_occ, beta_occ, alpha_p and beta_p. + + // Likelihood + for (i in 1:R) { + if (sum_y[i]) { // Occurred and observed + 1 ~ bernoulli_logit(logit_psi[i]); + y[i] ~ bernoulli_logit(logit_p[i]); + } else { + // Occurred and not observed + target += log_sum_exp(bernoulli_logit_lpmf(1 | logit_psi[i]) + + bernoulli_logit_lpmf(0 | logit_p[i]), + // Not occurred + bernoulli_logit_lpmf(0 | logit_psi[i])); + } + } +} + +generated quantities { + int occ_fs; // Number of occupied sites + real psi_con[R]; // prob occupied conditional on data + int z[R]; // occupancy indicator, 0/1 + + for (i in 1:R) { + if (sum_y[i] == 0) { // species not detected + real psi = inv_logit(logit_psi[i]); + vector[T] q = inv_logit(-logit_p[i])'; // q = 1 - p + real qT = prod(q[]); + psi_con[i] = (psi * qT) / (psi * qT + (1 - psi)); + z[i] = bernoulli_rng(psi_con[i]); + } else { // species detected at least once + psi_con[i] = 1; + z[i] = 1; + } + } + occ_fs = sum(z); +} diff --git a/test/integration/good/compiler-optimizations/off-small.stan b/test/integration/good/compiler-optimizations/off-small.stan new file mode 100644 index 0000000000..3c012fdc5a --- /dev/null +++ b/test/integration/good/compiler-optimizations/off-small.stan @@ -0,0 +1,40 @@ +data { + int J; + int N; + int person[N]; + vector[N] time; + vector[N] treatment; + vector[N] y; +} +parameters { + real beta; + vector[J] eta1; + vector[J] eta2; + real mu_a1; + real mu_a2; + real sigma_a1; + real sigma_a2; + real sigma_y; +} +transformed parameters { + vector[J] a1; + vector[J] a2; + vector[N] y_hat; + + a1 = 10 * mu_a1 + sigma_a1 * eta1; + a2 = 0.1 * mu_a2 + sigma_a2 * eta2; + + for (i in 1:N) + y_hat[i] = beta * time[i] * treatment[i] + a1[person[i]] + + a2[person[i]] * time[i]; +} +model { + mu_a1 ~ normal(0, 1); + eta1 ~ normal (0, 1); + mu_a2 ~ normal(0, 1); + eta2 ~ normal (0, 1); + + beta ~ normal (0, 1); + + y ~ normal(y_hat, sigma_y); +} diff --git a/test/integration/good/compiler-optimizations/partial-eval.stan b/test/integration/good/compiler-optimizations/partial-eval.stan new file mode 100644 index 0000000000..1114524265 --- /dev/null +++ b/test/integration/good/compiler-optimizations/partial-eval.stan @@ -0,0 +1,28 @@ +data { + int N; + int n_pair; + int pair[N]; + vector[N] pre_test; + vector[N] treatment; + vector[N] y; +} +parameters { + vector[n_pair] a; + vector[2] beta; + real mu_a; + real sigma_a; + real sigma_y; +} +transformed parameters { + vector[N] y_hat; + + for (i in 1:N) + y_hat[i] = a[pair[i]] + beta[1] * treatment[i] + + beta[2] * pre_test[i]; +} +model { + mu_a ~ normal(0, 1); + a ~ normal(100 * mu_a, sigma_a); + beta ~ normal(0, 100); + y ~ normal(y_hat, sigma_y); +} diff --git a/test/integration/good/compiler-optimizations/stalled1-failure.stan b/test/integration/good/compiler-optimizations/stalled1-failure.stan new file mode 100644 index 0000000000..813ed73f9b --- /dev/null +++ b/test/integration/good/compiler-optimizations/stalled1-failure.stan @@ -0,0 +1,53 @@ +# Using Data Cloning to Calculate MLEs for the Seeds Model in vol1 +# http://www.openbugs.net/Examples/DataCloning.html + +# The basic idea is that we raise the likelihood in the +# posterior to the power of K so that the posterior +# estimates would concentrate on the MLE estimates. +# Reference: +# Ecology Letters +# Subhash R. Lele Brian Dennis Frithjof Lutscher +# DOI: 10.1111/j.1461-0248.2007.01047.x +# http://onlinelibrary.wiley.com/doi/10.1111/j.1461-0248.2007.01047.x/abstract + + +data { + int I; + int n[I]; + int N[I]; + vector[I] x1; + vector[I] x2; +} + +transformed data { + int K; + vector[I] x1x2; + K <- 8; // {1, 2, 4, 8, 16, 32, 64, 128, 256} + x1x2 <- x1 .* x2; +} + +parameters { + real alpha0; + real alpha1; + real alpha2; + real alpha12; + real tau; + vector[K] b[I]; +} + +transformed parameters { + real sigma; + sigma <- 1 / sqrt(tau); +} + +model { + alpha0 ~ normal(0.0, 1.0E3); + alpha1 ~ normal(0.0, 1.0E3); + alpha2 ~ normal(0.0, 1.0E3); + alpha12 ~ normal(0.0, 1.0E3); + tau ~ gamma(1.0E-3, 1.0E-3); + for (i in 1:I) { + b[i] ~ normal(0.0, sigma); + n[i] ~ binomial_logit(N[i], alpha0 + alpha1 * x1[i] + alpha2 * x2[i] + alpha12 * x1x2[i] + b[i]); + } +} From a2e1d103428b9f86544b7c5c8ae99b39cbfbd453 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Sat, 25 Apr 2020 13:26:09 -0400 Subject: [PATCH 24/27] reverted optimization CLI interface --- src/analysis_and_optimization/Optimize.ml | 22 ++++++- src/analysis_and_optimization/Optimize.mli | 6 +- src/stanc/stanc.ml | 60 ++----------------- .../good/compiler-optimizations/cpp.expected | 48 +++++++-------- .../good/compiler-optimizations/dune | 2 +- 5 files changed, 56 insertions(+), 82 deletions(-) diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml index 6ae8ef803c..1e0d703c32 100644 --- a/src/analysis_and_optimization/Optimize.ml +++ b/src/analysis_and_optimization/Optimize.ml @@ -1070,7 +1070,27 @@ type optimization_settings = ; lazy_code_motion: bool ; optimize_ad_levels: bool } -let optimization_suite settings mir = +let const_optimizations b : optimization_settings = + { function_inlining= b + ; static_loop_unrolling= b + ; one_step_loop_unrolling= b + ; list_collapsing= b + ; block_fixing= b + ; constant_propagation= b + ; expression_propagation= b + ; copy_propagation= b + ; dead_code_elimination= b + ; partial_evaluation= b + ; lazy_code_motion= b + ; optimize_ad_levels= b } + +let all_optimizations : optimization_settings = + const_optimizations true + +let no_optimizations : optimization_settings = + const_optimizations false + +let optimization_suite ?settings:(settings=all_optimizations) mir = let maybe_optimizations = [ (* Phase order. See phase-ordering-nodes.org for details *) (* Book section A *) diff --git a/src/analysis_and_optimization/Optimize.mli b/src/analysis_and_optimization/Optimize.mli index 88aeaf1922..5dbea5dd9c 100644 --- a/src/analysis_and_optimization/Optimize.mli +++ b/src/analysis_and_optimization/Optimize.mli @@ -70,6 +70,10 @@ type optimization_settings = ; lazy_code_motion: bool ; optimize_ad_levels: bool } +val all_optimizations : optimization_settings + +val no_optimizations : optimization_settings + val optimization_suite : - optimization_settings -> Program.Typed.t -> Program.Typed.t + ?settings:optimization_settings -> Program.Typed.t -> Program.Typed.t (** Perform all optimizations in this module on the MIR in an appropriate order. *) diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml index 12aa470a5a..d1752dff09 100644 --- a/src/stanc/stanc.ml +++ b/src/stanc/stanc.ml @@ -25,7 +25,7 @@ let dump_tx_mir_pretty = ref false let dump_opt_mir = ref false let dump_opt_mir_pretty = ref false let dump_stan_math_sigs = ref false -let optimize_lvl = ref 0 +let optimize = ref false let output_file = ref "" let generate_data = ref false let warn_uninitialized = ref false @@ -98,9 +98,9 @@ let options = , " Take a string to set the model name (default = \ \"$model_filename_model\")" ) ; ( "--O" - , Arg.Set_int optimize_lvl + , Arg.Set optimize , "Allow the compiler to apply all optimizations to the Stan \ - code.WARNING: This is currently an experimental feature!" ) + code." ) ; ( "--o" , Arg.Set_string output_file , " Take the path to an output file for generated C++ code (default = \ @@ -122,56 +122,6 @@ let options = , Arg.Set Transform_Mir.use_opencl , " If set, try to use matrix_cl signatures." ) ] -(* Whether or not to run each optimization. Currently it's all or nothing - depending on the --O flag.*) -let optimization_settings lvl : Optimize.optimization_settings = - let _ : Optimize.optimization_settings = - { function_inlining= false - ; static_loop_unrolling= false - ; one_step_loop_unrolling= false - ; list_collapsing= false - ; block_fixing= false - ; constant_propagation= false - ; expression_propagation= false - ; copy_propagation= false - ; dead_code_elimination= false - ; partial_evaluation= false - ; lazy_code_motion= false - ; optimize_ad_levels= false - } - in - let max_safe : Optimize.optimization_settings = - { function_inlining= true - ; static_loop_unrolling= true - ; one_step_loop_unrolling= true - ; list_collapsing= true - ; block_fixing= true - ; constant_propagation= true - ; expression_propagation= true - ; copy_propagation= true - ; dead_code_elimination= true - ; partial_evaluation= true - ; lazy_code_motion= true - ; optimize_ad_levels= true - } - in match lvl with - | 1 -> - { max_safe with - copy_propagation = true - ; expression_propagation = false - } - | 2 -> - { max_safe with - lazy_code_motion = true - ; expression_propagation = true - ; function_inlining = true - ; dead_code_elimination = true - ; optimize_ad_levels = true - ; partial_evaluation = true - } - | _ -> - raise (Failure ("Unsupported optimization level " ^ string_of_int lvl)) - let print_warn_uninitialized (uninit_vars : (Location_span.t * string) Set.Poly.t) = let show_location_span Location_span.({begin_loc; end_loc; _}) = @@ -246,9 +196,9 @@ let use_file filename = [%sexp (tx_mir : Middle.Program.Typed.t)] ; if !dump_tx_mir_pretty then Program.Typed.pp Format.std_formatter tx_mir ; let opt_mir = - if !optimize_lvl > 0 then ( + if !optimize then ( let opt = - Optimize.optimization_suite (optimization_settings !optimize_lvl) tx_mir + Optimize.optimization_suite tx_mir in if !dump_opt_mir then Sexp.pp_hum Format.std_formatter diff --git a/test/integration/good/compiler-optimizations/cpp.expected b/test/integration/good/compiler-optimizations/cpp.expected index f633682827..6658b6f661 100644 --- a/test/integration/good/compiler-optimizations/cpp.expected +++ b/test/integration/good/compiler-optimizations/cpp.expected @@ -1,4 +1,4 @@ - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp ad-level-failing.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp ad-level-failing.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -815,7 +815,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp copy_fail.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp copy_fail.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -3159,7 +3159,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp dce-fail.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp dce-fail.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -4789,7 +4789,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-experiment.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-experiment.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -5161,7 +5161,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-experiment2.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-experiment2.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -5530,7 +5530,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-fail.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -6180,7 +6180,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-fail2.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail2.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -6684,7 +6684,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-fail3.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail3.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -8206,7 +8206,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-fail4.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail4.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -9156,7 +9156,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-fail5.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail5.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -11417,7 +11417,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-fail6.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail6.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -15458,7 +15458,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-fail7.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail7.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -16963,7 +16963,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp expr-prop-fail8.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail8.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -17806,7 +17806,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp fails-test.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp fails-test.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -20150,7 +20150,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp inlining-fail2.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp inlining-fail2.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -24096,7 +24096,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp lcm-experiment.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp lcm-experiment.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -24461,7 +24461,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp lcm-experiment2.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp lcm-experiment2.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -24826,7 +24826,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp lcm-fails.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp lcm-fails.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -25244,7 +25244,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp lcm-fails2.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp lcm-fails2.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -27340,7 +27340,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp off-dce.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp off-dce.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -28449,7 +28449,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp off-small.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp off-small.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -29484,7 +29484,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp optimizations.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp optimizations.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -30974,7 +30974,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp partial-eval.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp partial-eval.stan // Code generated by %%NAME%% %%VERSION%% #include @@ -31806,7 +31806,7 @@ stan::model::model_base& new_model( - $ ../../../../../install/default/bin/stanc --O 2 --print-cpp stalled1-failure.stan + $ ../../../../../install/default/bin/stanc --O --print-cpp stalled1-failure.stan // Code generated by %%NAME%% %%VERSION%% #include diff --git a/test/integration/good/compiler-optimizations/dune b/test/integration/good/compiler-optimizations/dune index cf41a81287..ba32bbdeb2 100644 --- a/test/integration/good/compiler-optimizations/dune +++ b/test/integration/good/compiler-optimizations/dune @@ -27,7 +27,7 @@ ad-level-failing.stan)) (action (with-stdout-to %{targets} - (run %{bin:run_bin_on_args} "%{bin:stanc} --O 2 --print-cpp" %{stanfiles})))) + (run %{bin:run_bin_on_args} "%{bin:stanc} --O --print-cpp" %{stanfiles})))) (alias (name runtest) From c7447b8dcfd9c43065cca3139619f01feb761c33 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Sat, 25 Apr 2020 13:30:00 -0400 Subject: [PATCH 25/27] Removed debug code --- .../Monotone_framework.ml | 44 ------------- src/analysis_and_optimization/Optimize.ml | 61 ++----------------- 2 files changed, 4 insertions(+), 101 deletions(-) diff --git a/src/analysis_and_optimization/Monotone_framework.ml b/src/analysis_and_optimization/Monotone_framework.ml index 99d8267688..b60d34b8a4 100644 --- a/src/analysis_and_optimization/Monotone_framework.ml +++ b/src/analysis_and_optimization/Monotone_framework.ml @@ -324,8 +324,6 @@ let label_top_decls | Decl {decl_id= s; _} -> Set.Poly.singleton s | _ -> Set.Poly.empty -let exprop_debug = false - (** The transfer function for an expression propagation analysis, AKA forward substitution (see page 396 of Muchnick) *) let expression_propagation_transfer @@ -1024,8 +1022,6 @@ let live_variables_mfp (prog : Program.Typed.t) in Mf.mfp () -let lcm_debug = false - (** Instantiate all four instances of the monotone framework for lazy code motion, reusing code between them *) let lazy_expressions_mfp @@ -1087,46 +1083,6 @@ let lazy_expressions_mfp (module Transfer4) in let used_not_latest_expressions_mfp = Mf4.mfp () in - let _ = - if lcm_debug then - let print_set s to_string = - [%sexp (Set.Poly.map ~f:to_string s : string Set.Poly.t)] |> Sexp.to_string - in - let print_expr (e:Expr.Typed.t) = - [%sexp (e.pattern : Expr.Typed.Meta.t Expr.Fixed.t Expr.Fixed.Pattern.t)] |> Sexp.to_string - in - let print_expr_set s = - print_set s print_expr - in - let print_stmt s = - [%sexp (s : Stmt.Located.Non_recursive.t)] |> Sexp.to_string_hum - in - Map.iteri flowgraph_to_mir ~f:(fun ~key ~data -> - let used = Map.Poly.find_exn used_expr key in - let ant = Map.Poly.find_exn anticipated_expressions_mfp key in - let avl = Map.Poly.find_exn available_expressions_mfp key in - let earliest = Map.Poly.find_exn earliest_expr key in - let post = Map.Poly.find_exn postponable_expressions_mfp key in - let latest = Map.Poly.find_exn latest_expr key in - let used_not_latest = Map.Poly.find_exn used_not_latest_expressions_mfp key in - List.iter ~f:print_endline - [ string_of_int key ^ ":" - ; "\tStmt: " ^ print_stmt data - ; "\tUsed: " ^ print_expr_set used - ; "\tAnticipated.entry: " ^ print_expr_set ant.entry - ; "\tAnticipated.exit: " ^ print_expr_set ant.exit - ; "\tAvailable.entry: " ^ print_expr_set avl.entry - ; "\tAvailable.exit: " ^ print_expr_set avl.exit - ; "\tEarliest: " ^ print_expr_set earliest - ; "\tPostponable.entry: " ^ print_expr_set post.entry - ; "\tPostponable.exit: " ^ print_expr_set post.exit - ; "\tLatest: " ^ print_expr_set latest - ; "\tUsed_not_latest.entry: " ^ print_expr_set used_not_latest.entry - ; "\tUsed_not_latest.exit: " ^ print_expr_set used_not_latest.exit - ; "" - ] - ) - in (latest_expr, used_not_latest_expressions_mfp) (** Perform the analysis for ad-levels, using both the fwd and reverse pass *) diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml index 1e0d703c32..1ea80bb277 100644 --- a/src/analysis_and_optimization/Optimize.ml +++ b/src/analysis_and_optimization/Optimize.ml @@ -637,21 +637,9 @@ let cannot_remove_expr (e : Expr.Typed.t) = expr_any can_side_effect_top_expr e let expression_propagation mir = - let res = - propagation - (Monotone_framework.expression_propagation_transfer cannot_duplicate_expr) - mir - in - let _ = if Monotone_framework.exprop_debug then ( - print_endline "Input program: {!"; - Program.Typed.pp Fmt.stdout mir; - print_endline "}!"; - print_endline "Output program: {!"; - Program.Typed.pp Fmt.stdout res; - print_endline "}!"; - ) - in - res + propagation + (Monotone_framework.expression_propagation_transfer cannot_duplicate_expr) + mir let copy_propagation mir = let globals = Monotone_framework.globals mir in @@ -754,13 +742,6 @@ let lazy_code_motion (mir : Program.Typed.t) = (* TODO: clean up this code. It is not very pretty. *) (* TODO: make lazy code motion operate on transformed parameters and models blocks simultaneously *) - let _ = - if Monotone_framework.lcm_debug then ( - print_endline "Input program: {!"; - Program.Typed.pp Fmt.stdout mir; - print_endline "}!"; - ) - in let preprocess_flowgraph = let preprocess_flowgraph_base (stmt : (Expr.Typed.t, Stmt.Located.t) Stmt.Fixed.Pattern.t) = @@ -821,18 +802,6 @@ let lazy_code_motion (mir : Program.Typed.t) = Set.fold (Monotone_framework.used_expressions_stmt s.pattern) ~init:Expr.Typed.Map.empty ~f:collect_expressions in - let _ = - if Monotone_framework.lcm_debug then - let print_expr (e:Expr.Typed.t) = - [%sexp (e.pattern : Expr.Typed.Meta.t Expr.Fixed.t Expr.Fixed.Pattern.t)] |> Sexp.to_string - in - (print_endline "Expression map:"; - Map.iteri expression_map ~f:(fun ~key ~data -> - print_endline ( - "\t" ^ print_expr key ^ " -> " ^ data - ) - )) - in (* TODO: it'd be more efficient to just not accumulate constants in the static analysis *) let declarations_list = Map.fold expression_map ~init:[] ~f:(fun ~key ~data accum -> @@ -892,20 +861,6 @@ let lazy_code_motion (mir : Program.Typed.t) = (Map.mapi expression_map ~f:(fun ~key ~data -> {key with pattern= Var data} )) in - let _ = - if Monotone_framework.lcm_debug then - let print_expr (e:Expr.Typed.t) = - [%sexp (e.pattern : Expr.Typed.Meta.t Expr.Fixed.t Expr.Fixed.Pattern.t)] - |> Sexp.to_string - in - (print_endline (string_of_int i ^ ": expression replacement map: {"); - Map.iteri expr_map ~f:(fun ~key ~data -> - print_endline ( - "\t" ^ print_expr key ^ " -> " ^ print_expr data - ) - ); - print_endline "}";) - in let f = expr_subst_stmt_except_initial_assign expr_map in @@ -951,15 +906,7 @@ let lazy_code_motion (mir : Program.Typed.t) = in map_rec_stmt_loc cleanup_base in - let res = transform_program_blockwise mir (fun _ x -> cleanup (transform (preprocess_flowgraph x))) in - let _ = - if Monotone_framework.lcm_debug then ( - print_endline "Output program: {!"; - Program.Typed.pp Fmt.stdout res; - print_endline "}!"; - ) - in - res + transform_program_blockwise mir (fun _ x -> cleanup (transform (preprocess_flowgraph x))) let block_fixing mir = transform_program_blockwise mir From a9df3b5e060f475e70d83d9648f5ec0c8294f198 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Thu, 21 May 2020 09:51:12 -0400 Subject: [PATCH 26/27] Workaround for issue with fdbody=Skip --- src/analysis_and_optimization/Optimize.ml | 41 ++++++++++++++++------- 1 file changed, 28 insertions(+), 13 deletions(-) diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml index 1ea80bb277..c460a3b3be 100644 --- a/src/analysis_and_optimization/Optimize.ml +++ b/src/analysis_and_optimization/Optimize.ml @@ -56,8 +56,14 @@ let transform_program_blockwise (mir : Program.Typed.t) raise (Failure "Something went wrong with program transformation packing!") in + (* Right now, we have an implicit constraint where if fdbody = Skip, the + fun_def is a function declaration. When that's the case we don't want + to change it from Skip.*) + let non_decl_functions = + List.filter ~f:(fun def -> def.fdbody.pattern <> Skip) mir.functions_block + in let transformed_functions = - List.map mir.functions_block ~f:(fun fs -> + List.map non_decl_functions ~f:(fun fs -> {fs with fdbody= transform (Some fs) fs.fdbody} ) in { mir with @@ -407,22 +413,31 @@ let rec inline_function_statement adt fim Stmt.Fixed.({pattern; meta}) = let create_function_inline_map adt l = (* We only add the first definition for each function to the inline map. - This will make sure we do not inline recursive functions. *) - let f accum fundef = - match fundef with Program.({fdname; fdargs; fdbody; fdrt; _}) -> ( - match - Map.add accum ~key:fdname - ~data: + This will make sure we do not inline recursive functions. + We also don't want to add any function declaration (as opposed to + definitions), because that would replace the function call with a Skip. + *) + let f (accum, visited) Program.({fdname; fdargs; fdbody; fdrt; _}) = + if Set.mem visited fdname then + (accum, visited) + else + let accum' = match fdbody with + | Stmt.Fixed.{pattern= Stmt.Fixed.Pattern.Skip; _} -> accum + | _ -> + let data = ( Option.map ~f:(fun x -> Type.Unsized x) fdrt , List.map ~f:(fun (_, name, _) -> name) fdargs , inline_function_statement adt accum fdbody ) - with - | `Ok m -> m - | `Duplicate -> accum ) + in + match Map.add accum ~key:fdname ~data:data with + | `Ok m -> m + | `Duplicate -> accum + in + let visited' = Set.add visited fdname in + (accum', visited') in - Map.filter - ~f:(fun (_, _, v) -> v.pattern <> Skip) - (List.fold l ~init:Map.Poly.empty ~f) + let (accum, _) = List.fold l ~init:(Map.Poly.empty, Set.Poly.empty) ~f in + accum let function_inlining (mir : Program.Typed.t) = let dataonly_inline_map = From 6f312535c657687c75f802636b8d750fdfd1e817 Mon Sep 17 00:00:00 2001 From: Ryan Bernstein Date: Thu, 21 May 2020 20:35:05 -0400 Subject: [PATCH 27/27] Fixed subtle codegen assumption; added debugging flag to disable optimizations which numerically change the program the preserve_stability flag is in Optimize.ml, Partial_eval.ml, and Monotone_framework.ml. I will change this interface, but right now it's only important for debugging. It's important because we use numerical comparisons to check correctness, which are thrown off by small numerical differences. Those differences occur with partial optimizations to "composed functions", and also it turns out moving around autodiffable variables in seemingly benign ways. --- .../Monotone_framework.ml | 16 ++++++++++++---- src/analysis_and_optimization/Optimize.ml | 4 +++- .../Partial_evaluator.ml | 19 +++++++++++-------- src/stan_math_backend/Stan_math_code_gen.ml | 17 +++++++++++------ 4 files changed, 37 insertions(+), 19 deletions(-) diff --git a/src/analysis_and_optimization/Monotone_framework.ml b/src/analysis_and_optimization/Monotone_framework.ml index b60d34b8a4..e721ab72b5 100644 --- a/src/analysis_and_optimization/Monotone_framework.ml +++ b/src/analysis_and_optimization/Monotone_framework.ml @@ -5,6 +5,8 @@ open Monotone_framework_sigs open Mir_utils open Middle +let preserve_stability = false + (** Debugging tool to print out MFP sets **) let print_mfp to_string (mfp : (int, 'a entry_exit) Map.Poly.t) (flowgraph_to_mir : (int, Stmt.Located.Non_recursive.t) Map.Poly.t) : unit = let print_set s = @@ -298,9 +300,12 @@ let constant_propagation_transfer ( match mir_node with (* TODO: we are currently only propagating constants for scalars. We could do the same for matrix and array expressions if we wanted. *) - | Assignment ((s, _, []), e) -> ( + | Assignment ((s, t, []), e) -> ( match Partial_evaluator.eval_expr (subst_expr m e) with - | {pattern= Lit (_, _); _} as e' -> Map.set m ~key:s ~data:e' + | {pattern= Lit (_, _); _} as e' + when not (preserve_stability && + UnsizedType.is_autodiffable t) -> + Map.set m ~key:s ~data:e' | _ -> Map.remove m s ) | Decl {decl_id= s; _} | Assignment ((s, _, _ :: _), _) -> Map.remove m s @@ -347,9 +352,12 @@ let expression_propagation_transfer ( match mir_node with (* TODO: we are currently only propagating constants for scalars. We could do the same for matrix and array expressions if we wanted. *) - | Middle.Stmt.Fixed.Pattern.Assignment ((s, _, []), e) -> + | Middle.Stmt.Fixed.Pattern.Assignment ((s, t, []), e) -> let m' = kill_var m s in - if can_side_effect_expr e || Set.Poly.mem (free_vars_expr e) s then + if can_side_effect_expr e || + Set.Poly.mem (free_vars_expr e) s || + (preserve_stability && UnsizedType.is_autodiffable t) + then m' else Map.set m ~key:s ~data:(subst_expr m e) | Decl {decl_id= s; _} | Assignment ((s, _, _ :: _), _) -> diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml index c460a3b3be..d9a76b833c 100644 --- a/src/analysis_and_optimization/Optimize.ml +++ b/src/analysis_and_optimization/Optimize.ml @@ -4,6 +4,8 @@ open Common open Middle open Mir_utils +let preserve_stability = false + (** Apply the transformation to each function body and to the rest of the program as one block. @@ -645,7 +647,7 @@ let cannot_duplicate_expr (e : Expr.Typed.t) = | FunApp (_, f, _) -> String.suffix f 4 = "_rng" | _ -> false - ) + ) || (preserve_stability && UnsizedType.is_autodiffable e.meta.type_) in expr_any pred e let cannot_remove_expr (e : Expr.Typed.t) = diff --git a/src/analysis_and_optimization/Partial_evaluator.ml b/src/analysis_and_optimization/Partial_evaluator.ml index db85f9640f..a9d95d8eda 100644 --- a/src/analysis_and_optimization/Partial_evaluator.ml +++ b/src/analysis_and_optimization/Partial_evaluator.ml @@ -4,6 +4,8 @@ open Core_kernel open Mir_utils open Middle +let preserve_stability = false + let is_int i Expr.Fixed.({pattern; _}) = let nums = List.map ~f:(fun s -> string_of_int i ^ s) [""; "."; ".0"] in match pattern with @@ -216,7 +218,7 @@ let rec eval_expr (e : Expr.Typed.t) = , "Minus__" , [y; {pattern= FunApp (StanLib, "exp", [x]); _}] ); _ } ] ) - when is_int 1 y -> + when is_int 1 y && not preserve_stability -> FunApp (StanLib, "log1m_exp", [x]) | ( "log" , [ { pattern= @@ -225,10 +227,10 @@ let rec eval_expr (e : Expr.Typed.t) = , "Minus__" , [y; {pattern= FunApp (StanLib, "inv_logit", [x]); _}] ); _ } ] ) - when is_int 1 y -> + when is_int 1 y && not preserve_stability -> FunApp (StanLib, "log1m_inv_logit", [x]) | "log", [{pattern= FunApp (StanLib, "Minus__", [y; x]); _}] - when is_int 1 y -> + when is_int 1 y && not preserve_stability -> FunApp (StanLib, "log1m", [x]) | ( "log" , [ { pattern= @@ -237,10 +239,10 @@ let rec eval_expr (e : Expr.Typed.t) = , "Plus__" , [y; {pattern= FunApp (StanLib, "exp", [x]); _}] ); _ } ] ) - when is_int 1 y -> + when is_int 1 y && not preserve_stability -> FunApp (StanLib, "log1p_exp", [x]) | "log", [{pattern= FunApp (StanLib, "Plus__", [y; x]); _}] - when is_int 1 y -> + when is_int 1 y && not preserve_stability -> FunApp (StanLib, "log1p", [x]) | ( "log" , [ { pattern= @@ -552,11 +554,11 @@ let rec eval_expr (e : Expr.Typed.t) = when is_int 1 x -> FunApp (StanLib, "erf", l) | "Minus__", [{pattern= FunApp (StanLib, "exp", l'); _}; x] - when is_int 1 x -> + when is_int 1 x && not preserve_stability -> FunApp (StanLib, "expm1", l') | "Plus__", [{pattern= FunApp (StanLib, "Times__", [x; y]); _}; z] |"Plus__", [z; {pattern= FunApp (StanLib, "Times__", [x; y]); _}] - -> + when not preserve_stability -> FunApp (StanLib, "fma", [x; y; z]) | "Minus__", [x; {pattern= FunApp (StanLib, "gamma_p", l); _}] when is_int 1 x -> @@ -590,7 +592,8 @@ let rec eval_expr (e : Expr.Typed.t) = -> FunApp (StanLib, "matrix_exp_multiply", [a; b]) | "Times__", [x; {pattern= FunApp (StanLib, "log", [y]); _}] - |"Times__", [{pattern= FunApp (StanLib, "log", [y]); _}; x] -> + |"Times__", [{pattern= FunApp (StanLib, "log", [y]); _}; x] + when not preserve_stability -> FunApp (StanLib, "lmultiply", [x; y]) | ( "Times__" , [ {pattern= FunApp (StanLib, "diag_matrix", [v]); _} diff --git a/src/stan_math_backend/Stan_math_code_gen.ml b/src/stan_math_backend/Stan_math_code_gen.ml index 33143ad509..b0645abbbf 100644 --- a/src/stan_math_backend/Stan_math_code_gen.ml +++ b/src/stan_math_backend/Stan_math_code_gen.ml @@ -288,14 +288,19 @@ let pp_ctor ppf p = , List.filter_map ~f:get_param_st output_vars ) ) ) , p ) +let rec top_level_decls Stmt.Fixed.({pattern; _}) = + match pattern with + | Decl d -> + [Some (d.decl_id, Type.to_unsized d.decl_type, UnsizedType.DataOnly)] + | SList stmts -> + List.concat_map ~f:top_level_decls stmts + | _ -> [None] + let pp_model_private ppf {Program.prepare_data; _} = - let decl Stmt.Fixed.({pattern; _}) = - match pattern with - | Decl d -> - Some (d.decl_id, Type.to_unsized d.decl_type, UnsizedType.DataOnly) - | _ -> None + let data_decls = + List.concat_map ~f:top_level_decls prepare_data + |> List.filter_map ~f:ident in - let data_decls = List.filter_map ~f:decl prepare_data in pf ppf "%a" (list ~sep:cut pp_decl) data_decls let pp_method ppf rt name params intro ?(outro = []) ppbody =