From cc8b9e38b9371604dcca8fe8a4d988825a045f57 Mon Sep 17 00:00:00 2001 From: Tess-LaCoil Date: Wed, 3 Apr 2024 14:54:56 +1100 Subject: [PATCH] Changed test data generation and single- and multi-individual testing structures for constant model. --- src/stanExports_constant_multi_ind.h | 1188 +++++++++-------- src/stanExports_constant_single_ind.h | 932 +++++++------ src/stanExports_linear.h | 661 ++++----- .../constant_baseline_output_multi_ind.rds | Bin 18764 -> 0 bytes .../constant_baseline_output_single_ind.rds | Bin 6946 -> 0 bytes .../constant/constant_data_multi_ind.rds | Bin 805 -> 814 bytes .../constant/constant_data_single_ind.rds | Bin 463 -> 471 bytes .../fixtures/constant/make_constant.R | 64 +- .../{helper.R => helper-data_generation.R} | 10 +- tests/testthat/helper-testing.R | 72 + tests/testthat/test-rmot_models.R | 75 +- tests/testthat/test-rmot_models_constant.R | 36 + 12 files changed, 1598 insertions(+), 1440 deletions(-) delete mode 100644 tests/testthat/fixtures/constant/constant_baseline_output_multi_ind.rds delete mode 100644 tests/testthat/fixtures/constant/constant_baseline_output_single_ind.rds rename tests/testthat/{helper.R => helper-data_generation.R} (92%) create mode 100644 tests/testthat/helper-testing.R create mode 100644 tests/testthat/test-rmot_models_constant.R diff --git a/src/stanExports_constant_multi_ind.h b/src/stanExports_constant_multi_ind.h index a30c3f5..d5dede6 100644 --- a/src/stanExports_constant_multi_ind.h +++ b/src/stanExports_constant_multi_ind.h @@ -21,91 +21,144 @@ #define USE_STANC3 #endif #include -// Code generated by stanc v2.32.2 +// Code generated by stanc v2.26.1-4-gd72b68b7-dirty #include namespace model_constant_multi_ind_namespace { +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; +using stan::math::pow; stan::math::profile_map profiles__; -static constexpr std::array locations_array__ = - {" (found before start of program)", - " (in 'constant_multi_ind', line 21, column 2 to column 31)", - " (in 'constant_multi_ind', line 22, column 2 to column 32)", - " (in 'constant_multi_ind', line 23, column 2 to column 23)", - " (in 'constant_multi_ind', line 24, column 2 to column 35)", - " (in 'constant_multi_ind', line 26, column 2 to column 35)", - " (in 'constant_multi_ind', line 62, column 2 to column 20)", - " (in 'constant_multi_ind', line 63, column 2 to column 24)", - " (in 'constant_multi_ind', line 67, column 6 to column 36)", - " (in 'constant_multi_ind', line 66, column 23 to line 68, column 5)", - " (in 'constant_multi_ind', line 66, column 4 to line 68, column 5)", - " (in 'constant_multi_ind', line 70, column 4 to column 47)", - " (in 'constant_multi_ind', line 75, column 8 to column 65)", - " (in 'constant_multi_ind', line 73, column 32 to line 76, column 7)", - " (in 'constant_multi_ind', line 73, column 6 to line 76, column 7)", - " (in 'constant_multi_ind', line 72, column 17 to line 77, column 5)", - " (in 'constant_multi_ind', line 72, column 4 to line 77, column 5)", - " (in 'constant_multi_ind', line 64, column 19 to line 78, column 3)", - " (in 'constant_multi_ind', line 64, column 2 to line 78, column 3)", - " (in 'constant_multi_ind', line 30, column 13 to column 18)", - " (in 'constant_multi_ind', line 30, column 2 to column 20)", - " (in 'constant_multi_ind', line 31, column 17 to column 22)", - " (in 'constant_multi_ind', line 31, column 2 to column 24)", - " (in 'constant_multi_ind', line 35, column 6 to column 36)", - " (in 'constant_multi_ind', line 34, column 23 to line 36, column 5)", - " (in 'constant_multi_ind', line 34, column 4 to line 36, column 5)", - " (in 'constant_multi_ind', line 38, column 4 to column 47)", - " (in 'constant_multi_ind', line 43, column 8 to column 65)", - " (in 'constant_multi_ind', line 41, column 32 to line 44, column 7)", - " (in 'constant_multi_ind', line 41, column 6 to line 44, column 7)", - " (in 'constant_multi_ind', line 40, column 17 to line 45, column 5)", - " (in 'constant_multi_ind', line 40, column 4 to line 45, column 5)", - " (in 'constant_multi_ind', line 32, column 19 to line 46, column 3)", - " (in 'constant_multi_ind', line 32, column 2 to line 46, column 3)", - " (in 'constant_multi_ind', line 48, column 2 to column 44)", - " (in 'constant_multi_ind', line 51, column 2 to column 48)", - " (in 'constant_multi_ind', line 52, column 2 to line 53, column 40)", - " (in 'constant_multi_ind', line 55, column 2 to column 35)", - " (in 'constant_multi_ind', line 56, column 2 to column 37)", - " (in 'constant_multi_ind', line 58, column 2 to column 37)", - " (in 'constant_multi_ind', line 10, column 2 to column 12)", - " (in 'constant_multi_ind', line 11, column 2 to column 12)", - " (in 'constant_multi_ind', line 12, column 13 to column 18)", - " (in 'constant_multi_ind', line 12, column 2 to column 20)", - " (in 'constant_multi_ind', line 13, column 16 to column 21)", - " (in 'constant_multi_ind', line 13, column 2 to column 23)", - " (in 'constant_multi_ind', line 14, column 12 to column 17)", - " (in 'constant_multi_ind', line 14, column 2 to column 19)", - " (in 'constant_multi_ind', line 15, column 13 to column 18)", - " (in 'constant_multi_ind', line 15, column 2 to column 20)", - " (in 'constant_multi_ind', line 16, column 15 to column 20)", - " (in 'constant_multi_ind', line 16, column 2 to column 22)", - " (in 'constant_multi_ind', line 21, column 24 to column 29)", - " (in 'constant_multi_ind', line 22, column 25 to column 30)", - " (in 'constant_multi_ind', line 62, column 13 to column 18)", - " (in 'constant_multi_ind', line 63, column 17 to column 22)", - " (in 'constant_multi_ind', line 5, column 4 to column 16)", - " (in 'constant_multi_ind', line 4, column 24 to line 6, column 3)"}; -template >* = nullptr> -stan::promote_args_t growth(const T0__& beta, std::ostream* pstream__); -template >*> -stan::promote_args_t growth(const T0__& beta, std::ostream* pstream__) { +static int current_statement__= 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'constant_multi_ind', line 21, column 2 to column 31)", + " (in 'constant_multi_ind', line 22, column 2 to column 32)", + " (in 'constant_multi_ind', line 23, column 2 to column 23)", + " (in 'constant_multi_ind', line 24, column 2 to column 35)", + " (in 'constant_multi_ind', line 26, column 2 to column 35)", + " (in 'constant_multi_ind', line 62, column 2 to column 20)", + " (in 'constant_multi_ind', line 63, column 2 to column 24)", + " (in 'constant_multi_ind', line 67, column 6 to column 36)", + " (in 'constant_multi_ind', line 66, column 23 to line 68, column 5)", + " (in 'constant_multi_ind', line 66, column 4 to line 68, column 5)", + " (in 'constant_multi_ind', line 70, column 4 to column 47)", + " (in 'constant_multi_ind', line 75, column 8 to column 65)", + " (in 'constant_multi_ind', line 73, column 32 to line 76, column 7)", + " (in 'constant_multi_ind', line 73, column 6 to line 76, column 7)", + " (in 'constant_multi_ind', line 72, column 17 to line 77, column 5)", + " (in 'constant_multi_ind', line 72, column 4 to line 77, column 5)", + " (in 'constant_multi_ind', line 64, column 19 to line 78, column 3)", + " (in 'constant_multi_ind', line 64, column 2 to line 78, column 3)", + " (in 'constant_multi_ind', line 30, column 13 to column 18)", + " (in 'constant_multi_ind', line 30, column 2 to column 20)", + " (in 'constant_multi_ind', line 31, column 17 to column 22)", + " (in 'constant_multi_ind', line 31, column 2 to column 24)", + " (in 'constant_multi_ind', line 35, column 6 to column 36)", + " (in 'constant_multi_ind', line 34, column 23 to line 36, column 5)", + " (in 'constant_multi_ind', line 34, column 4 to line 36, column 5)", + " (in 'constant_multi_ind', line 38, column 4 to column 47)", + " (in 'constant_multi_ind', line 43, column 8 to column 65)", + " (in 'constant_multi_ind', line 41, column 32 to line 44, column 7)", + " (in 'constant_multi_ind', line 41, column 6 to line 44, column 7)", + " (in 'constant_multi_ind', line 40, column 17 to line 45, column 5)", + " (in 'constant_multi_ind', line 40, column 4 to line 45, column 5)", + " (in 'constant_multi_ind', line 32, column 19 to line 46, column 3)", + " (in 'constant_multi_ind', line 32, column 2 to line 46, column 3)", + " (in 'constant_multi_ind', line 48, column 2 to column 44)", + " (in 'constant_multi_ind', line 51, column 2 to column 48)", + " (in 'constant_multi_ind', line 52, column 2 to line 53, column 40)", + " (in 'constant_multi_ind', line 55, column 2 to column 35)", + " (in 'constant_multi_ind', line 56, column 2 to column 37)", + " (in 'constant_multi_ind', line 58, column 2 to column 37)", + " (in 'constant_multi_ind', line 10, column 2 to column 12)", + " (in 'constant_multi_ind', line 11, column 2 to column 12)", + " (in 'constant_multi_ind', line 12, column 13 to column 18)", + " (in 'constant_multi_ind', line 12, column 2 to column 20)", + " (in 'constant_multi_ind', line 13, column 16 to column 21)", + " (in 'constant_multi_ind', line 13, column 2 to column 23)", + " (in 'constant_multi_ind', line 14, column 12 to column 17)", + " (in 'constant_multi_ind', line 14, column 2 to column 19)", + " (in 'constant_multi_ind', line 15, column 13 to column 18)", + " (in 'constant_multi_ind', line 15, column 2 to column 20)", + " (in 'constant_multi_ind', line 16, column 15 to column 20)", + " (in 'constant_multi_ind', line 16, column 2 to column 22)", + " (in 'constant_multi_ind', line 21, column 24 to column 29)", + " (in 'constant_multi_ind', line 22, column 25 to column 30)", + " (in 'constant_multi_ind', line 62, column 13 to column 18)", + " (in 'constant_multi_ind', line 63, column 17 to column 22)", + " (in 'constant_multi_ind', line 5, column 4 to column 16)", + " (in 'constant_multi_ind', line 4, column 24 to line 6, column 3)"}; +template +stan::promote_args_t +growth(const T0__& beta, std::ostream* pstream__) { using local_scalar_t__ = stan::promote_args_t; - int current_statement__ = 0; - static constexpr bool propto__ = true; - // suppress unused var warning + const static bool propto__ = true; (void) propto__; local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - // suppress unused var warning - (void) DUMMY_VAR__; + (void) DUMMY_VAR__; // suppress unused var warning + try { current_statement__ = 56; return beta; } 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 growth_functor__ { +template +stan::promote_args_t +operator()(const T0__& beta, std::ostream* pstream__) const +{ +return growth(beta, pstream__); } +}; #include class model_constant_multi_ind final : public model_base_crtp { private: @@ -116,622 +169,657 @@ class model_constant_multi_ind final : public model_base_crtp time; std::vector ind_id; std::vector y_0_obs; + public: - ~model_constant_multi_ind() {} - model_constant_multi_ind(stan::io::var_context& context__, unsigned int - random_seed__ = 0, std::ostream* - pstream__ = nullptr) : model_base_crtp(0) { - int current_statement__ = 0; - using local_scalar_t__ = double; - boost::ecuyer1988 base_rng__ = - stan::services::util::create_rng(random_seed__, 0); - // suppress unused var warning - (void) base_rng__; - static constexpr const char* function__ = - "model_constant_multi_ind_namespace::model_constant_multi_ind"; - // suppress unused var warning - (void) function__; + ~model_constant_multi_ind() { } + + inline std::string model_name() const final { return "model_constant_multi_ind"; } + inline std::vector model_compile_info() const noexcept { + return std::vector{"stanc_version = stanc3 v2.26.1-4-gd72b68b7-dirty", "stancflags = "}; + } + + + model_constant_multi_ind(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + using local_scalar_t__ = double ; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "model_constant_multi_ind_namespace::model_constant_multi_ind"; + (void) function__; // suppress unused var warning local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - // suppress unused var warning - (void) DUMMY_VAR__; + (void) DUMMY_VAR__; // suppress unused var warning + try { - int pos__ = std::numeric_limits::min(); + int pos__; + pos__ = std::numeric_limits::min(); + pos__ = 1; current_statement__ = 40; - context__.validate_dims("data initialization", "n_obs", "int", - std::vector{}); + context__.validate_dims("data initialization","n_obs","int", + context__.to_vec()); n_obs = std::numeric_limits::min(); + current_statement__ = 40; n_obs = context__.vals_i("n_obs")[(1 - 1)]; current_statement__ = 41; - context__.validate_dims("data initialization", "n_ind", "int", - std::vector{}); + context__.validate_dims("data initialization","n_ind","int", + context__.to_vec()); n_ind = std::numeric_limits::min(); + current_statement__ = 41; n_ind = context__.vals_i("n_ind")[(1 - 1)]; current_statement__ = 42; - stan::math::validate_non_negative_index("y_obs", "n_obs", n_obs); + validate_non_negative_index("y_obs", "n_obs", n_obs); current_statement__ = 43; - context__.validate_dims("data initialization", "y_obs", "double", - std::vector{static_cast(n_obs)}); - y_obs = std::vector(n_obs, - std::numeric_limits::quiet_NaN()); + context__.validate_dims("data initialization","y_obs","double", + context__.to_vec(n_obs)); + y_obs = std::vector(n_obs, std::numeric_limits::quiet_NaN()); + current_statement__ = 43; - y_obs = context__.vals_r("y_obs"); + assign(y_obs, nil_index_list(), context__.vals_r("y_obs"), + "assigning variable y_obs"); current_statement__ = 44; - stan::math::validate_non_negative_index("obs_index", "n_obs", n_obs); + validate_non_negative_index("obs_index", "n_obs", n_obs); current_statement__ = 45; - context__.validate_dims("data initialization", "obs_index", "int", - std::vector{static_cast(n_obs)}); + context__.validate_dims("data initialization","obs_index","int", + context__.to_vec(n_obs)); obs_index = std::vector(n_obs, std::numeric_limits::min()); + current_statement__ = 45; - obs_index = context__.vals_i("obs_index"); + assign(obs_index, nil_index_list(), context__.vals_i("obs_index"), + "assigning variable obs_index"); current_statement__ = 46; - stan::math::validate_non_negative_index("time", "n_obs", n_obs); + validate_non_negative_index("time", "n_obs", n_obs); current_statement__ = 47; - context__.validate_dims("data initialization", "time", "double", - std::vector{static_cast(n_obs)}); - time = std::vector(n_obs, - std::numeric_limits::quiet_NaN()); + context__.validate_dims("data initialization","time","double", + context__.to_vec(n_obs)); + time = std::vector(n_obs, std::numeric_limits::quiet_NaN()); + current_statement__ = 47; - time = context__.vals_r("time"); + assign(time, nil_index_list(), context__.vals_r("time"), + "assigning variable time"); current_statement__ = 48; - stan::math::validate_non_negative_index("ind_id", "n_obs", n_obs); + validate_non_negative_index("ind_id", "n_obs", n_obs); current_statement__ = 49; - context__.validate_dims("data initialization", "ind_id", "int", - std::vector{static_cast(n_obs)}); + context__.validate_dims("data initialization","ind_id","int", + context__.to_vec(n_obs)); ind_id = std::vector(n_obs, std::numeric_limits::min()); + current_statement__ = 49; - ind_id = context__.vals_i("ind_id"); + assign(ind_id, nil_index_list(), context__.vals_i("ind_id"), + "assigning variable ind_id"); current_statement__ = 50; - stan::math::validate_non_negative_index("y_0_obs", "n_ind", n_ind); + validate_non_negative_index("y_0_obs", "n_ind", n_ind); current_statement__ = 51; - context__.validate_dims("data initialization", "y_0_obs", "double", - std::vector{static_cast(n_ind)}); - y_0_obs = std::vector(n_ind, - std::numeric_limits::quiet_NaN()); + context__.validate_dims("data initialization","y_0_obs","double", + context__.to_vec(n_ind)); + y_0_obs = std::vector(n_ind, std::numeric_limits::quiet_NaN()); + current_statement__ = 51; - y_0_obs = context__.vals_r("y_0_obs"); + assign(y_0_obs, nil_index_list(), context__.vals_r("y_0_obs"), + "assigning variable y_0_obs"); current_statement__ = 52; - stan::math::validate_non_negative_index("ind_y_0", "n_ind", n_ind); + validate_non_negative_index("ind_y_0", "n_ind", n_ind); current_statement__ = 53; - stan::math::validate_non_negative_index("ind_beta", "n_ind", n_ind); + validate_non_negative_index("ind_beta", "n_ind", n_ind); current_statement__ = 54; - stan::math::validate_non_negative_index("y_hat", "n_obs", n_obs); + validate_non_negative_index("y_hat", "n_obs", n_obs); current_statement__ = 55; - stan::math::validate_non_negative_index("Delta_hat", "n_obs", n_obs); + validate_non_negative_index("Delta_hat", "n_obs", n_obs); } 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__ += n_ind; + num_params_r__ += n_ind; + 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 ***"); } - num_params_r__ = n_ind + n_ind + 1 + 1 + 1; - } - inline std::string model_name() const final { - return "model_constant_multi_ind"; - } - inline std::vector model_compile_info() const noexcept { - return std::vector{"stanc_version = stanc3 v2.32.2", - "stancflags = --allow-undefined"}; } - template * = nullptr, - stan::require_vector_like_vt* = nullptr> - inline stan::scalar_type_t - log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream* - pstream__ = nullptr) const { + template * = nullptr, stan::require_vector_like_vt* = nullptr> + inline stan::scalar_type_t log_prob_impl(VecR& params_r__, + VecI& params_i__, + std::ostream* pstream__ = nullptr) const { using T__ = stan::scalar_type_t; using local_scalar_t__ = T__; T__ lp__(0.0); stan::math::accumulator lp_accum__; - stan::io::deserializer in__(params_r__, params_i__); - int current_statement__ = 0; + static const char* function__ = "model_constant_multi_ind_namespace::log_prob"; +(void) function__; // suppress unused var warning + stan::io::reader in__(params_r__, params_i__); local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - // suppress unused var warning - (void) DUMMY_VAR__; - static constexpr const char* function__ = - "model_constant_multi_ind_namespace::log_prob"; - // suppress unused var warning - (void) function__; + (void) DUMMY_VAR__; // suppress unused var warning + try { - std::vector ind_y_0 = - std::vector(n_ind, DUMMY_VAR__); + std::vector ind_y_0; + ind_y_0 = std::vector(n_ind, DUMMY_VAR__); + + current_statement__ = 1; + for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { + current_statement__ = 1; + assign(ind_y_0, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable ind_y_0");} current_statement__ = 1; - ind_y_0 = in__.template read_constrain_lb< - std::vector, jacobian__>(0, lp__, n_ind); - std::vector ind_beta = - std::vector(n_ind, DUMMY_VAR__); + for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { + current_statement__ = 1; + if (jacobian__) { + current_statement__ = 1; + assign(ind_y_0, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(ind_y_0[(sym1__ - 1)], 0, lp__), + "assigning variable ind_y_0"); + } else { + current_statement__ = 1; + assign(ind_y_0, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(ind_y_0[(sym1__ - 1)], 0), + "assigning variable ind_y_0"); + }} + std::vector ind_beta; + ind_beta = std::vector(n_ind, DUMMY_VAR__); + current_statement__ = 2; - ind_beta = in__.template read_constrain_lb< - std::vector, jacobian__>(0, lp__, n_ind); - local_scalar_t__ species_beta_mu = DUMMY_VAR__; + for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { + current_statement__ = 2; + assign(ind_beta, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable ind_beta");} + current_statement__ = 2; + for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + assign(ind_beta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(ind_beta[(sym1__ - 1)], 0, lp__), + "assigning variable ind_beta"); + } else { + current_statement__ = 2; + assign(ind_beta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(ind_beta[(sym1__ - 1)], 0), + "assigning variable ind_beta"); + }} + local_scalar_t__ species_beta_mu; + species_beta_mu = DUMMY_VAR__; + current_statement__ = 3; - species_beta_mu = in__.template read(); - local_scalar_t__ species_beta_sigma = DUMMY_VAR__; + species_beta_mu = in__.scalar(); + local_scalar_t__ species_beta_sigma; + species_beta_sigma = DUMMY_VAR__; + + current_statement__ = 4; + species_beta_sigma = in__.scalar(); current_statement__ = 4; - species_beta_sigma = in__.template read_constrain_lb(0, lp__); - local_scalar_t__ global_error_sigma = DUMMY_VAR__; + if (jacobian__) { + current_statement__ = 4; + species_beta_sigma = stan::math::lb_constrain(species_beta_sigma, 0, + lp__); + } else { + current_statement__ = 4; + species_beta_sigma = stan::math::lb_constrain(species_beta_sigma, 0); + } + local_scalar_t__ global_error_sigma; + global_error_sigma = DUMMY_VAR__; + current_statement__ = 5; - global_error_sigma = in__.template read_constrain_lb(0, lp__); + global_error_sigma = in__.scalar(); + current_statement__ = 5; + if (jacobian__) { + current_statement__ = 5; + global_error_sigma = stan::math::lb_constrain(global_error_sigma, 0, + lp__); + } else { + current_statement__ = 5; + global_error_sigma = stan::math::lb_constrain(global_error_sigma, 0); + } { current_statement__ = 19; - stan::math::validate_non_negative_index("y_hat", "n_obs", n_obs); - std::vector y_hat = - std::vector(n_obs, DUMMY_VAR__); + validate_non_negative_index("y_hat", "n_obs", n_obs); + std::vector y_hat; + y_hat = std::vector(n_obs, DUMMY_VAR__); + current_statement__ = 21; - stan::math::validate_non_negative_index("Delta_hat", "n_obs", n_obs); - std::vector Delta_hat = - std::vector(n_obs, DUMMY_VAR__); + validate_non_negative_index("Delta_hat", "n_obs", n_obs); + std::vector Delta_hat; + Delta_hat = std::vector(n_obs, DUMMY_VAR__); + current_statement__ = 33; for (int i = 1; i <= n_obs; ++i) { current_statement__ = 25; - if (stan::math::logical_eq( - stan::model::rvalue(obs_index, "obs_index", - stan::model::index_uni(i)), 1)) { + if (logical_eq(obs_index[(i - 1)], 1)) { current_statement__ = 23; - stan::model::assign(y_hat, - stan::model::rvalue(ind_y_0, "ind_y_0", - stan::model::index_uni( - stan::model::rvalue(ind_id, "ind_id", - stan::model::index_uni(i)))), "assigning variable y_hat", - stan::model::index_uni(i)); - } + assign(y_hat, cons_list(index_uni(i), nil_index_list()), + ind_y_0[(ind_id[(i - 1)] - 1)], "assigning variable y_hat"); + } current_statement__ = 26; - stan::model::assign(Delta_hat, - growth( - stan::model::rvalue(ind_beta, "ind_beta", - stan::model::index_uni( - stan::model::rvalue(ind_id, "ind_id", - stan::model::index_uni(i)))), pstream__), - "assigning variable Delta_hat", stan::model::index_uni(i)); + assign(Delta_hat, cons_list(index_uni(i), nil_index_list()), + growth(ind_beta[(ind_id[(i - 1)] - 1)], pstream__), + "assigning variable Delta_hat"); current_statement__ = 31; - if (stan::math::logical_lt(i, n_obs)) { + if (logical_lt(i, n_obs)) { current_statement__ = 29; - if (stan::math::logical_eq( - stan::model::rvalue(ind_id, "ind_id", - stan::model::index_uni((i + 1))), - stan::model::rvalue(ind_id, "ind_id", - stan::model::index_uni(i)))) { + if (logical_eq(ind_id[((i + 1) - 1)], ind_id[(i - 1)])) { current_statement__ = 27; - stan::model::assign(y_hat, - (stan::model::rvalue(y_hat, "y_hat", - stan::model::index_uni(i)) + - (stan::model::rvalue(Delta_hat, "Delta_hat", - stan::model::index_uni(i)) * - (stan::model::rvalue(time, "time", - stan::model::index_uni((i + 1))) - - stan::model::rvalue(time, "time", stan::model::index_uni(i))))), - "assigning variable y_hat", stan::model::index_uni((i + 1))); - } - } - } + assign(y_hat, cons_list(index_uni((i + 1)), nil_index_list()), + (y_hat[(i - 1)] + + (Delta_hat[(i - 1)] * + (time[((i + 1) - 1)] - time[(i - 1)]))), + "assigning variable y_hat"); + } + } } current_statement__ = 34; - lp_accum__.add(stan::math::normal_lpdf(y_obs, y_hat, - global_error_sigma)); + lp_accum__.add( + normal_lpdf(y_obs, y_hat, global_error_sigma)); current_statement__ = 35; - lp_accum__.add(stan::math::normal_lpdf(ind_y_0, y_0_obs, - global_error_sigma)); + lp_accum__.add( + normal_lpdf(ind_y_0, y_0_obs, global_error_sigma)); current_statement__ = 36; - lp_accum__.add(stan::math::lognormal_lpdf(ind_beta, - species_beta_mu, species_beta_sigma)); + lp_accum__.add( + lognormal_lpdf(ind_beta, species_beta_mu, + species_beta_sigma)); current_statement__ = 37; - lp_accum__.add(stan::math::normal_lpdf(species_beta_mu, - 0.1, 1)); + lp_accum__.add(normal_lpdf(species_beta_mu, 0.1, 1)); current_statement__ = 38; - lp_accum__.add(stan::math::cauchy_lpdf(species_beta_sigma, - 0.1, 1)); + lp_accum__.add(cauchy_lpdf(species_beta_sigma, 0.1, 1)); current_statement__ = 39; - lp_accum__.add(stan::math::cauchy_lpdf(global_error_sigma, - 0.1, 1)); + lp_accum__.add(cauchy_lpdf(global_error_sigma, 0.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(); - } - template * = nullptr, stan::require_vector_like_vt* = nullptr, stan::require_vector_vt* = nullptr> - inline void - write_array_impl(RNG& base_rng__, VecR& params_r__, VecI& params_i__, - VecVar& vars__, const bool - emit_transformed_parameters__ = true, const bool - emit_generated_quantities__ = true, std::ostream* - pstream__ = nullptr) const { + } // log_prob_impl() + + template * = nullptr, stan::require_vector_like_vt* = nullptr, stan::require_std_vector_vt* = nullptr> + inline void write_array_impl(RNG& base_rng__, VecR& params_r__, + VecI& params_i__, VecVar& vars__, + const bool emit_transformed_parameters__ = true, + const bool emit_generated_quantities__ = true, + std::ostream* pstream__ = nullptr) const { using local_scalar_t__ = double; - stan::io::deserializer in__(params_r__, params_i__); - stan::io::serializer out__(vars__); - static constexpr bool propto__ = true; - // suppress unused var warning - (void) propto__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "model_constant_multi_ind_namespace::write_array"; +(void) function__; // suppress unused var warning + (void) function__; // suppress unused var warning double lp__ = 0.0; - // suppress unused var warning - (void) lp__; - int current_statement__ = 0; + (void) lp__; // dummy to suppress unused var warning stan::math::accumulator lp_accum__; local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - // suppress unused var warning - (void) DUMMY_VAR__; - constexpr bool jacobian__ = false; - static constexpr const char* function__ = - "model_constant_multi_ind_namespace::write_array"; - // suppress unused var warning - (void) function__; + (void) DUMMY_VAR__; // suppress unused var warning + try { - std::vector ind_y_0 = - std::vector(n_ind, std::numeric_limits::quiet_NaN()); + std::vector ind_y_0; + ind_y_0 = std::vector(n_ind, std::numeric_limits::quiet_NaN()); + current_statement__ = 1; - ind_y_0 = in__.template read_constrain_lb< - std::vector, jacobian__>(0, lp__, n_ind); - std::vector ind_beta = - std::vector(n_ind, std::numeric_limits::quiet_NaN()); + for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { + current_statement__ = 1; + assign(ind_y_0, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable ind_y_0");} + current_statement__ = 1; + for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { + current_statement__ = 1; + assign(ind_y_0, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(ind_y_0[(sym1__ - 1)], 0), + "assigning variable ind_y_0");} + std::vector ind_beta; + ind_beta = std::vector(n_ind, std::numeric_limits::quiet_NaN()); + + current_statement__ = 2; + for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { + current_statement__ = 2; + assign(ind_beta, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable ind_beta");} current_statement__ = 2; - ind_beta = in__.template read_constrain_lb< - std::vector, jacobian__>(0, lp__, n_ind); - double species_beta_mu = std::numeric_limits::quiet_NaN(); + for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { + current_statement__ = 2; + assign(ind_beta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(ind_beta[(sym1__ - 1)], 0), + "assigning variable ind_beta");} + double species_beta_mu; + species_beta_mu = std::numeric_limits::quiet_NaN(); + current_statement__ = 3; - species_beta_mu = in__.template read(); - double species_beta_sigma = std::numeric_limits::quiet_NaN(); + species_beta_mu = in__.scalar(); + double species_beta_sigma; + species_beta_sigma = std::numeric_limits::quiet_NaN(); + + current_statement__ = 4; + species_beta_sigma = in__.scalar(); current_statement__ = 4; - species_beta_sigma = in__.template read_constrain_lb(0, lp__); - double global_error_sigma = std::numeric_limits::quiet_NaN(); + species_beta_sigma = stan::math::lb_constrain(species_beta_sigma, 0); + double global_error_sigma; + global_error_sigma = std::numeric_limits::quiet_NaN(); + current_statement__ = 5; - global_error_sigma = in__.template read_constrain_lb(0, lp__); - out__.write(ind_y_0); - out__.write(ind_beta); - out__.write(species_beta_mu); - out__.write(species_beta_sigma); - out__.write(global_error_sigma); - if (stan::math::logical_negation( - (stan::math::primitive_value(emit_transformed_parameters__) || - stan::math::primitive_value(emit_generated_quantities__)))) { + global_error_sigma = in__.scalar(); + current_statement__ = 5; + global_error_sigma = stan::math::lb_constrain(global_error_sigma, 0); + for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { + vars__.emplace_back(ind_y_0[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { + vars__.emplace_back(ind_beta[(sym1__ - 1)]);} + vars__.emplace_back(species_beta_mu); + vars__.emplace_back(species_beta_sigma); + vars__.emplace_back(global_error_sigma); + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { return ; - } - if (stan::math::logical_negation(emit_generated_quantities__)) { + } + if (logical_negation(emit_generated_quantities__)) { return ; - } - std::vector y_hat = - std::vector(n_obs, std::numeric_limits::quiet_NaN()); - std::vector Delta_hat = - std::vector(n_obs, std::numeric_limits::quiet_NaN()); + } + std::vector y_hat; + y_hat = std::vector(n_obs, std::numeric_limits::quiet_NaN()); + + std::vector Delta_hat; + Delta_hat = std::vector(n_obs, std::numeric_limits::quiet_NaN()); + current_statement__ = 18; for (int i = 1; i <= n_obs; ++i) { current_statement__ = 10; - if (stan::math::logical_eq( - stan::model::rvalue(obs_index, "obs_index", - stan::model::index_uni(i)), 1)) { + if (logical_eq(obs_index[(i - 1)], 1)) { current_statement__ = 8; - stan::model::assign(y_hat, - stan::model::rvalue(ind_y_0, "ind_y_0", - stan::model::index_uni( - stan::model::rvalue(ind_id, "ind_id", - stan::model::index_uni(i)))), "assigning variable y_hat", - stan::model::index_uni(i)); - } + assign(y_hat, cons_list(index_uni(i), nil_index_list()), + ind_y_0[(ind_id[(i - 1)] - 1)], "assigning variable y_hat"); + } current_statement__ = 11; - stan::model::assign(Delta_hat, - growth( - stan::model::rvalue(ind_beta, "ind_beta", - stan::model::index_uni( - stan::model::rvalue(ind_id, "ind_id", - stan::model::index_uni(i)))), pstream__), - "assigning variable Delta_hat", stan::model::index_uni(i)); + assign(Delta_hat, cons_list(index_uni(i), nil_index_list()), + growth(ind_beta[(ind_id[(i - 1)] - 1)], pstream__), + "assigning variable Delta_hat"); current_statement__ = 16; - if (stan::math::logical_lt(i, n_obs)) { + if (logical_lt(i, n_obs)) { current_statement__ = 14; - if (stan::math::logical_eq( - stan::model::rvalue(ind_id, "ind_id", - stan::model::index_uni((i + 1))), - stan::model::rvalue(ind_id, "ind_id", - stan::model::index_uni(i)))) { + if (logical_eq(ind_id[((i + 1) - 1)], ind_id[(i - 1)])) { current_statement__ = 12; - stan::model::assign(y_hat, - (stan::model::rvalue(y_hat, "y_hat", stan::model::index_uni(i)) - + - (stan::model::rvalue(Delta_hat, "Delta_hat", - stan::model::index_uni(i)) * - (stan::model::rvalue(time, "time", - stan::model::index_uni((i + 1))) - - stan::model::rvalue(time, "time", stan::model::index_uni(i))))), - "assigning variable y_hat", stan::model::index_uni((i + 1))); - } - } - } - out__.write(y_hat); - out__.write(Delta_hat); + assign(y_hat, cons_list(index_uni((i + 1)), nil_index_list()), + (y_hat[(i - 1)] + + (Delta_hat[(i - 1)] * (time[((i + 1) - 1)] - time[(i - 1)]))), + "assigning variable y_hat"); + } + } } + for (int sym1__ = 1; sym1__ <= n_obs; ++sym1__) { + vars__.emplace_back(y_hat[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= n_obs; ++sym1__) { + vars__.emplace_back(Delta_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 ***"); } - } - template * = nullptr, - stan::require_vector_like_vt* = nullptr> - inline void - unconstrain_array_impl(const VecVar& params_r__, const VecI& params_i__, - VecVar& vars__, std::ostream* pstream__ = nullptr) const { + } // write_array_impl() + + template * = nullptr, stan::require_vector_like_vt* = nullptr> + inline void transform_inits_impl(const stan::io::var_context& context__, + VecI& params_i__, VecVar& vars__, + std::ostream* pstream__ = nullptr) const { using local_scalar_t__ = double; - stan::io::deserializer in__(params_r__, params_i__); - stan::io::serializer out__(vars__); - int current_statement__ = 0; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - // suppress unused var warning - (void) DUMMY_VAR__; + vars__.clear(); + vars__.reserve(num_params_r__); + try { - int pos__ = std::numeric_limits::min(); + int pos__; + pos__ = std::numeric_limits::min(); + pos__ = 1; - std::vector ind_y_0 = - std::vector(n_ind, DUMMY_VAR__); + std::vector ind_y_0; + ind_y_0 = std::vector(n_ind, std::numeric_limits::quiet_NaN()); + current_statement__ = 1; - stan::model::assign(ind_y_0, - in__.read>(n_ind), + assign(ind_y_0, nil_index_list(), context__.vals_r("ind_y_0"), "assigning variable ind_y_0"); - out__.write_free_lb(0, ind_y_0); - std::vector ind_beta = - std::vector(n_ind, DUMMY_VAR__); - current_statement__ = 2; - stan::model::assign(ind_beta, - in__.read>(n_ind), - "assigning variable ind_beta"); - out__.write_free_lb(0, ind_beta); - local_scalar_t__ species_beta_mu = DUMMY_VAR__; - current_statement__ = 3; - species_beta_mu = in__.read(); - out__.write(species_beta_mu); - local_scalar_t__ species_beta_sigma = DUMMY_VAR__; - current_statement__ = 4; - species_beta_sigma = in__.read(); - out__.write_free_lb(0, species_beta_sigma); - local_scalar_t__ global_error_sigma = DUMMY_VAR__; - current_statement__ = 5; - global_error_sigma = in__.read(); - out__.write_free_lb(0, global_error_sigma); - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, locations_array__[current_statement__]); - } - } - template * = nullptr> - inline void - transform_inits_impl(const stan::io::var_context& context__, VecVar& - vars__, std::ostream* pstream__ = nullptr) const { - using local_scalar_t__ = double; - stan::io::serializer out__(vars__); - int current_statement__ = 0; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - // suppress unused var warning - (void) DUMMY_VAR__; - try { + std::vector ind_y_0_free__; + ind_y_0_free__ = std::vector(n_ind, std::numeric_limits::quiet_NaN()); + current_statement__ = 1; - context__.validate_dims("parameter initialization", "ind_y_0", - "double", std::vector{static_cast(n_ind)}); + for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { + current_statement__ = 1; + assign(ind_y_0_free__, + cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_free(ind_y_0[(sym1__ - 1)], 0), + "assigning variable ind_y_0_free__");} + std::vector ind_beta; + ind_beta = std::vector(n_ind, std::numeric_limits::quiet_NaN()); + current_statement__ = 2; - context__.validate_dims("parameter initialization", "ind_beta", - "double", std::vector{static_cast(n_ind)}); - current_statement__ = 3; - context__.validate_dims("parameter initialization", "species_beta_mu", - "double", std::vector{}); - current_statement__ = 4; - context__.validate_dims("parameter initialization", - "species_beta_sigma", "double", std::vector{}); - current_statement__ = 5; - context__.validate_dims("parameter initialization", - "global_error_sigma", "double", std::vector{}); - int pos__ = std::numeric_limits::min(); - pos__ = 1; - std::vector ind_y_0 = - std::vector(n_ind, DUMMY_VAR__); - current_statement__ = 1; - ind_y_0 = context__.vals_r("ind_y_0"); - out__.write_free_lb(0, ind_y_0); - std::vector ind_beta = - std::vector(n_ind, DUMMY_VAR__); + assign(ind_beta, nil_index_list(), context__.vals_r("ind_beta"), + "assigning variable ind_beta"); + std::vector ind_beta_free__; + ind_beta_free__ = std::vector(n_ind, std::numeric_limits::quiet_NaN()); + current_statement__ = 2; - ind_beta = context__.vals_r("ind_beta"); - out__.write_free_lb(0, ind_beta); - local_scalar_t__ species_beta_mu = DUMMY_VAR__; + for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { + current_statement__ = 2; + assign(ind_beta_free__, + cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_free(ind_beta[(sym1__ - 1)], 0), + "assigning variable ind_beta_free__");} + double species_beta_mu; + species_beta_mu = std::numeric_limits::quiet_NaN(); + current_statement__ = 3; species_beta_mu = context__.vals_r("species_beta_mu")[(1 - 1)]; - out__.write(species_beta_mu); - local_scalar_t__ species_beta_sigma = DUMMY_VAR__; + double species_beta_sigma; + species_beta_sigma = std::numeric_limits::quiet_NaN(); + current_statement__ = 4; species_beta_sigma = context__.vals_r("species_beta_sigma")[(1 - 1)]; - out__.write_free_lb(0, species_beta_sigma); - local_scalar_t__ global_error_sigma = DUMMY_VAR__; + double species_beta_sigma_free__; + species_beta_sigma_free__ = std::numeric_limits::quiet_NaN(); + + current_statement__ = 4; + species_beta_sigma_free__ = stan::math::lb_free(species_beta_sigma, 0); + double global_error_sigma; + global_error_sigma = std::numeric_limits::quiet_NaN(); + current_statement__ = 5; global_error_sigma = context__.vals_r("global_error_sigma")[(1 - 1)]; - out__.write_free_lb(0, global_error_sigma); + double global_error_sigma_free__; + global_error_sigma_free__ = std::numeric_limits::quiet_NaN(); + + current_statement__ = 5; + global_error_sigma_free__ = stan::math::lb_free(global_error_sigma, 0); + for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { + vars__.emplace_back(ind_y_0_free__[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { + vars__.emplace_back(ind_beta_free__[(sym1__ - 1)]);} + vars__.emplace_back(species_beta_mu); + vars__.emplace_back(species_beta_sigma_free__); + vars__.emplace_back(global_error_sigma_free__); } 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 ***"); } - } - inline void - get_param_names(std::vector& names__, const bool - emit_transformed_parameters__ = true, const bool - emit_generated_quantities__ = true) const { - names__ = std::vector{"ind_y_0", "ind_beta", - "species_beta_mu", "species_beta_sigma", - "global_error_sigma"}; - if (emit_transformed_parameters__) {} - if (emit_generated_quantities__) { - std::vector temp{"y_hat", "Delta_hat"}; - names__.reserve(names__.size() + temp.size()); - names__.insert(names__.end(), temp.begin(), temp.end()); - } - } - inline void - get_dims(std::vector>& dimss__, const bool - emit_transformed_parameters__ = true, const bool - emit_generated_quantities__ = true) const { - dimss__ = std::vector>{std::vector{static_cast< - size_t>( - n_ind)}, - std::vector{static_cast(n_ind)}, - std::vector{}, std::vector{}, - std::vector{}}; - if (emit_transformed_parameters__) {} - if (emit_generated_quantities__) { - std::vector> - temp{std::vector{static_cast(n_obs)}, - std::vector{static_cast(n_obs)}}; - dimss__.reserve(dimss__.size() + temp.size()); - dimss__.insert(dimss__.end(), temp.begin(), temp.end()); - } - } - inline void - constrained_param_names(std::vector& param_names__, bool - emit_transformed_parameters__ = true, bool - emit_generated_quantities__ = true) const final { + } // transform_inits_impl() + + inline void get_param_names(std::vector& names__) const { + + names__.clear(); + names__.emplace_back("ind_y_0"); + names__.emplace_back("ind_beta"); + names__.emplace_back("species_beta_mu"); + names__.emplace_back("species_beta_sigma"); + names__.emplace_back("global_error_sigma"); + names__.emplace_back("y_hat"); + names__.emplace_back("Delta_hat"); + } // get_param_names() + + inline void get_dims(std::vector>& dimss__) const { + dimss__.clear(); + dimss__.emplace_back(std::vector{static_cast(n_ind)}); + + dimss__.emplace_back(std::vector{static_cast(n_ind)}); + + dimss__.emplace_back(std::vector{}); + + dimss__.emplace_back(std::vector{}); + + dimss__.emplace_back(std::vector{}); + + dimss__.emplace_back(std::vector{static_cast(n_obs)}); + + dimss__.emplace_back(std::vector{static_cast(n_obs)}); + + } // get_dims() + + inline void constrained_param_names( + std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const + final { + for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { - param_names__.emplace_back(std::string() + "ind_y_0" + '.' + - std::to_string(sym1__)); - } + { + param_names__.emplace_back(std::string() + "ind_y_0" + '.' + std::to_string(sym1__)); + }} for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { - param_names__.emplace_back(std::string() + "ind_beta" + '.' + - std::to_string(sym1__)); - } + { + param_names__.emplace_back(std::string() + "ind_beta" + '.' + std::to_string(sym1__)); + }} param_names__.emplace_back(std::string() + "species_beta_mu"); param_names__.emplace_back(std::string() + "species_beta_sigma"); param_names__.emplace_back(std::string() + "global_error_sigma"); - if (emit_transformed_parameters__) {} + if (emit_transformed_parameters__) { + + } + if (emit_generated_quantities__) { for (int sym1__ = 1; sym1__ <= n_obs; ++sym1__) { - param_names__.emplace_back(std::string() + "y_hat" + '.' + - std::to_string(sym1__)); - } + { + param_names__.emplace_back(std::string() + "y_hat" + '.' + std::to_string(sym1__)); + }} for (int sym1__ = 1; sym1__ <= n_obs; ++sym1__) { - param_names__.emplace_back(std::string() + "Delta_hat" + '.' + - std::to_string(sym1__)); - } + { + param_names__.emplace_back(std::string() + "Delta_hat" + '.' + std::to_string(sym1__)); + }} } - } - inline void - unconstrained_param_names(std::vector& param_names__, bool - emit_transformed_parameters__ = true, bool - emit_generated_quantities__ = true) const final { + + } // constrained_param_names() + + inline void unconstrained_param_names( + std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const + final { + for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { - param_names__.emplace_back(std::string() + "ind_y_0" + '.' + - std::to_string(sym1__)); - } + { + param_names__.emplace_back(std::string() + "ind_y_0" + '.' + std::to_string(sym1__)); + }} for (int sym1__ = 1; sym1__ <= n_ind; ++sym1__) { - param_names__.emplace_back(std::string() + "ind_beta" + '.' + - std::to_string(sym1__)); - } + { + param_names__.emplace_back(std::string() + "ind_beta" + '.' + std::to_string(sym1__)); + }} param_names__.emplace_back(std::string() + "species_beta_mu"); param_names__.emplace_back(std::string() + "species_beta_sigma"); param_names__.emplace_back(std::string() + "global_error_sigma"); - if (emit_transformed_parameters__) {} + if (emit_transformed_parameters__) { + + } + if (emit_generated_quantities__) { for (int sym1__ = 1; sym1__ <= n_obs; ++sym1__) { - param_names__.emplace_back(std::string() + "y_hat" + '.' + - std::to_string(sym1__)); - } + { + param_names__.emplace_back(std::string() + "y_hat" + '.' + std::to_string(sym1__)); + }} for (int sym1__ = 1; sym1__ <= n_obs; ++sym1__) { - param_names__.emplace_back(std::string() + "Delta_hat" + '.' + - std::to_string(sym1__)); - } + { + param_names__.emplace_back(std::string() + "Delta_hat" + '.' + std::to_string(sym1__)); + }} } - } + + } // unconstrained_param_names() + inline std::string get_constrained_sizedtypes() const { - return std::string("[{\"name\":\"ind_y_0\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(n_ind) + ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"ind_beta\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(n_ind) + ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"species_beta_mu\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"species_beta_sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"global_error_sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(n_obs) + ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"},{\"name\":\"Delta_hat\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(n_obs) + ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"}]"); - } + stringstream s__; + s__ << "[{\"name\":\"ind_y_0\",\"type\":{\"name\":\"array\",\"length\":" << n_ind << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"ind_beta\",\"type\":{\"name\":\"array\",\"length\":" << n_ind << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"species_beta_mu\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"species_beta_sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"global_error_sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"array\",\"length\":" << n_obs << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"},{\"name\":\"Delta_hat\",\"type\":{\"name\":\"array\",\"length\":" << n_obs << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + inline std::string get_unconstrained_sizedtypes() const { - return std::string("[{\"name\":\"ind_y_0\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(n_ind) + ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"ind_beta\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(n_ind) + ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"species_beta_mu\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"species_beta_sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"global_error_sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(n_obs) + ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"},{\"name\":\"Delta_hat\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(n_obs) + ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"}]"); - } - // Begin method overload boilerplate - template inline void - write_array(RNG& base_rng, Eigen::Matrix& params_r, - Eigen::Matrix& vars, const bool - emit_transformed_parameters = true, const bool - emit_generated_quantities = true, std::ostream* - pstream = nullptr) const { - const size_t num_params__ = ((((n_ind + n_ind) + 1) + 1) + 1); - const size_t num_transformed = emit_transformed_parameters * (0); - const size_t num_gen_quantities = emit_generated_quantities * ((n_obs + - n_obs)); - const size_t num_to_write = num_params__ + num_transformed + - num_gen_quantities; - std::vector params_i; - vars = Eigen::Matrix::Constant(num_to_write, - std::numeric_limits::quiet_NaN()); - write_array_impl(base_rng, params_r, params_i, vars, - emit_transformed_parameters, emit_generated_quantities, pstream); - } - template inline 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 = nullptr) const { - const size_t num_params__ = ((((n_ind + n_ind) + 1) + 1) + 1); - const size_t num_transformed = emit_transformed_parameters * (0); - const size_t num_gen_quantities = emit_generated_quantities * ((n_obs + - n_obs)); - const size_t num_to_write = num_params__ + num_transformed + - num_gen_quantities; - vars = std::vector(num_to_write, - std::numeric_limits::quiet_NaN()); - write_array_impl(base_rng, params_r, params_i, vars, - emit_transformed_parameters, emit_generated_quantities, pstream); - } - template inline T_ - log_prob(Eigen::Matrix& params_r, std::ostream* pstream = nullptr) const { - Eigen::Matrix params_i; - return log_prob_impl(params_r, params_i, pstream); - } - template inline T_ - log_prob(std::vector& params_r, std::vector& params_i, - std::ostream* pstream = nullptr) const { - return log_prob_impl(params_r, params_i, pstream); - } - inline void - transform_inits(const stan::io::var_context& context, - Eigen::Matrix& params_r, std::ostream* - pstream = nullptr) const final { - std::vector params_r_vec(params_r.size()); - std::vector params_i; - transform_inits(context, params_i, params_r_vec, pstream); - params_r = Eigen::Map>(params_r_vec.data(), - params_r_vec.size()); - } - inline void - transform_inits(const stan::io::var_context& context, std::vector& - params_i, std::vector& vars, std::ostream* - pstream__ = nullptr) const { - vars.resize(num_params_r__); - transform_inits_impl(context, vars, pstream__); - } - inline void - unconstrain_array(const std::vector& params_constrained, - std::vector& params_unconstrained, std::ostream* - pstream = nullptr) const { - const std::vector params_i; - params_unconstrained = std::vector(num_params_r__, - std::numeric_limits::quiet_NaN()); - unconstrain_array_impl(params_constrained, params_i, - params_unconstrained, pstream); - } - inline void - unconstrain_array(const Eigen::Matrix& params_constrained, - Eigen::Matrix& params_unconstrained, - std::ostream* pstream = nullptr) const { - const std::vector params_i; - params_unconstrained = Eigen::Matrix::Constant(num_params_r__, - std::numeric_limits::quiet_NaN()); - unconstrain_array_impl(params_constrained, params_i, - params_unconstrained, pstream); - } + stringstream s__; + s__ << "[{\"name\":\"ind_y_0\",\"type\":{\"name\":\"array\",\"length\":" << n_ind << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"ind_beta\",\"type\":{\"name\":\"array\",\"length\":" << n_ind << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"species_beta_mu\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"species_beta_sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"global_error_sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"array\",\"length\":" << n_obs << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"},{\"name\":\"Delta_hat\",\"type\":{\"name\":\"array\",\"length\":" << n_obs << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + inline void write_array(RNG& base_rng, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + const bool emit_transformed_parameters = true, + const bool emit_generated_quantities = true, + std::ostream* pstream = nullptr) const { + std::vector vars_vec(vars.size()); + std::vector params_i; + write_array_impl(base_rng, params_r, params_i, vars_vec, + emit_transformed_parameters, emit_generated_quantities, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) { + vars.coeffRef(i) = vars_vec[i]; + } + } + template + inline 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 = nullptr) const { + write_array_impl(base_rng, params_r, params_i, vars, emit_transformed_parameters, emit_generated_quantities, pstream); + } + template + inline T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = nullptr) const { + Eigen::Matrix params_i; + return log_prob_impl(params_r, params_i, pstream); + } + template + inline T__ log_prob(std::vector& params_r, + std::vector& params_i, + std::ostream* pstream = nullptr) const { + return log_prob_impl(params_r, params_i, pstream); + } + + inline void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream = nullptr) const final { + std::vector params_r_vec(params_r.size()); + std::vector params_i; + transform_inits_impl(context, params_i, params_r_vec, pstream); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) { + params_r.coeffRef(i) = params_r_vec[i]; + } + } + inline void transform_inits(const stan::io::var_context& context, + std::vector& params_i, + std::vector& vars, + std::ostream* pstream = nullptr) const final { + transform_inits_impl(context, params_i, vars, pstream); + } }; } using stan_model = model_constant_multi_ind_namespace::model_constant_multi_ind; #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::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; } diff --git a/src/stanExports_constant_single_ind.h b/src/stanExports_constant_single_ind.h index c97f444..a88757d 100644 --- a/src/stanExports_constant_single_ind.h +++ b/src/stanExports_constant_single_ind.h @@ -21,82 +21,132 @@ #define USE_STANC3 #endif #include -// Code generated by stanc v2.32.2 +// Code generated by stanc v2.26.1-4-gd72b68b7-dirty #include namespace model_constant_single_ind_namespace { +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; +using stan::math::pow; stan::math::profile_map profiles__; -static constexpr std::array locations_array__ = - {" (found before start of program)", - " (in 'constant_single_ind', line 19, column 2 to column 24)", - " (in 'constant_single_ind', line 20, column 2 to column 25)", - " (in 'constant_single_ind', line 22, column 2 to column 35)", - " (in 'constant_single_ind', line 48, column 2 to column 20)", - " (in 'constant_single_ind', line 49, column 2 to column 24)", - " (in 'constant_single_ind', line 52, column 6 to column 25)", - " (in 'constant_single_ind', line 51, column 23 to line 53, column 5)", - " (in 'constant_single_ind', line 51, column 4 to line 53, column 5)", - " (in 'constant_single_ind', line 54, column 4 to column 46)", - " (in 'constant_single_ind', line 56, column 6 to column 63)", - " (in 'constant_single_ind', line 55, column 17 to line 57, column 5)", - " (in 'constant_single_ind', line 55, column 4 to line 57, column 5)", - " (in 'constant_single_ind', line 50, column 19 to line 58, column 3)", - " (in 'constant_single_ind', line 50, column 2 to line 58, column 3)", - " (in 'constant_single_ind', line 26, column 13 to column 18)", - " (in 'constant_single_ind', line 26, column 2 to column 20)", - " (in 'constant_single_ind', line 27, column 17 to column 22)", - " (in 'constant_single_ind', line 27, column 2 to column 24)", - " (in 'constant_single_ind', line 30, column 6 to column 25)", - " (in 'constant_single_ind', line 29, column 23 to line 31, column 5)", - " (in 'constant_single_ind', line 29, column 4 to line 31, column 5)", - " (in 'constant_single_ind', line 32, column 4 to column 46)", - " (in 'constant_single_ind', line 34, column 6 to column 63)", - " (in 'constant_single_ind', line 33, column 17 to line 35, column 5)", - " (in 'constant_single_ind', line 33, column 4 to line 35, column 5)", - " (in 'constant_single_ind', line 28, column 19 to line 36, column 3)", - " (in 'constant_single_ind', line 28, column 2 to line 36, column 3)", - " (in 'constant_single_ind', line 38, column 2 to column 44)", - " (in 'constant_single_ind', line 41, column 2 to column 48)", - " (in 'constant_single_ind', line 42, column 2 to column 31)", - " (in 'constant_single_ind', line 44, column 2 to column 37)", - " (in 'constant_single_ind', line 10, column 2 to column 12)", - " (in 'constant_single_ind', line 11, column 13 to column 18)", - " (in 'constant_single_ind', line 11, column 2 to column 20)", - " (in 'constant_single_ind', line 12, column 16 to column 21)", - " (in 'constant_single_ind', line 12, column 2 to column 23)", - " (in 'constant_single_ind', line 13, column 12 to column 17)", - " (in 'constant_single_ind', line 13, column 2 to column 19)", - " (in 'constant_single_ind', line 14, column 2 to column 15)", - " (in 'constant_single_ind', line 48, column 13 to column 18)", - " (in 'constant_single_ind', line 49, column 17 to column 22)", - " (in 'constant_single_ind', line 5, column 4 to column 16)", - " (in 'constant_single_ind', line 4, column 32 to line 6, column 3)"}; -template , - stan::is_stan_scalar>* = nullptr> -stan::promote_args_t -growth(const T0__& y, const T1__& beta, std::ostream* pstream__); -template , - stan::is_stan_scalar>*> -stan::promote_args_t +static int current_statement__= 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'constant_single_ind', line 19, column 2 to column 24)", + " (in 'constant_single_ind', line 20, column 2 to column 25)", + " (in 'constant_single_ind', line 22, column 2 to column 35)", + " (in 'constant_single_ind', line 48, column 2 to column 20)", + " (in 'constant_single_ind', line 49, column 2 to column 24)", + " (in 'constant_single_ind', line 52, column 6 to column 25)", + " (in 'constant_single_ind', line 51, column 23 to line 53, column 5)", + " (in 'constant_single_ind', line 51, column 4 to line 53, column 5)", + " (in 'constant_single_ind', line 54, column 4 to column 46)", + " (in 'constant_single_ind', line 56, column 6 to column 63)", + " (in 'constant_single_ind', line 55, column 17 to line 57, column 5)", + " (in 'constant_single_ind', line 55, column 4 to line 57, column 5)", + " (in 'constant_single_ind', line 50, column 19 to line 58, column 3)", + " (in 'constant_single_ind', line 50, column 2 to line 58, column 3)", + " (in 'constant_single_ind', line 26, column 13 to column 18)", + " (in 'constant_single_ind', line 26, column 2 to column 20)", + " (in 'constant_single_ind', line 27, column 17 to column 22)", + " (in 'constant_single_ind', line 27, column 2 to column 24)", + " (in 'constant_single_ind', line 30, column 6 to column 25)", + " (in 'constant_single_ind', line 29, column 23 to line 31, column 5)", + " (in 'constant_single_ind', line 29, column 4 to line 31, column 5)", + " (in 'constant_single_ind', line 32, column 4 to column 46)", + " (in 'constant_single_ind', line 34, column 6 to column 63)", + " (in 'constant_single_ind', line 33, column 17 to line 35, column 5)", + " (in 'constant_single_ind', line 33, column 4 to line 35, column 5)", + " (in 'constant_single_ind', line 28, column 19 to line 36, column 3)", + " (in 'constant_single_ind', line 28, column 2 to line 36, column 3)", + " (in 'constant_single_ind', line 38, column 2 to column 44)", + " (in 'constant_single_ind', line 41, column 2 to column 48)", + " (in 'constant_single_ind', line 42, column 2 to column 31)", + " (in 'constant_single_ind', line 44, column 2 to column 37)", + " (in 'constant_single_ind', line 10, column 2 to column 12)", + " (in 'constant_single_ind', line 11, column 13 to column 18)", + " (in 'constant_single_ind', line 11, column 2 to column 20)", + " (in 'constant_single_ind', line 12, column 16 to column 21)", + " (in 'constant_single_ind', line 12, column 2 to column 23)", + " (in 'constant_single_ind', line 13, column 12 to column 17)", + " (in 'constant_single_ind', line 13, column 2 to column 19)", + " (in 'constant_single_ind', line 14, column 2 to column 15)", + " (in 'constant_single_ind', line 48, column 13 to column 18)", + " (in 'constant_single_ind', line 49, column 17 to column 22)", + " (in 'constant_single_ind', line 5, column 4 to column 16)", + " (in 'constant_single_ind', line 4, column 32 to line 6, column 3)"}; +template +stan::promote_args_t growth(const T0__& y, const T1__& beta, std::ostream* pstream__) { using local_scalar_t__ = stan::promote_args_t; - int current_statement__ = 0; - static constexpr bool propto__ = true; - // suppress unused var warning + const static bool propto__ = true; (void) propto__; local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - // suppress unused var warning - (void) DUMMY_VAR__; + (void) DUMMY_VAR__; // suppress unused var warning + try { current_statement__ = 42; return beta; } 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 growth_functor__ { +template +stan::promote_args_t +operator()(const T0__& y, const T1__& beta, std::ostream* pstream__) const +{ +return growth(y, beta, pstream__); } +}; #include class model_constant_single_ind final : public model_base_crtp { private: @@ -105,496 +155,498 @@ class model_constant_single_ind final : public model_base_crtp obs_index; std::vector time; double y_0_obs; + public: - ~model_constant_single_ind() {} - model_constant_single_ind(stan::io::var_context& context__, unsigned int - random_seed__ = 0, std::ostream* - pstream__ = nullptr) : model_base_crtp(0) { - int current_statement__ = 0; - using local_scalar_t__ = double; - boost::ecuyer1988 base_rng__ = - stan::services::util::create_rng(random_seed__, 0); - // suppress unused var warning - (void) base_rng__; - static constexpr const char* function__ = - "model_constant_single_ind_namespace::model_constant_single_ind"; - // suppress unused var warning - (void) function__; + ~model_constant_single_ind() { } + + inline std::string model_name() const final { return "model_constant_single_ind"; } + inline std::vector model_compile_info() const noexcept { + return std::vector{"stanc_version = stanc3 v2.26.1-4-gd72b68b7-dirty", "stancflags = "}; + } + + + model_constant_single_ind(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + using local_scalar_t__ = double ; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "model_constant_single_ind_namespace::model_constant_single_ind"; + (void) function__; // suppress unused var warning local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - // suppress unused var warning - (void) DUMMY_VAR__; + (void) DUMMY_VAR__; // suppress unused var warning + try { - int pos__ = std::numeric_limits::min(); + int pos__; + pos__ = std::numeric_limits::min(); + pos__ = 1; current_statement__ = 32; - context__.validate_dims("data initialization", "n_obs", "int", - std::vector{}); + context__.validate_dims("data initialization","n_obs","int", + context__.to_vec()); n_obs = std::numeric_limits::min(); + current_statement__ = 32; n_obs = context__.vals_i("n_obs")[(1 - 1)]; current_statement__ = 33; - stan::math::validate_non_negative_index("y_obs", "n_obs", n_obs); + validate_non_negative_index("y_obs", "n_obs", n_obs); current_statement__ = 34; - context__.validate_dims("data initialization", "y_obs", "double", - std::vector{static_cast(n_obs)}); - y_obs = std::vector(n_obs, - std::numeric_limits::quiet_NaN()); + context__.validate_dims("data initialization","y_obs","double", + context__.to_vec(n_obs)); + y_obs = std::vector(n_obs, std::numeric_limits::quiet_NaN()); + current_statement__ = 34; - y_obs = context__.vals_r("y_obs"); + assign(y_obs, nil_index_list(), context__.vals_r("y_obs"), + "assigning variable y_obs"); current_statement__ = 35; - stan::math::validate_non_negative_index("obs_index", "n_obs", n_obs); + validate_non_negative_index("obs_index", "n_obs", n_obs); current_statement__ = 36; - context__.validate_dims("data initialization", "obs_index", "int", - std::vector{static_cast(n_obs)}); + context__.validate_dims("data initialization","obs_index","int", + context__.to_vec(n_obs)); obs_index = std::vector(n_obs, std::numeric_limits::min()); + current_statement__ = 36; - obs_index = context__.vals_i("obs_index"); + assign(obs_index, nil_index_list(), context__.vals_i("obs_index"), + "assigning variable obs_index"); current_statement__ = 37; - stan::math::validate_non_negative_index("time", "n_obs", n_obs); + validate_non_negative_index("time", "n_obs", n_obs); current_statement__ = 38; - context__.validate_dims("data initialization", "time", "double", - std::vector{static_cast(n_obs)}); - time = std::vector(n_obs, - std::numeric_limits::quiet_NaN()); + context__.validate_dims("data initialization","time","double", + context__.to_vec(n_obs)); + time = std::vector(n_obs, std::numeric_limits::quiet_NaN()); + current_statement__ = 38; - time = context__.vals_r("time"); + assign(time, nil_index_list(), context__.vals_r("time"), + "assigning variable time"); current_statement__ = 39; - context__.validate_dims("data initialization", "y_0_obs", "double", - std::vector{}); + context__.validate_dims("data initialization","y_0_obs","double", + context__.to_vec()); y_0_obs = std::numeric_limits::quiet_NaN(); + current_statement__ = 39; y_0_obs = context__.vals_r("y_0_obs")[(1 - 1)]; current_statement__ = 40; - stan::math::validate_non_negative_index("y_hat", "n_obs", n_obs); + validate_non_negative_index("y_hat", "n_obs", n_obs); current_statement__ = 41; - stan::math::validate_non_negative_index("Delta_hat", "n_obs", n_obs); + validate_non_negative_index("Delta_hat", "n_obs", n_obs); } 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; + } 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__ = 1 + 1 + 1; - } - inline std::string model_name() const final { - return "model_constant_single_ind"; - } - inline std::vector model_compile_info() const noexcept { - return std::vector{"stanc_version = stanc3 v2.32.2", - "stancflags = --allow-undefined"}; } - template * = nullptr, - stan::require_vector_like_vt* = nullptr> - inline stan::scalar_type_t - log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream* - pstream__ = nullptr) const { + template * = nullptr, stan::require_vector_like_vt* = nullptr> + inline stan::scalar_type_t log_prob_impl(VecR& params_r__, + VecI& params_i__, + std::ostream* pstream__ = nullptr) const { using T__ = stan::scalar_type_t; using local_scalar_t__ = T__; T__ lp__(0.0); stan::math::accumulator lp_accum__; - stan::io::deserializer in__(params_r__, params_i__); - int current_statement__ = 0; + static const char* function__ = "model_constant_single_ind_namespace::log_prob"; +(void) function__; // suppress unused var warning + stan::io::reader in__(params_r__, params_i__); local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - // suppress unused var warning - (void) DUMMY_VAR__; - static constexpr const char* function__ = - "model_constant_single_ind_namespace::log_prob"; - // suppress unused var warning - (void) function__; + (void) DUMMY_VAR__; // suppress unused var warning + try { - local_scalar_t__ ind_y_0 = DUMMY_VAR__; + local_scalar_t__ ind_y_0; + ind_y_0 = DUMMY_VAR__; + + current_statement__ = 1; + ind_y_0 = in__.scalar(); current_statement__ = 1; - ind_y_0 = in__.template read_constrain_lb(0, lp__); - local_scalar_t__ ind_beta = DUMMY_VAR__; + if (jacobian__) { + current_statement__ = 1; + ind_y_0 = stan::math::lb_constrain(ind_y_0, 0, lp__); + } else { + current_statement__ = 1; + ind_y_0 = stan::math::lb_constrain(ind_y_0, 0); + } + local_scalar_t__ ind_beta; + ind_beta = DUMMY_VAR__; + current_statement__ = 2; - ind_beta = in__.template read_constrain_lb(0, lp__); - local_scalar_t__ global_error_sigma = DUMMY_VAR__; + ind_beta = in__.scalar(); + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + ind_beta = stan::math::lb_constrain(ind_beta, 0, lp__); + } else { + current_statement__ = 2; + ind_beta = stan::math::lb_constrain(ind_beta, 0); + } + local_scalar_t__ global_error_sigma; + global_error_sigma = DUMMY_VAR__; + current_statement__ = 3; - global_error_sigma = in__.template read_constrain_lb(0, lp__); + global_error_sigma = in__.scalar(); + current_statement__ = 3; + if (jacobian__) { + current_statement__ = 3; + global_error_sigma = stan::math::lb_constrain(global_error_sigma, 0, + lp__); + } else { + current_statement__ = 3; + global_error_sigma = stan::math::lb_constrain(global_error_sigma, 0); + } { current_statement__ = 15; - stan::math::validate_non_negative_index("y_hat", "n_obs", n_obs); - std::vector y_hat = - std::vector(n_obs, DUMMY_VAR__); + validate_non_negative_index("y_hat", "n_obs", n_obs); + std::vector y_hat; + y_hat = std::vector(n_obs, DUMMY_VAR__); + current_statement__ = 17; - stan::math::validate_non_negative_index("Delta_hat", "n_obs", n_obs); - std::vector Delta_hat = - std::vector(n_obs, DUMMY_VAR__); + validate_non_negative_index("Delta_hat", "n_obs", n_obs); + std::vector Delta_hat; + Delta_hat = std::vector(n_obs, DUMMY_VAR__); + current_statement__ = 27; for (int i = 1; i <= n_obs; ++i) { current_statement__ = 21; - if (stan::math::logical_eq( - stan::model::rvalue(obs_index, "obs_index", - stan::model::index_uni(i)), 1)) { + if (logical_eq(obs_index[(i - 1)], 1)) { current_statement__ = 19; - stan::model::assign(y_hat, ind_y_0, "assigning variable y_hat", - stan::model::index_uni(i)); - } + assign(y_hat, cons_list(index_uni(i), nil_index_list()), ind_y_0, + "assigning variable y_hat"); + } current_statement__ = 22; - stan::model::assign(Delta_hat, - growth( - stan::model::rvalue(y_hat, "y_hat", stan::model::index_uni(i)), - ind_beta, pstream__), "assigning variable Delta_hat", - stan::model::index_uni(i)); + assign(Delta_hat, cons_list(index_uni(i), nil_index_list()), + growth(y_hat[(i - 1)], ind_beta, pstream__), + "assigning variable Delta_hat"); current_statement__ = 25; - if (stan::math::logical_lt(i, n_obs)) { + if (logical_lt(i, n_obs)) { current_statement__ = 23; - stan::model::assign(y_hat, - (stan::model::rvalue(y_hat, "y_hat", stan::model::index_uni(i)) - + - (stan::model::rvalue(Delta_hat, "Delta_hat", - stan::model::index_uni(i)) * - (stan::model::rvalue(time, "time", - stan::model::index_uni((i + 1))) - - stan::model::rvalue(time, "time", stan::model::index_uni(i))))), - "assigning variable y_hat", stan::model::index_uni((i + 1))); - } - } + assign(y_hat, cons_list(index_uni((i + 1)), nil_index_list()), + (y_hat[(i - 1)] + + (Delta_hat[(i - 1)] * (time[((i + 1) - 1)] - time[(i - 1)]))), + "assigning variable y_hat"); + } } current_statement__ = 28; - lp_accum__.add(stan::math::normal_lpdf(y_obs, y_hat, - global_error_sigma)); + lp_accum__.add( + normal_lpdf(y_obs, y_hat, global_error_sigma)); current_statement__ = 29; - lp_accum__.add(stan::math::normal_lpdf(ind_y_0, y_0_obs, - global_error_sigma)); + lp_accum__.add( + normal_lpdf(ind_y_0, y_0_obs, global_error_sigma)); current_statement__ = 30; - lp_accum__.add(stan::math::lognormal_lpdf(ind_beta, 0.1, 1)); + lp_accum__.add(lognormal_lpdf(ind_beta, 0.1, 1)); current_statement__ = 31; - lp_accum__.add(stan::math::cauchy_lpdf(global_error_sigma, - 0.1, 1)); + lp_accum__.add(cauchy_lpdf(global_error_sigma, 0.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(); - } - template * = nullptr, stan::require_vector_like_vt* = nullptr, stan::require_vector_vt* = nullptr> - inline void - write_array_impl(RNG& base_rng__, VecR& params_r__, VecI& params_i__, - VecVar& vars__, const bool - emit_transformed_parameters__ = true, const bool - emit_generated_quantities__ = true, std::ostream* - pstream__ = nullptr) const { + } // log_prob_impl() + + template * = nullptr, stan::require_vector_like_vt* = nullptr, stan::require_std_vector_vt* = nullptr> + inline void write_array_impl(RNG& base_rng__, VecR& params_r__, + VecI& params_i__, VecVar& vars__, + const bool emit_transformed_parameters__ = true, + const bool emit_generated_quantities__ = true, + std::ostream* pstream__ = nullptr) const { using local_scalar_t__ = double; - stan::io::deserializer in__(params_r__, params_i__); - stan::io::serializer out__(vars__); - static constexpr bool propto__ = true; - // suppress unused var warning - (void) propto__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "model_constant_single_ind_namespace::write_array"; +(void) function__; // suppress unused var warning + (void) function__; // suppress unused var warning double lp__ = 0.0; - // suppress unused var warning - (void) lp__; - int current_statement__ = 0; + (void) lp__; // dummy to suppress unused var warning stan::math::accumulator lp_accum__; local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - // suppress unused var warning - (void) DUMMY_VAR__; - constexpr bool jacobian__ = false; - static constexpr const char* function__ = - "model_constant_single_ind_namespace::write_array"; - // suppress unused var warning - (void) function__; + (void) DUMMY_VAR__; // suppress unused var warning + try { - double ind_y_0 = std::numeric_limits::quiet_NaN(); + double ind_y_0; + ind_y_0 = std::numeric_limits::quiet_NaN(); + current_statement__ = 1; - ind_y_0 = in__.template read_constrain_lb(0, lp__); - double ind_beta = std::numeric_limits::quiet_NaN(); + ind_y_0 = in__.scalar(); + current_statement__ = 1; + ind_y_0 = stan::math::lb_constrain(ind_y_0, 0); + double ind_beta; + ind_beta = std::numeric_limits::quiet_NaN(); + + current_statement__ = 2; + ind_beta = in__.scalar(); current_statement__ = 2; - ind_beta = in__.template read_constrain_lb(0, lp__); - double global_error_sigma = std::numeric_limits::quiet_NaN(); + ind_beta = stan::math::lb_constrain(ind_beta, 0); + double global_error_sigma; + global_error_sigma = std::numeric_limits::quiet_NaN(); + + current_statement__ = 3; + global_error_sigma = in__.scalar(); current_statement__ = 3; - global_error_sigma = in__.template read_constrain_lb(0, lp__); - out__.write(ind_y_0); - out__.write(ind_beta); - out__.write(global_error_sigma); - if (stan::math::logical_negation( - (stan::math::primitive_value(emit_transformed_parameters__) || - stan::math::primitive_value(emit_generated_quantities__)))) { + global_error_sigma = stan::math::lb_constrain(global_error_sigma, 0); + vars__.emplace_back(ind_y_0); + vars__.emplace_back(ind_beta); + vars__.emplace_back(global_error_sigma); + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { return ; - } - if (stan::math::logical_negation(emit_generated_quantities__)) { + } + if (logical_negation(emit_generated_quantities__)) { return ; - } - std::vector y_hat = - std::vector(n_obs, std::numeric_limits::quiet_NaN()); - std::vector Delta_hat = - std::vector(n_obs, std::numeric_limits::quiet_NaN()); + } + std::vector y_hat; + y_hat = std::vector(n_obs, std::numeric_limits::quiet_NaN()); + + std::vector Delta_hat; + Delta_hat = std::vector(n_obs, std::numeric_limits::quiet_NaN()); + current_statement__ = 14; for (int i = 1; i <= n_obs; ++i) { current_statement__ = 8; - if (stan::math::logical_eq( - stan::model::rvalue(obs_index, "obs_index", - stan::model::index_uni(i)), 1)) { + if (logical_eq(obs_index[(i - 1)], 1)) { current_statement__ = 6; - stan::model::assign(y_hat, ind_y_0, "assigning variable y_hat", - stan::model::index_uni(i)); - } + assign(y_hat, cons_list(index_uni(i), nil_index_list()), ind_y_0, + "assigning variable y_hat"); + } current_statement__ = 9; - stan::model::assign(Delta_hat, - growth( - stan::model::rvalue(y_hat, "y_hat", stan::model::index_uni(i)), - ind_beta, pstream__), "assigning variable Delta_hat", - stan::model::index_uni(i)); + assign(Delta_hat, cons_list(index_uni(i), nil_index_list()), + growth(y_hat[(i - 1)], ind_beta, pstream__), + "assigning variable Delta_hat"); current_statement__ = 12; - if (stan::math::logical_lt(i, n_obs)) { + if (logical_lt(i, n_obs)) { current_statement__ = 10; - stan::model::assign(y_hat, - (stan::model::rvalue(y_hat, "y_hat", stan::model::index_uni(i)) + - (stan::model::rvalue(Delta_hat, "Delta_hat", - stan::model::index_uni(i)) * - (stan::model::rvalue(time, "time", - stan::model::index_uni((i + 1))) - - stan::model::rvalue(time, "time", stan::model::index_uni(i))))), - "assigning variable y_hat", stan::model::index_uni((i + 1))); - } - } - out__.write(y_hat); - out__.write(Delta_hat); - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, locations_array__[current_statement__]); - } - } - template * = nullptr, - stan::require_vector_like_vt* = nullptr> - inline void - unconstrain_array_impl(const VecVar& params_r__, const VecI& params_i__, - VecVar& vars__, std::ostream* pstream__ = nullptr) const { - using local_scalar_t__ = double; - stan::io::deserializer in__(params_r__, params_i__); - stan::io::serializer out__(vars__); - int current_statement__ = 0; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - // suppress unused var warning - (void) DUMMY_VAR__; - try { - int pos__ = std::numeric_limits::min(); - pos__ = 1; - local_scalar_t__ ind_y_0 = DUMMY_VAR__; - current_statement__ = 1; - ind_y_0 = in__.read(); - out__.write_free_lb(0, ind_y_0); - local_scalar_t__ ind_beta = DUMMY_VAR__; - current_statement__ = 2; - ind_beta = in__.read(); - out__.write_free_lb(0, ind_beta); - local_scalar_t__ global_error_sigma = DUMMY_VAR__; - current_statement__ = 3; - global_error_sigma = in__.read(); - out__.write_free_lb(0, global_error_sigma); + assign(y_hat, cons_list(index_uni((i + 1)), nil_index_list()), + (y_hat[(i - 1)] + + (Delta_hat[(i - 1)] * (time[((i + 1) - 1)] - time[(i - 1)]))), + "assigning variable y_hat"); + } } + for (int sym1__ = 1; sym1__ <= n_obs; ++sym1__) { + vars__.emplace_back(y_hat[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= n_obs; ++sym1__) { + vars__.emplace_back(Delta_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 ***"); } - } - template * = nullptr> - inline void - transform_inits_impl(const stan::io::var_context& context__, VecVar& - vars__, std::ostream* pstream__ = nullptr) const { + } // write_array_impl() + + template * = nullptr, stan::require_vector_like_vt* = nullptr> + inline void transform_inits_impl(const stan::io::var_context& context__, + VecI& params_i__, VecVar& vars__, + std::ostream* pstream__ = nullptr) const { using local_scalar_t__ = double; - stan::io::serializer out__(vars__); - int current_statement__ = 0; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - // suppress unused var warning - (void) DUMMY_VAR__; + vars__.clear(); + vars__.reserve(num_params_r__); + try { - current_statement__ = 1; - context__.validate_dims("parameter initialization", "ind_y_0", - "double", std::vector{}); - current_statement__ = 2; - context__.validate_dims("parameter initialization", "ind_beta", - "double", std::vector{}); - current_statement__ = 3; - context__.validate_dims("parameter initialization", - "global_error_sigma", "double", std::vector{}); - int pos__ = std::numeric_limits::min(); + int pos__; + pos__ = std::numeric_limits::min(); + pos__ = 1; - local_scalar_t__ ind_y_0 = DUMMY_VAR__; + double ind_y_0; + ind_y_0 = std::numeric_limits::quiet_NaN(); + current_statement__ = 1; ind_y_0 = context__.vals_r("ind_y_0")[(1 - 1)]; - out__.write_free_lb(0, ind_y_0); - local_scalar_t__ ind_beta = DUMMY_VAR__; + double ind_y_0_free__; + ind_y_0_free__ = std::numeric_limits::quiet_NaN(); + + current_statement__ = 1; + ind_y_0_free__ = stan::math::lb_free(ind_y_0, 0); + double ind_beta; + ind_beta = std::numeric_limits::quiet_NaN(); + current_statement__ = 2; ind_beta = context__.vals_r("ind_beta")[(1 - 1)]; - out__.write_free_lb(0, ind_beta); - local_scalar_t__ global_error_sigma = DUMMY_VAR__; + double ind_beta_free__; + ind_beta_free__ = std::numeric_limits::quiet_NaN(); + + current_statement__ = 2; + ind_beta_free__ = stan::math::lb_free(ind_beta, 0); + double global_error_sigma; + global_error_sigma = std::numeric_limits::quiet_NaN(); + current_statement__ = 3; global_error_sigma = context__.vals_r("global_error_sigma")[(1 - 1)]; - out__.write_free_lb(0, global_error_sigma); + double global_error_sigma_free__; + global_error_sigma_free__ = std::numeric_limits::quiet_NaN(); + + current_statement__ = 3; + global_error_sigma_free__ = stan::math::lb_free(global_error_sigma, 0); + vars__.emplace_back(ind_y_0_free__); + vars__.emplace_back(ind_beta_free__); + vars__.emplace_back(global_error_sigma_free__); } 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 ***"); } - } - inline void - get_param_names(std::vector& names__, const bool - emit_transformed_parameters__ = true, const bool - emit_generated_quantities__ = true) const { - names__ = std::vector{"ind_y_0", "ind_beta", - "global_error_sigma"}; - if (emit_transformed_parameters__) {} - if (emit_generated_quantities__) { - std::vector temp{"y_hat", "Delta_hat"}; - names__.reserve(names__.size() + temp.size()); - names__.insert(names__.end(), temp.begin(), temp.end()); - } - } - inline void - get_dims(std::vector>& dimss__, const bool - emit_transformed_parameters__ = true, const bool - emit_generated_quantities__ = true) const { - dimss__ = std::vector>{std::vector{}, - std::vector{}, std::vector{}}; - if (emit_transformed_parameters__) {} - if (emit_generated_quantities__) { - std::vector> - temp{std::vector{static_cast(n_obs)}, - std::vector{static_cast(n_obs)}}; - dimss__.reserve(dimss__.size() + temp.size()); - dimss__.insert(dimss__.end(), temp.begin(), temp.end()); - } - } - inline void - constrained_param_names(std::vector& param_names__, bool - emit_transformed_parameters__ = true, bool - emit_generated_quantities__ = true) const final { + } // transform_inits_impl() + + inline void get_param_names(std::vector& names__) const { + + names__.clear(); + names__.emplace_back("ind_y_0"); + names__.emplace_back("ind_beta"); + names__.emplace_back("global_error_sigma"); + names__.emplace_back("y_hat"); + names__.emplace_back("Delta_hat"); + } // get_param_names() + + inline void get_dims(std::vector>& dimss__) const { + dimss__.clear(); + dimss__.emplace_back(std::vector{}); + + dimss__.emplace_back(std::vector{}); + + dimss__.emplace_back(std::vector{}); + + dimss__.emplace_back(std::vector{static_cast(n_obs)}); + + dimss__.emplace_back(std::vector{static_cast(n_obs)}); + + } // get_dims() + + inline void constrained_param_names( + std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const + final { + param_names__.emplace_back(std::string() + "ind_y_0"); param_names__.emplace_back(std::string() + "ind_beta"); param_names__.emplace_back(std::string() + "global_error_sigma"); - if (emit_transformed_parameters__) {} + if (emit_transformed_parameters__) { + + } + if (emit_generated_quantities__) { for (int sym1__ = 1; sym1__ <= n_obs; ++sym1__) { - param_names__.emplace_back(std::string() + "y_hat" + '.' + - std::to_string(sym1__)); - } + { + param_names__.emplace_back(std::string() + "y_hat" + '.' + std::to_string(sym1__)); + }} for (int sym1__ = 1; sym1__ <= n_obs; ++sym1__) { - param_names__.emplace_back(std::string() + "Delta_hat" + '.' + - std::to_string(sym1__)); - } + { + param_names__.emplace_back(std::string() + "Delta_hat" + '.' + std::to_string(sym1__)); + }} } - } - inline void - unconstrained_param_names(std::vector& param_names__, bool - emit_transformed_parameters__ = true, bool - emit_generated_quantities__ = true) const final { + + } // constrained_param_names() + + inline void unconstrained_param_names( + std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const + final { + param_names__.emplace_back(std::string() + "ind_y_0"); param_names__.emplace_back(std::string() + "ind_beta"); param_names__.emplace_back(std::string() + "global_error_sigma"); - if (emit_transformed_parameters__) {} + if (emit_transformed_parameters__) { + + } + if (emit_generated_quantities__) { for (int sym1__ = 1; sym1__ <= n_obs; ++sym1__) { - param_names__.emplace_back(std::string() + "y_hat" + '.' + - std::to_string(sym1__)); - } + { + param_names__.emplace_back(std::string() + "y_hat" + '.' + std::to_string(sym1__)); + }} for (int sym1__ = 1; sym1__ <= n_obs; ++sym1__) { - param_names__.emplace_back(std::string() + "Delta_hat" + '.' + - std::to_string(sym1__)); - } + { + param_names__.emplace_back(std::string() + "Delta_hat" + '.' + std::to_string(sym1__)); + }} } - } + + } // unconstrained_param_names() + inline std::string get_constrained_sizedtypes() const { - return std::string("[{\"name\":\"ind_y_0\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"ind_beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"global_error_sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(n_obs) + ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"},{\"name\":\"Delta_hat\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(n_obs) + ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"}]"); - } + stringstream s__; + s__ << "[{\"name\":\"ind_y_0\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"ind_beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"global_error_sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"array\",\"length\":" << n_obs << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"},{\"name\":\"Delta_hat\",\"type\":{\"name\":\"array\",\"length\":" << n_obs << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + inline std::string get_unconstrained_sizedtypes() const { - return std::string("[{\"name\":\"ind_y_0\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"ind_beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"global_error_sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(n_obs) + ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"},{\"name\":\"Delta_hat\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(n_obs) + ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"}]"); - } - // Begin method overload boilerplate - template inline void - write_array(RNG& base_rng, Eigen::Matrix& params_r, - Eigen::Matrix& vars, const bool - emit_transformed_parameters = true, const bool - emit_generated_quantities = true, std::ostream* - pstream = nullptr) const { - const size_t num_params__ = ((1 + 1) + 1); - const size_t num_transformed = emit_transformed_parameters * (0); - const size_t num_gen_quantities = emit_generated_quantities * ((n_obs + - n_obs)); - const size_t num_to_write = num_params__ + num_transformed + - num_gen_quantities; - std::vector params_i; - vars = Eigen::Matrix::Constant(num_to_write, - std::numeric_limits::quiet_NaN()); - write_array_impl(base_rng, params_r, params_i, vars, - emit_transformed_parameters, emit_generated_quantities, pstream); - } - template inline 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 = nullptr) const { - const size_t num_params__ = ((1 + 1) + 1); - const size_t num_transformed = emit_transformed_parameters * (0); - const size_t num_gen_quantities = emit_generated_quantities * ((n_obs + - n_obs)); - const size_t num_to_write = num_params__ + num_transformed + - num_gen_quantities; - vars = std::vector(num_to_write, - std::numeric_limits::quiet_NaN()); - write_array_impl(base_rng, params_r, params_i, vars, - emit_transformed_parameters, emit_generated_quantities, pstream); - } - template inline T_ - log_prob(Eigen::Matrix& params_r, std::ostream* pstream = nullptr) const { - Eigen::Matrix params_i; - return log_prob_impl(params_r, params_i, pstream); - } - template inline T_ - log_prob(std::vector& params_r, std::vector& params_i, - std::ostream* pstream = nullptr) const { - return log_prob_impl(params_r, params_i, pstream); - } - inline void - transform_inits(const stan::io::var_context& context, - Eigen::Matrix& params_r, std::ostream* - pstream = nullptr) const final { - std::vector params_r_vec(params_r.size()); - std::vector params_i; - transform_inits(context, params_i, params_r_vec, pstream); - params_r = Eigen::Map>(params_r_vec.data(), - params_r_vec.size()); - } - inline void - transform_inits(const stan::io::var_context& context, std::vector& - params_i, std::vector& vars, std::ostream* - pstream__ = nullptr) const { - vars.resize(num_params_r__); - transform_inits_impl(context, vars, pstream__); - } - inline void - unconstrain_array(const std::vector& params_constrained, - std::vector& params_unconstrained, std::ostream* - pstream = nullptr) const { - const std::vector params_i; - params_unconstrained = std::vector(num_params_r__, - std::numeric_limits::quiet_NaN()); - unconstrain_array_impl(params_constrained, params_i, - params_unconstrained, pstream); - } - inline void - unconstrain_array(const Eigen::Matrix& params_constrained, - Eigen::Matrix& params_unconstrained, - std::ostream* pstream = nullptr) const { - const std::vector params_i; - params_unconstrained = Eigen::Matrix::Constant(num_params_r__, - std::numeric_limits::quiet_NaN()); - unconstrain_array_impl(params_constrained, params_i, - params_unconstrained, pstream); - } + stringstream s__; + s__ << "[{\"name\":\"ind_y_0\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"ind_beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"global_error_sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"array\",\"length\":" << n_obs << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"},{\"name\":\"Delta_hat\",\"type\":{\"name\":\"array\",\"length\":" << n_obs << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + inline void write_array(RNG& base_rng, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + const bool emit_transformed_parameters = true, + const bool emit_generated_quantities = true, + std::ostream* pstream = nullptr) const { + std::vector vars_vec(vars.size()); + std::vector params_i; + write_array_impl(base_rng, params_r, params_i, vars_vec, + emit_transformed_parameters, emit_generated_quantities, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) { + vars.coeffRef(i) = vars_vec[i]; + } + } + template + inline 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 = nullptr) const { + write_array_impl(base_rng, params_r, params_i, vars, emit_transformed_parameters, emit_generated_quantities, pstream); + } + template + inline T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = nullptr) const { + Eigen::Matrix params_i; + return log_prob_impl(params_r, params_i, pstream); + } + template + inline T__ log_prob(std::vector& params_r, + std::vector& params_i, + std::ostream* pstream = nullptr) const { + return log_prob_impl(params_r, params_i, pstream); + } + + inline void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream = nullptr) const final { + std::vector params_r_vec(params_r.size()); + std::vector params_i; + transform_inits_impl(context, params_i, params_r_vec, pstream); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) { + params_r.coeffRef(i) = params_r_vec[i]; + } + } + inline void transform_inits(const stan::io::var_context& context, + std::vector& params_i, + std::vector& vars, + std::ostream* pstream = nullptr) const final { + transform_inits_impl(context, params_i, vars, pstream); + } }; } using stan_model = model_constant_single_ind_namespace::model_constant_single_ind; #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::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; } diff --git a/src/stanExports_linear.h b/src/stanExports_linear.h index b9e1696..b072723 100644 --- a/src/stanExports_linear.h +++ b/src/stanExports_linear.h @@ -21,418 +21,457 @@ #define USE_STANC3 #endif #include -// Code generated by stanc v2.32.2 +// Code generated by stanc v2.26.1-4-gd72b68b7-dirty #include namespace model_linear_namespace { +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; +using stan::math::pow; stan::math::profile_map profiles__; -static constexpr std::array locations_array__ = - {" (found before start of program)", - " (in 'linear', line 8, column 2 to column 17)", - " (in 'linear', line 9, column 2 to column 12)", - " (in 'linear', line 10, column 2 to column 22)", - " (in 'linear', line 14, column 2 to column 42)", - " (in 'linear', line 3, column 2 to column 17)", - " (in 'linear', line 4, column 9 to column 10)", - " (in 'linear', line 4, column 2 to column 14)", - " (in 'linear', line 5, column 9 to column 10)", - " (in 'linear', line 5, column 2 to column 14)"}; +static int current_statement__= 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'linear', line 8, column 2 to column 17)", + " (in 'linear', line 9, column 2 to column 12)", + " (in 'linear', line 10, column 2 to column 22)", + " (in 'linear', line 14, column 2 to column 42)", + " (in 'linear', line 3, column 2 to column 17)", + " (in 'linear', line 4, column 9 to column 10)", + " (in 'linear', line 4, column 2 to column 14)", + " (in 'linear', line 5, column 9 to column 10)", + " (in 'linear', line 5, column 2 to column 14)"}; #include class model_linear final : public model_base_crtp { private: int N; - Eigen::Matrix X_data__; - Eigen::Matrix Y_data__; - Eigen::Map> X{nullptr, 0}; - Eigen::Map> Y{nullptr, 0}; + Eigen::Matrix X; + Eigen::Matrix Y; + public: - ~model_linear() {} - model_linear(stan::io::var_context& context__, unsigned int - random_seed__ = 0, std::ostream* pstream__ = nullptr) - : model_base_crtp(0) { - int current_statement__ = 0; - using local_scalar_t__ = double; - boost::ecuyer1988 base_rng__ = - stan::services::util::create_rng(random_seed__, 0); - // suppress unused var warning - (void) base_rng__; - static constexpr const char* function__ = - "model_linear_namespace::model_linear"; - // suppress unused var warning - (void) function__; + ~model_linear() { } + + inline std::string model_name() const final { return "model_linear"; } + inline std::vector model_compile_info() const noexcept { + return std::vector{"stanc_version = stanc3 v2.26.1-4-gd72b68b7-dirty", "stancflags = "}; + } + + + model_linear(stan::io::var_context& context__, + unsigned int random_seed__ = 0, + std::ostream* pstream__ = nullptr) : model_base_crtp(0) { + using local_scalar_t__ = double ; + boost::ecuyer1988 base_rng__ = + stan::services::util::create_rng(random_seed__, 0); + (void) base_rng__; // suppress unused var warning + static const char* function__ = "model_linear_namespace::model_linear"; + (void) function__; // suppress unused var warning local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - // suppress unused var warning - (void) DUMMY_VAR__; + (void) DUMMY_VAR__; // suppress unused var warning + try { - int pos__ = std::numeric_limits::min(); + int pos__; + pos__ = std::numeric_limits::min(); + pos__ = 1; current_statement__ = 5; - context__.validate_dims("data initialization", "N", "int", - std::vector{}); + context__.validate_dims("data initialization","N","int", + context__.to_vec()); N = std::numeric_limits::min(); + current_statement__ = 5; N = context__.vals_i("N")[(1 - 1)]; current_statement__ = 5; - stan::math::check_greater_or_equal(function__, "N", N, 1); + current_statement__ = 5; + check_greater_or_equal(function__, "N", N, 1); current_statement__ = 6; - stan::math::validate_non_negative_index("X", "N", N); + validate_non_negative_index("X", "N", N); current_statement__ = 7; - context__.validate_dims("data initialization", "X", "double", - std::vector{static_cast(N)}); - X_data__ = Eigen::Matrix::Constant(N, - std::numeric_limits::quiet_NaN()); - new (&X) Eigen::Map>(X_data__.data(), N); + context__.validate_dims("data initialization","X","double", + context__.to_vec(N)); + X = Eigen::Matrix(N); + stan::math::fill(X, std::numeric_limits::quiet_NaN()); + { std::vector X_flat__; current_statement__ = 7; - X_flat__ = context__.vals_r("X"); + assign(X_flat__, nil_index_list(), context__.vals_r("X"), + "assigning variable X_flat__"); current_statement__ = 7; pos__ = 1; current_statement__ = 7; for (int sym1__ = 1; sym1__ <= N; ++sym1__) { current_statement__ = 7; - stan::model::assign(X, X_flat__[(pos__ - 1)], - "assigning variable X", stan::model::index_uni(sym1__)); + assign(X, cons_list(index_uni(sym1__), nil_index_list()), + X_flat__[(pos__ - 1)], "assigning variable X"); current_statement__ = 7; - pos__ = (pos__ + 1); - } + pos__ = (pos__ + 1);} } current_statement__ = 8; - stan::math::validate_non_negative_index("Y", "N", N); + validate_non_negative_index("Y", "N", N); current_statement__ = 9; - context__.validate_dims("data initialization", "Y", "double", - std::vector{static_cast(N)}); - Y_data__ = Eigen::Matrix::Constant(N, - std::numeric_limits::quiet_NaN()); - new (&Y) Eigen::Map>(Y_data__.data(), N); + context__.validate_dims("data initialization","Y","double", + context__.to_vec(N)); + Y = Eigen::Matrix(N); + stan::math::fill(Y, std::numeric_limits::quiet_NaN()); + { std::vector Y_flat__; current_statement__ = 9; - Y_flat__ = context__.vals_r("Y"); + assign(Y_flat__, nil_index_list(), context__.vals_r("Y"), + "assigning variable Y_flat__"); current_statement__ = 9; pos__ = 1; current_statement__ = 9; for (int sym1__ = 1; sym1__ <= N; ++sym1__) { current_statement__ = 9; - stan::model::assign(Y, Y_flat__[(pos__ - 1)], - "assigning variable Y", stan::model::index_uni(sym1__)); + assign(Y, cons_list(index_uni(sym1__), nil_index_list()), + Y_flat__[(pos__ - 1)], "assigning variable Y"); current_statement__ = 9; - pos__ = (pos__ + 1); - } + 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 ***"); + } + num_params_r__ = 0U; + + try { + 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 ***"); } - num_params_r__ = 1 + 1 + 1; - } - inline std::string model_name() const final { - return "model_linear"; - } - inline std::vector model_compile_info() const noexcept { - return std::vector{"stanc_version = stanc3 v2.32.2", - "stancflags = --allow-undefined"}; } - template * = nullptr, - stan::require_vector_like_vt* = nullptr> - inline stan::scalar_type_t - log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream* - pstream__ = nullptr) const { + template * = nullptr, stan::require_vector_like_vt* = nullptr> + inline stan::scalar_type_t log_prob_impl(VecR& params_r__, + VecI& params_i__, + std::ostream* pstream__ = nullptr) const { using T__ = stan::scalar_type_t; using local_scalar_t__ = T__; T__ lp__(0.0); stan::math::accumulator lp_accum__; - stan::io::deserializer in__(params_r__, params_i__); - int current_statement__ = 0; + static const char* function__ = "model_linear_namespace::log_prob"; +(void) function__; // suppress unused var warning + stan::io::reader in__(params_r__, params_i__); local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - // suppress unused var warning - (void) DUMMY_VAR__; - static constexpr const char* function__ = - "model_linear_namespace::log_prob"; - // suppress unused var warning - (void) function__; + (void) DUMMY_VAR__; // suppress unused var warning + try { - local_scalar_t__ intercept = DUMMY_VAR__; + local_scalar_t__ intercept; + intercept = DUMMY_VAR__; + current_statement__ = 1; - intercept = in__.template read(); - local_scalar_t__ beta = DUMMY_VAR__; + intercept = in__.scalar(); + local_scalar_t__ beta; + beta = DUMMY_VAR__; + current_statement__ = 2; - beta = in__.template read(); - local_scalar_t__ sigma = DUMMY_VAR__; + beta = in__.scalar(); + local_scalar_t__ sigma; + sigma = DUMMY_VAR__; + + current_statement__ = 3; + sigma = in__.scalar(); current_statement__ = 3; - sigma = in__.template read_constrain_lb(0, lp__); + if (jacobian__) { + current_statement__ = 3; + sigma = stan::math::lb_constrain(sigma, 0, lp__); + } else { + current_statement__ = 3; + sigma = stan::math::lb_constrain(sigma, 0); + } { current_statement__ = 4; - lp_accum__.add(stan::math::normal_lpdf(Y, - stan::math::add(intercept, - stan::math::multiply(beta, X)), sigma)); + lp_accum__.add( + normal_lpdf(Y, add(intercept, multiply(beta, X)), 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(); - } - template * = nullptr, stan::require_vector_like_vt* = nullptr, stan::require_vector_vt* = nullptr> - inline void - write_array_impl(RNG& base_rng__, VecR& params_r__, VecI& params_i__, - VecVar& vars__, const bool - emit_transformed_parameters__ = true, const bool - emit_generated_quantities__ = true, std::ostream* - pstream__ = nullptr) const { + } // log_prob_impl() + + template * = nullptr, stan::require_vector_like_vt* = nullptr, stan::require_std_vector_vt* = nullptr> + inline void write_array_impl(RNG& base_rng__, VecR& params_r__, + VecI& params_i__, VecVar& vars__, + const bool emit_transformed_parameters__ = true, + const bool emit_generated_quantities__ = true, + std::ostream* pstream__ = nullptr) const { using local_scalar_t__ = double; - stan::io::deserializer in__(params_r__, params_i__); - stan::io::serializer out__(vars__); - static constexpr bool propto__ = true; - // suppress unused var warning - (void) propto__; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "model_linear_namespace::write_array"; +(void) function__; // suppress unused var warning + (void) function__; // suppress unused var warning double lp__ = 0.0; - // suppress unused var warning - (void) lp__; - int current_statement__ = 0; + (void) lp__; // dummy to suppress unused var warning stan::math::accumulator lp_accum__; local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - // suppress unused var warning - (void) DUMMY_VAR__; - constexpr bool jacobian__ = false; - static constexpr const char* function__ = - "model_linear_namespace::write_array"; - // suppress unused var warning - (void) function__; + (void) DUMMY_VAR__; // suppress unused var warning + try { - double intercept = std::numeric_limits::quiet_NaN(); + double intercept; + intercept = std::numeric_limits::quiet_NaN(); + current_statement__ = 1; - intercept = in__.template read(); - double beta = std::numeric_limits::quiet_NaN(); + intercept = in__.scalar(); + double beta; + beta = std::numeric_limits::quiet_NaN(); + current_statement__ = 2; - beta = in__.template read(); - double sigma = std::numeric_limits::quiet_NaN(); + beta = in__.scalar(); + double sigma; + sigma = std::numeric_limits::quiet_NaN(); + current_statement__ = 3; - sigma = in__.template read_constrain_lb(0, lp__); - out__.write(intercept); - out__.write(beta); - out__.write(sigma); - if (stan::math::logical_negation( - (stan::math::primitive_value(emit_transformed_parameters__) || - stan::math::primitive_value(emit_generated_quantities__)))) { + sigma = in__.scalar(); + current_statement__ = 3; + sigma = stan::math::lb_constrain(sigma, 0); + vars__.emplace_back(intercept); + vars__.emplace_back(beta); + vars__.emplace_back(sigma); + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { return ; - } - if (stan::math::logical_negation(emit_generated_quantities__)) { + } + 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 ***"); } - } - template * = nullptr, - stan::require_vector_like_vt* = nullptr> - inline void - unconstrain_array_impl(const VecVar& params_r__, const VecI& params_i__, - VecVar& vars__, std::ostream* pstream__ = nullptr) const { + } // write_array_impl() + + template * = nullptr, stan::require_vector_like_vt* = nullptr> + inline void transform_inits_impl(const stan::io::var_context& context__, + VecI& params_i__, VecVar& vars__, + std::ostream* pstream__ = nullptr) const { using local_scalar_t__ = double; - stan::io::deserializer in__(params_r__, params_i__); - stan::io::serializer out__(vars__); - int current_statement__ = 0; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - // suppress unused var warning - (void) DUMMY_VAR__; + vars__.clear(); + vars__.reserve(num_params_r__); + try { - int pos__ = std::numeric_limits::min(); + int pos__; + pos__ = std::numeric_limits::min(); + pos__ = 1; - local_scalar_t__ intercept = DUMMY_VAR__; - current_statement__ = 1; - intercept = in__.read(); - out__.write(intercept); - local_scalar_t__ beta = DUMMY_VAR__; - current_statement__ = 2; - beta = in__.read(); - out__.write(beta); - local_scalar_t__ sigma = DUMMY_VAR__; - current_statement__ = 3; - sigma = in__.read(); - out__.write_free_lb(0, sigma); - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, locations_array__[current_statement__]); - } - } - template * = nullptr> - inline void - transform_inits_impl(const stan::io::var_context& context__, VecVar& - vars__, std::ostream* pstream__ = nullptr) const { - using local_scalar_t__ = double; - stan::io::serializer out__(vars__); - int current_statement__ = 0; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - // suppress unused var warning - (void) DUMMY_VAR__; - try { - current_statement__ = 1; - context__.validate_dims("parameter initialization", "intercept", - "double", std::vector{}); - current_statement__ = 2; - context__.validate_dims("parameter initialization", "beta", "double", - std::vector{}); - current_statement__ = 3; - context__.validate_dims("parameter initialization", "sigma", "double", - std::vector{}); - int pos__ = std::numeric_limits::min(); - pos__ = 1; - local_scalar_t__ intercept = DUMMY_VAR__; + double intercept; + intercept = std::numeric_limits::quiet_NaN(); + current_statement__ = 1; intercept = context__.vals_r("intercept")[(1 - 1)]; - out__.write(intercept); - local_scalar_t__ beta = DUMMY_VAR__; + double beta; + beta = std::numeric_limits::quiet_NaN(); + current_statement__ = 2; beta = context__.vals_r("beta")[(1 - 1)]; - out__.write(beta); - local_scalar_t__ sigma = DUMMY_VAR__; + double sigma; + sigma = std::numeric_limits::quiet_NaN(); + current_statement__ = 3; sigma = context__.vals_r("sigma")[(1 - 1)]; - out__.write_free_lb(0, sigma); + double sigma_free__; + sigma_free__ = std::numeric_limits::quiet_NaN(); + + current_statement__ = 3; + sigma_free__ = stan::math::lb_free(sigma, 0); + vars__.emplace_back(intercept); + vars__.emplace_back(beta); + vars__.emplace_back(sigma_free__); } 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 ***"); } - } - inline void - get_param_names(std::vector& names__, const bool - emit_transformed_parameters__ = true, const bool - emit_generated_quantities__ = true) const { - names__ = std::vector{"intercept", "beta", "sigma"}; - if (emit_transformed_parameters__) {} - if (emit_generated_quantities__) {} - } - inline void - get_dims(std::vector>& dimss__, const bool - emit_transformed_parameters__ = true, const bool - emit_generated_quantities__ = true) const { - dimss__ = std::vector>{std::vector{}, - std::vector{}, std::vector{}}; - if (emit_transformed_parameters__) {} - if (emit_generated_quantities__) {} - } - inline void - constrained_param_names(std::vector& param_names__, bool - emit_transformed_parameters__ = true, bool - emit_generated_quantities__ = true) const final { + } // transform_inits_impl() + + inline void get_param_names(std::vector& names__) const { + + names__.clear(); + names__.emplace_back("intercept"); + names__.emplace_back("beta"); + names__.emplace_back("sigma"); + } // get_param_names() + + inline void get_dims(std::vector>& dimss__) const { + dimss__.clear(); + dimss__.emplace_back(std::vector{}); + + dimss__.emplace_back(std::vector{}); + + dimss__.emplace_back(std::vector{}); + + } // get_dims() + + inline void constrained_param_names( + std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const + final { + param_names__.emplace_back(std::string() + "intercept"); param_names__.emplace_back(std::string() + "beta"); param_names__.emplace_back(std::string() + "sigma"); - if (emit_transformed_parameters__) {} - if (emit_generated_quantities__) {} - } - inline void - unconstrained_param_names(std::vector& param_names__, bool - emit_transformed_parameters__ = true, bool - emit_generated_quantities__ = true) const final { + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // constrained_param_names() + + inline void unconstrained_param_names( + std::vector& param_names__, + bool emit_transformed_parameters__ = true, + bool emit_generated_quantities__ = true) const + final { + param_names__.emplace_back(std::string() + "intercept"); param_names__.emplace_back(std::string() + "beta"); param_names__.emplace_back(std::string() + "sigma"); - if (emit_transformed_parameters__) {} - if (emit_generated_quantities__) {} - } + if (emit_transformed_parameters__) { + + } + + if (emit_generated_quantities__) { + + } + + } // unconstrained_param_names() + inline std::string get_constrained_sizedtypes() const { - return std::string("[{\"name\":\"intercept\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"}]"); - } + stringstream s__; + s__ << "[{\"name\":\"intercept\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + inline std::string get_unconstrained_sizedtypes() const { - return std::string("[{\"name\":\"intercept\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"}]"); - } - // Begin method overload boilerplate - template inline void - write_array(RNG& base_rng, Eigen::Matrix& params_r, - Eigen::Matrix& vars, const bool - emit_transformed_parameters = true, const bool - emit_generated_quantities = true, std::ostream* - pstream = nullptr) const { - const size_t num_params__ = ((1 + 1) + 1); - const size_t num_transformed = emit_transformed_parameters * (0); - const size_t num_gen_quantities = emit_generated_quantities * (0); - const size_t num_to_write = num_params__ + num_transformed + - num_gen_quantities; - std::vector params_i; - vars = Eigen::Matrix::Constant(num_to_write, - std::numeric_limits::quiet_NaN()); - write_array_impl(base_rng, params_r, params_i, vars, - emit_transformed_parameters, emit_generated_quantities, pstream); - } - template inline 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 = nullptr) const { - const size_t num_params__ = ((1 + 1) + 1); - const size_t num_transformed = emit_transformed_parameters * (0); - const size_t num_gen_quantities = emit_generated_quantities * (0); - const size_t num_to_write = num_params__ + num_transformed + - num_gen_quantities; - vars = std::vector(num_to_write, - std::numeric_limits::quiet_NaN()); - write_array_impl(base_rng, params_r, params_i, vars, - emit_transformed_parameters, emit_generated_quantities, pstream); - } - template inline T_ - log_prob(Eigen::Matrix& params_r, std::ostream* pstream = nullptr) const { - Eigen::Matrix params_i; - return log_prob_impl(params_r, params_i, pstream); - } - template inline T_ - log_prob(std::vector& params_r, std::vector& params_i, - std::ostream* pstream = nullptr) const { - return log_prob_impl(params_r, params_i, pstream); - } - inline void - transform_inits(const stan::io::var_context& context, - Eigen::Matrix& params_r, std::ostream* - pstream = nullptr) const final { - std::vector params_r_vec(params_r.size()); - std::vector params_i; - transform_inits(context, params_i, params_r_vec, pstream); - params_r = Eigen::Map>(params_r_vec.data(), - params_r_vec.size()); - } - inline void - transform_inits(const stan::io::var_context& context, std::vector& - params_i, std::vector& vars, std::ostream* - pstream__ = nullptr) const { - vars.resize(num_params_r__); - transform_inits_impl(context, vars, pstream__); - } - inline void - unconstrain_array(const std::vector& params_constrained, - std::vector& params_unconstrained, std::ostream* - pstream = nullptr) const { - const std::vector params_i; - params_unconstrained = std::vector(num_params_r__, - std::numeric_limits::quiet_NaN()); - unconstrain_array_impl(params_constrained, params_i, - params_unconstrained, pstream); - } - inline void - unconstrain_array(const Eigen::Matrix& params_constrained, - Eigen::Matrix& params_unconstrained, - std::ostream* pstream = nullptr) const { - const std::vector params_i; - params_unconstrained = Eigen::Matrix::Constant(num_params_r__, - std::numeric_limits::quiet_NaN()); - unconstrain_array_impl(params_constrained, params_i, - params_unconstrained, pstream); - } + stringstream s__; + s__ << "[{\"name\":\"intercept\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate + template + inline void write_array(RNG& base_rng, + Eigen::Matrix& params_r, + Eigen::Matrix& vars, + const bool emit_transformed_parameters = true, + const bool emit_generated_quantities = true, + std::ostream* pstream = nullptr) const { + std::vector vars_vec(vars.size()); + std::vector params_i; + write_array_impl(base_rng, params_r, params_i, vars_vec, + emit_transformed_parameters, emit_generated_quantities, pstream); + vars.resize(vars_vec.size()); + for (int i = 0; i < vars.size(); ++i) { + vars.coeffRef(i) = vars_vec[i]; + } + } + template + inline 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 = nullptr) const { + write_array_impl(base_rng, params_r, params_i, vars, emit_transformed_parameters, emit_generated_quantities, pstream); + } + template + inline T_ log_prob(Eigen::Matrix& params_r, + std::ostream* pstream = nullptr) const { + Eigen::Matrix params_i; + return log_prob_impl(params_r, params_i, pstream); + } + template + inline T__ log_prob(std::vector& params_r, + std::vector& params_i, + std::ostream* pstream = nullptr) const { + return log_prob_impl(params_r, params_i, pstream); + } + + inline void transform_inits(const stan::io::var_context& context, + Eigen::Matrix& params_r, + std::ostream* pstream = nullptr) const final { + std::vector params_r_vec(params_r.size()); + std::vector params_i; + transform_inits_impl(context, params_i, params_r_vec, pstream); + params_r.resize(params_r_vec.size()); + for (int i = 0; i < params_r.size(); ++i) { + params_r.coeffRef(i) = params_r_vec[i]; + } + } + inline void transform_inits(const stan::io::var_context& context, + std::vector& params_i, + std::vector& vars, + std::ostream* pstream = nullptr) const final { + transform_inits_impl(context, params_i, vars, pstream); + } }; } using stan_model = model_linear_namespace::model_linear; #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::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; } diff --git a/tests/testthat/fixtures/constant/constant_baseline_output_multi_ind.rds b/tests/testthat/fixtures/constant/constant_baseline_output_multi_ind.rds deleted file mode 100644 index 1836e7193e349e3721f6b5f953c3f0fbed606b67..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 18764 zcmV(-K-|9{iwFP!000001MS^;RLkSsTapJc9RM*u1dB_~~8`gv!xhLA1x1jKe)$?)MAkKRQ*3b<|vW^K0=0`uq5^ zIi*0ZDOUNrC@iBi}f{5>Q$E~h_I@xJ1Ti}wICwkLR za%c0SXY82%u7KaB{LH#W!CEmlmj;~9wuN#{VH9XsxnK;x#)(LiYXX>W29q&+@WZwTc* zec46fh7bEL+QW?*FWj;*&QXQ=a;#7wd_mQGlwaEVHs1)bg-=!AH%R|sCy##B0bySy zI*`BompWVnh^yMd%ekC;R93AH}e|jnk_owEZ#PeF@ zrzVbL8Q)LXY%H|65SH|ZDtMy3d45}qBD@jN_N^1;A=E0BO^7#{+4(1uJhHLfb3u8y z51+R&<}tOPwO)W0FTF!?Uut$P`8tSmsSTFT5y5_|ZkTI|pGNsWpzKaJ^e^?!Urx@Y zxi)+`xffY1%Tr27yv;L|A4(kQeT#crRl37;;X{lg89=w|MSu548@^cn{Z7_J4sG2r zy&BSV{5uX)>mrog^^R|ZX9CP7Mxbtibk`MV9Z{w(3Ny9tJjq9U6Um1k*CK9sda+6e zPE8#dkV3i6_&0tp#HS0RO`aldO}yRd3O94Gx-Nv;JFf33Hokw9A(}U(*VUTU{0~QNHuMHeCX`uGll34Ao?lXPdMKuvAONsg-mi@lk*LSNqe4KSMQ8}xk;=S_CqJPV(Heb+M$b@}_9aB{O&(EB-I*wwDW z?Gz`keahnl;S{HU!3n=%8z`Uj>R>j-IomdJ*2YPSlfSy6YkeQZ$ycSo=O~VP*?r5o zpTGmsmF~u9SF>Ym=L3v$_4vHrVv2K)@{jB4n1{#2QbKPn`iB`-sIQ_p1-HMc(66RA zg${&{2VFwDgrSWOb|M~dJw?@`UhI9C<_pBUUc81^A?ITM^9>kRn6BT;j(PNpk2)@c zp9S8t31a+}i&GiF7(d}B-)UXM9kbP$>#(kqOCV$d)yx5MRnB}c)&Bmk*l2G^Skz{MNrINY76o^N8|kHH!+N}N-ZcT7jfJ< zwU;KS7iX#K8OQw72lsdJBUTv|W_<{?twohd{gSWcXR$xNpL;^DZp3<;?wyZOp*ZKw zt7U9Pp65#5{rJNiA`*t{>Ur7L*BL?RF@$4;rXWS zxOlYlHZllSM*m|}?c)K&5|hniuMuComVPJ;d8uuBeee+Ci2cq#L*bl3@w;{y?}bqE z?Gv!FWA8WIt2uK+n71#?$(V=7Yv+azLyULET7c4oYy70m zHo>3M0q?$}{^BKZjip$hh1@%T5%g0jKK|g%0S zMEgS?ELOPhd^Nsn7os0`?vCjk+-q(<4y&|J7`J)tvBD4kc_*~2$~C(t<#xlC1?RcA zXjwJen^d@EXjv7^uvMA!;NfFOpUpyj&B2=V9ki^fPo1XrQ848C`cMU0*4tsH7||=V ztcF*v($^|!S@j}QdL`x1Txso5w6EK4`g+kxT2|@fw|=utXjx?@#TJjQ(@;XNN98 z{|6DGH&sz@W_;F-mzMQ1b&jj{Ma-wndn0HO#;dlC7}`e5dSw~kKIw__@rds7(ZCGrV7LDvD@68@mw#p%@}lCPErju3 zGs_NSHDdgY+f(U0sK2>;Yz@}gFmOO3Y#-vPVmBx3^G)cUo=!#Nr+Vt%z+vc_Gnn)c z<5w-43RsQt7CdgeiTzYZH+3f1!j$gT)yYH)$?jJ$u39t16`uX1ey$E4`QS+jVBcMW zI`6Rlnq_9`=Kfg!ccH5jIGR#uu3%XQAxHvZ3m*P~_?M@_}^ZubJuh z>GETY@Al2+`3Sjh{`AINxMKX_6|AG?U65h59xbcso8VXT`&id2*5SAsT2`%uRn#T7 zzu!r>@cE)AN@LLKq3iGcv~Cf)oA!&}wC?$=L+m{LhznDr`K4*y^ZMRRZ@&g3ca=n` z(7NaLOKocV2hq07S;A!fABzM&1jj|GNgz+(&vv9qu+^yK}k7_Y`NC)Eux zRU_mygnsR&!yCUsk*-2PYn1;Qbk(K7JlW+FvtgU;!Sz$5-0ga4EZT8-Ww|~<{H=Ib z1rOF48vG!U6LD1F_L?MkRIGeD6bi*Z^(O81Oa?eNqhH>tv9L;5b}4glI;j^(DrZ1Z zDW}p*IVI%$rp*+(O*hyxHS^7=VRV{vcG^z z=c?y0@TF2=A=EChWHE*7#Pa3W!IdrNmTQo8-HQI)hyHRwA%k}in>Ge+(nEYjYjK$Y zJf6L{k00e{?|;Ai4mu@mUc(1pnFMj5op7B_nrtm%{+x-(5yX9up2i?g!bNLYbdI2W z*>c5BcdTD;FQ={oVgVPWS2`HC%Jk5{T*M&>C(mFKydK+O@1v36M$D095N+D7W#eyx20>zNU; zBcxt6YNID=cw7QXfuQU678MXx5s;zAM*SaY1h!^7c!g7XMKo9^7?*BPnZL=$_sU9(RGaT6L zurY$HyFN#07TN!D)kId(FCxf>oL8~Y$L{^G^Wu)A&+rw;${QhM{6*fD@vz2t!Mtmv zpW~x#5v$33KKNj%znBRbC+zxclK=W&?J4Q7 zd5rBpZxOpk*_o2*D!~H++gxTRivk=fz6$A9h+8?(bH;_Kn2W@g7hm%4+C%9$MuX}6+1Ud#?F zeO>KU>dcOvOmTm|JIwCOq5JPH(q?|#7}9l;XBV?q@W}Pgk6oF4{Yx%=JoAy+SHA3p z$QFHOAIA?1wfq~*-dBycPmR1}_EtqL802eY_EyAZn)>`<_HCwl3RqX6+|DFA_${-4 zW#eVDt-F|gJ<{dQnsbDfXtT^kez#+gKPOlO& z(6eWb9RI3V&Qs1DIh!!|$Hm3Wkx>2;XJ0MmNWwAmS7NuBBiR!n3toCMN1l9G?^iL# z9OId_RGOECIXbj+ZOXlD=ICVaicWnY=IGNcX6c>Jn4=XAe407d%+W_D*Ch27Fh`&9 z-g>(rmpMvX>-naXn>o6^O?Qv|BIc;?SF@*mEzHql8=tW;t}sUrvgatnm2k1Ji8G5zfPEK|S`&;gKfC3HD*;aMM)j z<#kca;fjXEgPU@h!v(L6N3Hsp!*##)Q$=nuhhG{`{SM}54nIhy|5r)Ou{|nmj4lc0*rHUOu^ODi$n1e@+H~f4 z{py#I*XA+DpWFRWKU%>YZ!o_0g{^}*{<<|gw#S`0o=qidKMrJ$_wLvE%#%6hP+_Mj;=mj` zB6cD;XT#sWpUh(WAU&EDP0gCMR*&Duj+!MDe_ALinqt?hpU{04M6qwF-ZHt{l49RH zuzs=Rb&B0y=Sd&uHHzIu^2^ea9E$xo+f-VKDK%@CcFWk+DT=N8^ zA;nt3Cmx8ePgx(1=Va&{pja8fi!6CvQmh{8Q%?G+6sxCB+1tto6kF)n z36|3vD7J)v>Fk(MYSx@Z`*MXZQtT`4`M=(HjAAc5p!DbjzTQ{K3SqittJzNmuvCrW)#d&!tJLS<$aULzU(C!qcIM3d=-+gET`B%-~2T`zntP=32Chr;KsSMuK$y3MsbJ;kBl9zqBsPmUwr;4 zLvgHp5Y1xl3Bw)aBpDQYonvL75o}O;D5_is2Yr3Fi&5gqBuV3(O%rZ`G0b%^4ru#aUA%Pw!>Bh z_d==R&Eu^UdqmK5nsXAxvD7L2iAOl*kIPlLV?}ZBcqOi}VWT)^XMQZS!a2{|o^PHk zPI1h)O}qbS`tPq#95=;fY#bS+Int`;m0e}0Ij&SM39{y?;;COrSBUxnfFUPtq8br-I|8VrY!o-LIl|Y0wyb5|6}-n`n%# zFrLg4{xnA8W|>*~Wi&=z)=8}|$7qaS)yH@79i=hG15{VO6r?d;zi6b|-Jx5AKG1P~PHPTQ-gHN<(*O&l4KsE!V4}ihP=l ztVR2Q^B-t70;U@8nhj`-&zJLaY$7oKTwzBII~s%exsW2|9&-oh)i1H2YbmvMcd+3xr6t$h_RO1!R_6hg=$u|i!+ac{^ zdK;a3gwDfxhpsgD{B5x*NSeG`RtYq>@r_M`t|ZLb&0 zp`x1LX=_;O|KzI++E?BVI6MV|uRqWHgz}wzPsaVwFK5=V;^(kSc#oDK^j@pn7=!xV zN%;?yp}%DG278p7=^JyMLOl6FrllQze(B)IkMY8|3q;gN`@j_EJ!lu>;OzMZ?ilZB zYC`#km)pBq5VwsCi@b&3zs>8sjPk9vQdB+S7soz(UWb>uR=pte#|d=58G~nhK4cc6 zo!*;*D~Dj1tnC!~oqX50u4NGnY4EMP1*3hJ#$&xF%`^7w!2V7)bRWpJMEg1H$r(k6 zJMxNIN&Dc(TJ&O=)&DeI4)vyUFZ-53@0Aaa&Vfd!%RS|x&9&kQGOzZ8FIOU5UDChE z8?N8OF4_kbg7(kfigAtyyZ*F+np=zV&!hYyonwN`Y=Drk`4QR#Ty!?Ndve;LXa}hArBKx}~KT_`t z-*|;fcfx1Fy7^?Bi$T1jaj?E9N!}UdDOXss{veKMuhi>6yzumn#(gk9=#D`w?%SmB zlgKmh>r##>%;&%C&a3;FFF-k4SVsx{#Fx7+oJZ#AymuJu@>ia`8%^$qkb(}YHtNU3 zmUxIGp8x7y&;a69oO6bUh`&FVieMbcD;{^GQGc@QedfZy--&`!eN6>x8>OI}y)H$t z2|kDm&o@PRB`B$yzM0?0>5@uHb#n?k~-oryH_{yTuu9tsHkpt`zND^;GxkP{v z9s5ukPU`k@LVR+~ulBnzN-DsT%s<^ZX*^*?kNp*s<)zFo9g0b20hX?P2dv59WBhP#x~zmu3jtzMr9wUoTH zzCf9|rYi5CMpH`SA-Kr$OW_BM=kva-lFVzvejs@o<*&VzEB7KE6f=|Qf_-QG%}Kl7 z_yW~4u)s!sG70Tm=j){&gUMfeVm(M6{%l#r3)R2azNjGe=lV-H(S9sd=jL|!Gbz}X z>@)SAScD%8@SqEal6zBMog<6(*G2j&ZXm95iTZ?mDSg+g&UQxmhh)C>E6MtQ_a>*3 zcIJ84e#2Kc1>`Wka^d>v%@b%}xi1KzvMF9!2KKASEJK)DK z?Zt!STx%8eai5f~_(bg=f?rl8*^&F(rse9s6>-eu9Z_;#MH`n!l5ykQA~|M3{fl4T z*Fkv|vGqrxx!ImLb745=?lY6|+udQzSOW|0OAoJ?<&H~GrqogW51eaMc4#DvOdPs7`56Wt#3wSWFiYJehjwa@UC^Jb;EDqWwu;totH^ zLf|^r!$-EkLSw04XbCi_uwEuDfp@AJE7lX>r0Rgv{Po1QNi zNb)k`ExMWH&p+52pQqhb%!{gcU){NOPhMxC{^xvKF>>xY3pK8ga~|86k>w5LCoeTx zk@16jRJF-DUTqv-L-u#>-XDD4cB?l@lw-cGigbS|lIQa!m2tS=-AhVZMM%5*@wc+t z(T{)7*RvjRz(`82Ep#%NJF6B(w9`)BZEs%=+ z`<*CWj^h^>F{Kov!;~(+wSiCK4HCbh+%#24aS9$?XmwbFQoK65?xn*aO7YU$3XNQG zO7RNw!TndUXuky)%N(vUZ~9dS3+mK`L}BBO9GV2$$-Cb_eh+bTL;Hdt*eahlRSg&X zy6d6>51Tc88G&h9Lz^*AblJMTBwzGnEEd0$ikMABE;$16)~D1^8se>TUk=N`$BVZs zXrY{&+kSEl)|n8NZ4rg?Su!aRhHyzwc)bJaSFc*RGyw5li8malpvB_D3}<*Z^?l8^1JMz93u`Yz54pZ5&N8Cli}rnfuY_G!7$r9Go%;e3MQU! zwL?4KoHhrNU)Oop18&3Z5B>E?z6z!nblQ=2d#_1_L&M&o3LmmRgNw{(P;UKn;9Qt> zCZgmq^hm7mE{A3;*Zej?^TJFq6U_I`r%!P`Vv%8Prw8!0;ncHT@J(0nr$1z0tizqh z;T;pn?hj~R{('r306M$1WkSr7j@(*AL{`@X|axjkHA4Ek*OQ#BjwnsfE6@*1*_ zlizOLKs<{}(MBGwPjD>`B=c;R$nhliODR>wALGZUns?M9)-YI6L-vz!Nl3Vi%*P^H zpMicS><;!MAkN#d|I!zje1N}tCFxHWI)Zy~S)X}HhMePG!TM(#&|dQGgZ*uY@407x zp#S|&l%zIAC%y`SPt9IPn8LPQrd4<0qPd3sPH+|TbkKWBN!oYFajiI|w5(r(El?2g z?o;)VXHnnbBAk%`3v;8?$#~z)dIs81&uLb@p%u!k@ijt!sgfhfzk^|2(7P;Nc-lhx z3qNeuyvM!@ey!8=K8E&-^bdOFL91gPKQE))SuZ1UC*tE+g3&*0F^;sb5`AAfnU7=e*?hA8Ugd2^;ESO3Rkg6FQ#9ZP zthwZWejypxs#{Qi^tW@(Bm1G#g?THX?6*U~K4f2S7IKhw8Tj&(Z-XzQ-K7k>ah$KzK;RJ@ zPT2ZNPwg~())dLH2sTOmPH%@dD3Se@WPODuQX23}cG12jj3X!DpSK+G%Zwr)COPj0 zk@sZ0?e>P>wP5+7FfWSahkbK=0a>3_wC6SW*mPf_B5cX;{!@){#J*%$l6`*+O3xZ5 z_eWP-KMbmxovu6x*9I7@c>>pMzFAB1rfDU*Qwq8dZ1f{}o|7fTEl18Jqr&?cVvq4v zDVpS7Hl5RW0Y4X=-iCEZ^ByV4A@iQ52q89+t1CeM z{TB1dJ;(j>?Rk+qOh+tSl3|bqm$5(HkA3*9eJp*@4)r&F^thIjc_vy9D!>zpU)6C= zzF+j{7ch^X*r}hpOrY`Sy<(4H2z~dRH>kJp)UUxg_*G?YcE5&N$Otx$%0^*cKZWz}cWp=9G{skc2UgycEp?U$cJup|1P^-lDhd*bVJzKNmiSF_qMjZoq z_lR`JM)+W~J0phV>$2iGoWF0_{Xl(uKKNelNwmj1@I7djmU-@)292U_m(tU+G=ya&IZzL?PUBKlW1AcQ_9} zSJ^`EZ76Twf96av%szQjZ!1*Wzd(rxzWg=0JAmA;`N7hLvC%R^lahFM)mdE?`)t4K) z+)VDzwIa?ba?je&^2#7ic@SqK2}L+%y2W1=$70J&P z5LfEw>99h}eMaX);Kq_ApDUoK{@&!5Q2por(M@no?b~-4C-j+eWfMDM0qX?S1n467 zx_CX@u(RZJ4BQl)FNbwqWMiYB$9$oY>Y=(6?3|_V6o>jVexhTy5kG$K;8Rcf?GnyO zgCb5lE%w6Aj@lPIA-zUTR}Agi#>S+UBlfn9&>Mh;kuSe5gt)f`QX_s36Sl-vXH=jT#b z;O(13TQ5V`r1wm5$Q_hmgL4n=By}PcBZ_@(Q|bWA7G%k1llIoCVLm zWfUkwPqq^C(=e=ld@vinXngnaFbw=SYpW@IoSj&60^YN~*slho^sPmA!uMYf8siUy zI@zstZ+zfwaT8rD7`tfy3ORUFxN<5H=1CarTLo>Oj`|3~D>-MXPr`zMKkLO|a#z{C zAMpClpL-K1N|$Yp`bAH~j)7wGY&|TM`XY6Pw0G@O@_@O%Pu7OP6cM@OHl#m$eWNyvzqM@+ znJ00}p}zg_VcreJb!1&q7n{hqcap`88(@UaiTjsHe|DEE)nuQ(gJ*Ek{E+PL?QsngcyTx*DTm~_@bJ}X zm^rWL+%P%s_+j2wvaXXW1)boD6G_sNWIb+tzwiZy&V}=r{G4HZsb&PpUvk<+@_BOJ zHb+b3VTN1sTrzLjQ@#pP{z_A7A3v-zaw#U~>+RnqPR{>4|7bJ0FR!9nj>^DF@tn2X z@bYio?IgdU8!X>3VRY$L@2zBB*|5OnFve&ZJAJ4_X_w2qq-&9VhF}{7@vU0mB8ppB*RjTdD4U36t!m#cIj9jL1dllKY)Fc$eI} ztpVqL=>PprHa<68wR`j;wei`=-pJ245HGCH&Iy4|k7z>`a9wl-T^i0`@>$Ivu9l}% zmO_(nF%qp%P-dx*JT$r_>OBf&Vy?6(k$!#-hFs9J^2n^Ykap%<=R>&MVt!ZyREi2a zb`&mJ+3P6<%^O#5x4=63Y`%tyBVM7c^+yhF)Q*l`1l3|5Tv!3;>=R4igr}FTYwUu2 z0lXJn;oOlq*VaIr5_uILj5B66ky?OwZQE<#$7J0rMIYKjo%R&}GjONwm*-w^hi>b` z9%yhyTIwoPzC74t4%I94xP+j*l3qYJ)btg*Udun=FGz7b zauRN5kw3u$C7uh^CP0nLMS-tLdpge-CRAJ@csvQNEZ;XILDqFlYU^sqb5eUU8)~i5 zKIskDZ++fTP3C{VF1Hs-XP8N9LUI2WFF!)P6+;qra9{9lt9y{ad0J>Tv~~*|_ztZy zl$B$k<%?@>^!8ii zKJ25JlYDGklpHw(MP>VMO~75-mR^$~=WS?O8bHqF%7f2jzRgXy`CCYSy*MICzimlO zSxKmWT<>QN&gJt)wdbCQIr0{?Op^RtJl#yr!|LNn;Xrafo|N>GJV>XoJ0(KNhfn1T ziQX1#7eduNxl74BdmRt?m&2_M_P@z}nT0=ylKW?D_kwR1$2?AXoBQ(nN|6`D^Y=T^+3=i&+CYa^ z*8}71;LE-C=UFHnnpDdzt#HI6CdwS5Fjrej*ayBi8}5A(b}ia(sS9s9(H?NZ(Zd&3 z*ua#AxJo%v|Ij0d39Dm#AH9bas*+;^Fe$R7Wjie4DJm}_{k2&q?!d_lJnMs@6F1Av zRWQ5cvvMn0Po(VFLddkd#REHLh{}F`g=ZEcdzU7$7K97pDRRQcy?ZiCw$5ius;A6yeV}yCG9HNx^-Z3dqlGy z%=jVcy$+U_T{oD9-#77PYQi6$$@U~qz1%qtH(=+2P1ni1J>MjlB))B2vfw#_!FruJ~`15N^^B`G=->Z40 zF!Vs{s1iA!V+!g9FpDG0lH9-g9RtzqWSj^?&7I^vzV^>q0~_bZ2B*LnlPJOcWZmt3 zO=O(Ht$mih(08aZul4VDqFboiydq4M(k-ZJ_ApRF?A{}~?>Kz-=i5ay7%y}!g%|GG zV?2Hg(mUIpeTRoPEQw5qE7SM2wZl+Dmii_r&v(B-2A=QpDyKCCDK{|te2@ywSpeYokxcUPQSL2pSb-yQgSj&oZ-%Jn;gdN+}CJ2v};7u+JRAx_TQ z;?&+ydy=1U?kkDp{O0v1k$qUZ^jL|&TfqiO{LpBnh8&rH?hd(yN67v|u3GDn`_q5p z;~eN1uXJ!1lo_~UuopT#EUwuNPk1zlk#kyZ!e& z(OY{joxhC}t{1WW@{`hAx7fK{X&hc&VcNC`8rQNI{zm<;V}Z3EL@fnwJ2*}6s9FFY zeexB`MLQYUqyF0vXKcz!lSZs6es)3;aiLC>h%0;_>dtQg)41raTCnfi5~p48=0VM| zduXrty-chV@eyO;0v*`!+WP7m_*&EQHkqfP)_Q#k^bYcLS4VqJqiq>-h{u{g4Ryl` z0rk{ZC>Q2k!g~U7SczbS7wjDWo&FrQ7|{wz`Ba>*$Z_~P>QrVl+VB3Rc;G#0H=Hh2 z37>OL{rLkQq))hAfjOrx->^r!xt$|fAE3k!_k{*1ziRN?Y#OF;dW4hwU8S*XwnY6V z4*J-A#FcBSsB+k`IZLktrt%!puORzAWd4)HPnJcv5)1ELE+2xoq_gM~uqcyLB8-&x zRh%a0lgiFwG#5UmxHsFtrqRX^J+PL0>fRpAr&Ms*!V1do`Xa1`^3UrRA0qo17_@WL zC;QwdODFli^ug>8=^y|44*M|lGHvZ|CHYpM9te|tJlhvQC*#EIXIYK-I*Z;ea(+KJ zxQ4&M#-)MAMPckj|yq#yhkHpOPk(l{D z6950dj|8M;u*!k7bfN#4|^*!k1PMY<8EnH{s>fy_OFb1uSZjZb6O zP|qi={(Tw>>s?y259MD>-_EOmgJtW?kD{F8E$f@>h(C_Yc#Xo8Sn-`JVPkK4CRy)u zrJy>pp3sJ6CCaeja{3dp?%U00=QNOh6SnV;!K}WP2m`WS$5l}WNx#HU8#7qNqGI|S zKH;=%wZ?p`iZxLJkZ00$HP#mstLYGu4j)w1z6&MghuF9wk0S`aP9?fPKcCKXXqX`-l~Apt?UHu2AtD*bj3({r8gj z+7i<;PLc8<$IDk?8SnYu$YV^2^43m1cyHPwFd6+@xo@b%ZGnD!$hEjh4ycuo2NX{)IPwC?p za*uwSe=dS`#mlToyUIkJ%n~@PnlPV?8*_c_coqDy$VqVpjKA~Hh1B1%pJ-eLy8|wc zlKV4N{>b1o>F2}vMe^JK!_LYcK9w9g*bZ-{%J>|C5vEo&65khE+jjKtcVaZ6f6-*` zacG$IROTL}PxSr%0>@4EOYVl=Z;VuTAb6!?S;yj<&*JjkPip(2eH+ zZ!vWLX4aEI%7ctfNkcoP)`@GRKi@*Guh1#}CWi(zx;A_K3fy#4{m^pKKd5Q%32559 z*p`fYgw^qFJhaNVF0TUZn{V&ZBm2zTvmgvQ%MPb$L5mw{;`;FD{R1OSWZ%maefgnD zYR1rf((kf|=QbEPz?eJV`l=`#Um^J#Td$1#Qib z1{sldTczZm!E-O`O*WABQ#K58E*FiSZ5V~SLfN9`zlI69u?aAolKi;_2V`e8v3~^6DkyctjYg*g(h0Wu;_YE;%*3gUG$j=7|#^ zdFjs$E+FqfT6qt754+7>CBy!HCwoGxtDA!_!#B^hRJdW^>nvGo*!Y}R^BSC9v+k2U z9M4>mApn1P-B(->N1lH2n@x92PcRL+!c1^YcQc5aQyvCux<41^4q_JW1MZ z%aT|Po1~7MWkosnnRMf~kk=)0^f6>LkjcqGeOJE~pClZ;C=e@6+KDGF@J0Og%z?aI z*jBc@e-9kq(e{vxSA4bQIK~NOZr|z}(2U)SSYELgw3B;&jI z{E$aK{y;z7NwTiPkG#TQXOZ{CkEH&D+%Iw-L;3dQnPi`L^IZVdqNxHs<l0cr zwvL=nu-&!+GOt|i^a`>LrPF!gq&_-xJz4LM>0c7M#8oLAc& zrcu}5?}QO8b4DKTo)InQvM(kZYFKK^k@6Md0x|(`qt>m?e7JV=^kFMVU9$N^+OKuX z9j$|FR<8N<1}>(7Y`O^I!}*b`(oofb&uo&+H+pWC0m;9|wc3>=A4e)Hd`O;JVwU@nSXM>;3~8^qYJ&$E zC#5&slH|dpd~OQa=ciXef9<(y+vBmJ$NqSlf1@&-i z&3}_T+}1iv^0MCNc_~@uM_DuueXkN88$d44gCCFi+`W7kJza&L7mKkp~^MfkLF1DV&-$yS!E+jG&~*QCAD z=~c7HxOD3b76eM=sSQ2Z_0DtY0e1EhI!{6}5(_kgVCF3v*jj zXu^nHG&5|>Hrwy??)=}J=lQ?-JkR%ezR&0T`m6uCGZ2@TBaI+lwSchgrjKoLs0}D; z)LeJdi9Cqx>Zr6XDNH?(_sH6Ca4xWJmr(!bu&OuWdW1*kWv}9GP4NZu-ISzRSjH$h z5cy&Hn3MVHAo4lx@*7-UkM=Ru%3+Vutcm%fu4>NoSIpCYMjLUJK{`LRmg+$Pj&VYf z6-0FVm0y}ZDQ^!3LzrnW@yIRD<`pwypP~#*TrjKOUF}JR?F+`D*bZTspS`xB#lY&T{74U7E_yv0cF30f zVrMaGFevmL6@ zH##skXzW&PK%Jw>p6G3}z?F2WcgO!U8x0dehh~kG22zXs~B|)Q`&FVCMv+^t9_^Iv9rUmG|sjpUwce=_w zPv%5JCtGs1oxXDLa+15pc;SGCNNqw^?LX^>Qsva~UOe-E>rx?Mj5JP%YDCzEa~`kV zqZo+8Zp&fl^|B6s=jgK4+kY*&JL-uFqV<$}PT)<`!+Dwbkq6(T-ZnCTYOZZLQs-e3zgR{ z7(xI}L&uSl@~t9$)~71MiRL{4j6#>+G01(QQkwvFCz*six{2;US})}mEM6okV@)Ol z{>Y{o^S=Dudgw+@;0v_Vd}eaEGkx;f^UzlH?dUJR1*d<`3mQJMR65IVdwHi;#I*07 zeAjI<;e-P0S5m{Br%p=6bP?UA=37c_wf!x{g?jOf+$GepXpah?)(5VtJqM zj`YNr6MW*SkxnsBrQY%M$@zg%T`hb{pBL3Vri*+Y(Mf8<-C2~rakL}m!sQu-6!Yd~ zpLpS%5&lF%7PX?Grb=Mv%7!j;5eO?+-f)~B2JJLV|G6=5jL6rE-qPivfRn$~eWv>O zYTZuH;)90s-KHN#xTM*)6s>a!D)KcC>Iun5MP#JrKDb=cwUtFJH$@8kv3uV#2>j++3+GClT!mZxf-40x zS2Tgye_7;Dn1>Ou*I;x7A$~@p7svClF^INo99W8w%VH;c-4okfV z^X!MfwC>>eYXnn`W_QzQ=R^KMZyozno4qAb)E9j?n5q2GxG1gut7%4j^(paydk(|k z!8xs43)$u|8z>L?&K*n3Mc-CzEQyINv?~6-m~Vu#&OhU0x^*mC3Hh3B1mg-F3oQ%nld+we_NmiA7tFL|p?*j;C<)Efk zg?+jT0yXT-)WV5A`1hvlx3HLrN`}>1%vd<&zb%?L%S!`)X}4|y|Aa@S+?*IEdj+($ zEnaDAZt4%_;J}lW3wisiK~kv#tb6`kj9MAG1hUPFfI4}~AtrbdqxZ5Q;hA{3W_Xyx z2cHBl(`uJ49pJYwi!3+Wy=Ltxe=5AC7i+)Z-1LhaxiLn7*u((;ngh)JWH;gl0Jxvx zM%*F*4-so}biosKGEGh-=;Oqr2|cC>W_Li+VGhCU=pr1px8P=7xX5|tP_B6k161J z(j%beq^jAy=m(U|?oB@cHh1j@Pm$(hips!KvKWZBta+1isP!9&d?Y>-DFByZd(iKM zciRD{+u@TsfvdVhK>Inib8|Evq7TYORLI?;)fq5Eo9bt|VVMe8wbgutU{<|q)jtMQ Bv1|YU diff --git a/tests/testthat/fixtures/constant/constant_baseline_output_single_ind.rds b/tests/testthat/fixtures/constant/constant_baseline_output_single_ind.rds deleted file mode 100644 index 300e10db6290193b6f3de1d2ed3283d9c79315ea..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6946 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 delta 334 zcmV-U0kQtq1J470ABzY80000000WEQVqjokW?*4rWMF0mG8tGyL)>&N7#Ns@fgE-q z<^y6z`wt8-0OmW$pzzrpbk2&l%u@R6pj&s@b#*11gPx(*<(WTR9rPYg?iO=c?VvxE z+tb|D)WJYSbM>h;>l_Sfx-e?NZ<4J8(MC~drYL|b(8 zbcDJyDSer1-(ZF!voJW=;h_gn2MoP^77}e=fT1V;@Ob - rmot_assign_data(n_obs = const_data$n_obs, #integer - y_obs = const_data$y_obs, - obs_index = const_data$obs_index, #vector length N_obs - time = const_data$time, #Vector length N_obs - y_0_obs = const_data$y_0_obs #vector length N_ind - ) |> - rmot_run(chains = 1, iter = 300, verbose = FALSE, show_messages = FALSE, seed=1) -) - -# Extract 100 rows of the samples -constant_baseline_output_single_ind <- rstan::extract(constant_single_ind_test, permuted = FALSE, inc_warmup = FALSE) |> - as.data.frame() |> - head(n=100) - -# Save the output to compare againest -saveRDS(constant_baseline_output_single_ind, - file = test_path("fixtures/constant/constant_baseline_output_single_ind.rds") -) - -#Build model fit multiple inds -const_data <- readRDS(test_path("fixtures/constant/constant_data_multi_ind.rds")) -suppressWarnings( #Suppresses stan warnings - constant_multi_ind_test <- rmot_model("constant_multi_ind") |> - rmot_assign_data(n_obs = const_data$n_obs, #integer - n_ind = const_data$n_ind, #integer - y_obs = const_data$y_obs, #vector length N_obs - obs_index = const_data$obs_index, #vector length N_obs - time = const_data$time, #Vector length N_obs - ind_id = const_data$ind_id, #Vector length N_obs - y_0_obs = const_data$y_0_obs #vector length N_ind - ) |> - rmot_run(chains = 1, iter = 300, verbose = FALSE, show_messages = FALSE, seed=1) -) - -# Extract 100 rows of the samples -constant_baseline_output_multi_ind <- rstan::extract(constant_multi_ind_test, permuted = FALSE, inc_warmup = FALSE) |> - as.data.frame() |> - head(n=100) - -# Save the output to compare againest -saveRDS(constant_baseline_output_multi_ind, - file = test_path("fixtures/constant/constant_baseline_output_multi_ind.rds") - ) - diff --git a/tests/testthat/helper.R b/tests/testthat/helper-data_generation.R similarity index 92% rename from tests/testthat/helper.R rename to tests/testthat/helper-data_generation.R index e4399d8..23f51e9 100644 --- a/tests/testthat/helper.R +++ b/tests/testthat/helper-data_generation.R @@ -1,6 +1,4 @@ - #General functions for data generation - #Runge-Kutta 4th order rmot_rk4_est <- function(y_0, DE, pars, step_size, n_step){ runge_kutta_int <- c(y_0) @@ -46,6 +44,10 @@ rmot_build_true_test_data <- function(n_ind, n_obs, interval, return(true_data) } +rmot_add_normal_error <- function(y, sigma_e=0.001){ + return(y + rnorm(length(y), mean=0, sd=sigma_e)) +} + #Save data to files rmot_export_test_data <- function(n_obs_per_ind, n_ind, @@ -63,6 +65,7 @@ rmot_export_test_data <- function(n_obs_per_ind, obs_index = 1:n_obs_per_ind, #Vector indexed by n_obs time = time, #Vector indexed by n_obs y_0_obs = y_obs[1], #Number + n_pars = ncol(DE_pars), #Number single_true_data = list( DE_pars = DE_pars[1,], initial_conditions = initial_conditions[1,], @@ -80,6 +83,7 @@ rmot_export_test_data <- function(n_obs_per_ind, time = rep(time, times=n_ind), #Vector indexed by n_obs ind_id = sort(rep(1:n_ind, times = n_obs_per_ind)), #Vector indexed by n_obs y_0_obs = y_obs[seq(from = 1, to=n_ind*n_obs_per_ind, by=n_obs_per_ind)], #Vector indexed by n_ind + n_pars = ncol(DE_pars), multi_true_data = list( DE_pars = DE_pars, initial_conditions = initial_conditions, @@ -88,7 +92,7 @@ rmot_export_test_data <- function(n_obs_per_ind, ) ) - if(! exists(test_path("fixtures", model_name))) dir.create(test_path("fixtures", model_name)) + if(! dir.exists(test_path("fixtures", model_name))) dir.create(test_path("fixtures", model_name)) filename <- paste("tests/testthat/fixtures", "/", model_name, "/", model_name, "_data", sep="") saveRDS(single_ind_data, file=paste(filename, "single_ind.rds", sep="_")) saveRDS(multi_ind_data, file=paste(filename, "multi_ind.rds", sep="_")) diff --git a/tests/testthat/helper-testing.R b/tests/testthat/helper-testing.R new file mode 100644 index 0000000..1e105f6 --- /dev/null +++ b/tests/testthat/helper-testing.R @@ -0,0 +1,72 @@ +rmot_test_model_functions <- function(model_name){ + single_ind_name <- paste0(model_name, "_single_ind") + multi_ind_name <- paste0(model_name, "_multi_ind") + + # Single individual + expect_named(rmot_model(single_ind_name)) + expect_type(rmot_model(single_ind_name), "list") + expect_visible(rmot_model(single_ind_name)) + #Multiple individuals + expect_named(rmot_model(multi_ind_name)) + expect_type(rmot_model(multi_ind_name), "list") + expect_visible(rmot_model(multi_ind_name)) +} + +rmot_test_single_individual <- function(model_name, + par_names){ + data <- readRDS(test_path("fixtures", model_name, + paste0(model_name, "_data_single_ind.rds"))) + + # Test constant single individual + suppressWarnings( #Suppresses stan warnings + single_ind_test <- rmot_model(paste0(model_name, "_single_ind")) |> + rmot_assign_data(n_obs = data$n_obs, #integer + y_obs = data$y_obs, + obs_index = data$obs_index, #vector length N_obs + time = data$time, #Vector length N_obs + y_0_obs = data$y_0_obs #vector length N_ind + ) |> + rmot_run(chains = 1, iter = 1000, verbose = FALSE, show_messages = FALSE) + ) + + # Extract samples and check if parameter estimates are reasonable. + ind_samples <- rstan::extract(single_ind_test, permuted = TRUE, + inc_warmup = FALSE) + par_ests <- c() + for(i in length(par_names)){ + par_ests[i] <- mean(ind_samples[[par_names[i]]]) + } + + initial_condition <- mean(ind_samples$ind_y_0) + expect_equal(par_ests, data$single_true_data$DE_pars, + tolerance = 1e-1) + expect_equal(initial_condition, data$single_true_data$initial_conditions, + tolerance = 1e-1) + + # hecks for output existence and type + expect_visible(single_ind_test) + expect_s4_class(single_ind_test, "stanfit") +} + +rmot_test_multi_individual <- function(model_name, data, est_dim){ + # Test constant multi-individual + suppressWarnings( #Suppresses stan warnings + multi_ind_test <- rmot_model(paste0(model_name, "_multi_ind")) |> + rmot_assign_data(n_obs = data$n_obs, #integer + n_ind = data$n_ind, #integer + y_obs = data$y_obs, #vector length N_obs + obs_index = data$obs_index, #vector length N_obs + time = data$time, #Vector length N_obs + ind_id = data$ind_id, #Vector length N_obs + y_0_obs = data$y_0_obs #vector length N_ind + ) |> + rmot_run(chains = 2, iter = 100, verbose = FALSE, show_messages = FALSE) + ) + + # Extract samples + multi_samples <- rstan::extract(multi_ind_test, permuted = FALSE, inc_warmup = TRUE) + expect_equal(dim(multi_samples), c(100, 2, est_dim)) + + expect_visible(multi_ind_test) + expect_s4_class(multi_ind_test, "stanfit") +} diff --git a/tests/testthat/test-rmot_models.R b/tests/testthat/test-rmot_models.R index 380d762..26976d0 100644 --- a/tests/testthat/test-rmot_models.R +++ b/tests/testthat/test-rmot_models.R @@ -1,17 +1,7 @@ -test_that("Model structures", { +test_that("Model structures: Linear", { expect_named(rmot_model("linear")) expect_type(rmot_model("linear"), "list") expect_visible(rmot_model("linear")) - - # Constant models - # Single individual - expect_named(rmot_model("constant_single_ind")) - expect_type(rmot_model("constant_single_ind"), "list") - expect_visible(rmot_model("constant_single_ind")) - #Multiple individuals - expect_named(rmot_model("constant_multi_ind")) - expect_type(rmot_model("constant_multi_ind"), "list") - expect_visible(rmot_model("constant_multi_ind")) }) test_that("Execution and output: Linear", { @@ -37,66 +27,3 @@ test_that("Execution and output: Linear", { expect_visible(lm_test) expect_s4_class(lm_test, "stanfit") }) - -test_that("Execution: Constant single individual", { - const_data <- readRDS(test_path("fixtures", "constant", - "constant_data_single_ind.rds")) - const_single_ind_baseline_output <- readRDS(test_path("fixtures", "constant", - "constant_baseline_output_single_ind.rds")) - - # Test constant single individual - suppressWarnings( #Suppresses stan warnings - constant_single_ind_test <- rmot_model("constant_single_ind") |> - rmot_assign_data(n_obs = const_data$n_obs, #integer - y_obs = const_data$y_obs, - obs_index = const_data$obs_index, #vector length N_obs - time = const_data$time, #Vector length N_obs - y_0_obs = const_data$y_0_obs #vector length N_ind - ) |> - rmot_run(chains = 1, iter = 300, verbose = FALSE, show_messages = FALSE, - seed = 1) - ) - - # Extract samples - constant_ind_samples <- rstan::extract(constant_single_ind_test, permuted = FALSE, inc_warmup = FALSE) |> - as.data.frame() |> - head(n=100) - - expect_equal(constant_ind_samples, - const_single_ind_baseline_output, tolerance = 1e-5) - expect_visible(constant_single_ind_test) - expect_s4_class(constant_single_ind_test, "stanfit") - -}) - -test_that("Execution: Constant multiple individuals", { - const_data <- readRDS(test_path("fixtures", "constant", - "constant_data_multi_ind.rds")) - const_multi_ind_baseline_output <- readRDS(test_path("fixtures", "constant", - "constant_baseline_output_multi_ind.rds")) - - # Test constant multi-individual - suppressWarnings( #Suppresses stan warnings - constant_multi_ind_test <- rmot_model("constant_multi_ind") |> - rmot_assign_data(n_obs = const_data$n_obs, #integer - n_ind = const_data$n_ind, #integer - y_obs = const_data$y_obs, #vector length N_obs - obs_index = const_data$obs_index, #vector length N_obs - time = const_data$time, #Vector length N_obs - ind_id = const_data$ind_id, #Vector length N_obs - y_0_obs = const_data$y_0_obs #vector length N_ind - ) |> - rmot_run(chains = 1, iter = 300, verbose = FALSE, show_messages = FALSE, - seed = 1) - ) - - # Extract samples - constant_multi_samples <- rstan::extract(constant_multi_ind_test, permuted = FALSE, inc_warmup = FALSE) |> - as.data.frame() |> - head(n=100) - - expect_equal(constant_multi_samples, - const_multi_ind_baseline_output, tolerance = 1e-5) - expect_visible(constant_multi_ind_test) - expect_s4_class(constant_multi_ind_test, "stanfit") -}) diff --git a/tests/testthat/test-rmot_models_constant.R b/tests/testthat/test-rmot_models_constant.R new file mode 100644 index 0000000..56ba31f --- /dev/null +++ b/tests/testthat/test-rmot_models_constant.R @@ -0,0 +1,36 @@ +#Testing for constant model +test_that("Model structures: Constant", { + # Single individual + expect_named(rmot_model("constant_single_ind")) + expect_type(rmot_model("constant_single_ind"), "list") + expect_visible(rmot_model("constant_single_ind")) + #Multiple individuals + expect_named(rmot_model("constant_multi_ind")) + expect_type(rmot_model("constant_multi_ind"), "list") + expect_visible(rmot_model("constant_multi_ind")) +}) + +test_that("Execution: Constant single individual", { + model_name <- "constant" + par_names <- "ind_beta" + + rmot_test_single_individual(model_name, par_names) +}) + +test_that("Execution: Constant multiple individuals", { + model_name <- "constant" + + data <- readRDS(test_path("fixtures", "constant", + "constant_data_multi_ind.rds")) + + #Dimension is: + est_dim <- data$n_ind + #Initial condition + data$n_pars * data$n_ind + #Individual parameters + data$n_pars * 2 + #Population parameters + 1 + #Global error + data$n_obs + #y_ij + data$n_obs + #Delta y_ij + 1 #lp__ + + rmot_test_multi_individual(model_name, data, est_dim) +})