diff --git a/.Rbuildignore b/.Rbuildignore index 2b6554a..d6b19f1 100644 --- a/.Rbuildignore +++ b/.Rbuildignore @@ -17,3 +17,4 @@ cleanup* ^vignettes\compositional.Rmd ^vignettes\covariates.Rmd ^vignettes\estimate_process_sigma.Rmd +^CRAN-SUBMISSION$ diff --git a/CRAN-SUBMISSION b/CRAN-SUBMISSION new file mode 100644 index 0000000..a9ab30a --- /dev/null +++ b/CRAN-SUBMISSION @@ -0,0 +1,3 @@ +Version: 1.3.1 +Date: 2023-10-11 13:49:02 UTC +SHA: 6a6bf9d71e962434b17045286c42cd14a74062ce diff --git a/DESCRIPTION b/DESCRIPTION index 32433be..2045ce7 100644 --- a/DESCRIPTION +++ b/DESCRIPTION @@ -1,7 +1,7 @@ Package: bayesdfa Type: Package Title: Bayesian Dynamic Factor Analysis (DFA) with 'Stan' -Version: 1.3.0 +Version: 1.3.1 Authors@R: c( person(c("Eric", "J."), "Ward", role = c("aut", "cre"), email = "eric.ward@noaa.gov"), diff --git a/NEWS.md b/NEWS.md index 466448d..0c42a10 100644 --- a/NEWS.md +++ b/NEWS.md @@ -39,3 +39,11 @@ Add penalized spline models, so that the 'trend_model' argument may take on "rw" for conventional random walks, "bs" for B-splines, "ps" for "P-splines", or "gp" for Gaussian processes + +# bayesdfa 1.3.0 + +Change to new Stan syntax + +# bayesdfa 1.3.1 + +Versioning diff --git a/src/Makevars b/src/Makevars index e2ddefe..ab2c9d3 100644 --- a/src/Makevars +++ b/src/Makevars @@ -2,7 +2,7 @@ STANHEADERS_SRC = $(shell "$(R_HOME)/bin$(R_ARCH_BIN)/Rscript" -e "message()" -e "cat(system.file('include', 'src', package = 'StanHeaders', mustWork = TRUE))" -e "message()" | grep "StanHeaders") -STANC_FLAGS = $(shell "$(R_HOME)/bin$(R_ARCH_BIN)/Rscript" -e "cat(ifelse(utils::packageVersion('rstan') >= 2.26, '-DUSE_STANC3',''))") +STANC_FLAGS = $(shell "$(R_HOME)/bin$(R_ARCH_BIN)/Rscript" -e "cat(ifelse(utils::packageVersion('rstan') >= '2.26', '-DUSE_STANC3',''))") PKG_CPPFLAGS = -I"../inst/include" -I"$(STANHEADERS_SRC)" -DBOOST_DISABLE_ASSERTS -DEIGEN_NO_DEBUG -DBOOST_MATH_OVERFLOW_ERROR_POLICY=errno_on_error $(STANC_FLAGS) -D_HAS_AUTO_PTR_ETC=0 PKG_CXXFLAGS = $(shell "$(R_HOME)/bin$(R_ARCH_BIN)/Rscript" -e "RcppParallel::CxxFlags()") $(shell "$(R_HOME)/bin$(R_ARCH_BIN)/Rscript" -e "StanHeaders:::CxxFlags()") PKG_LIBS = $(shell "$(R_HOME)/bin$(R_ARCH_BIN)/Rscript" -e "RcppParallel::RcppParallelLibs()") $(shell "$(R_HOME)/bin$(R_ARCH_BIN)/Rscript" -e "StanHeaders:::LdFlags()") diff --git a/src/stanExports_corr.h b/src/stanExports_corr.h index 042e949..a66b399 100644 --- a/src/stanExports_corr.h +++ b/src/stanExports_corr.h @@ -17,304 +17,450 @@ #ifndef MODELS_HPP #define MODELS_HPP #define STAN__SERVICES__COMMAND_HPP +#ifndef USE_STANC3 +#define USE_STANC3 +#endif #include -// Code generated by Stan version 2.21.0 +// Code generated by stanc v2.26.1-4-gd72b68b7-dirty #include namespace model_corr_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::prob_grad; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; using namespace stan::math; -static int current_statement_begin__; -stan::io::program_reader prog_reader__() { - stan::io::program_reader reader; - reader.add_event(0, 0, "start", "model_corr"); - reader.add_event(16, 14, "end", "model_corr"); - return reader; -} +using stan::math::pow; +stan::math::profile_map profiles__; +static int current_statement__= 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'corr', line 7, column 2 to column 30)", + " (in 'corr', line 8, column 2 to column 22)", + " (in 'corr', line 12, column 2 to column 29)", + " (in 'corr', line 13, column 2 to column 30)", + " (in 'corr', line 2, column 2 to column 17)", + " (in 'corr', line 3, column 9 to column 10)", + " (in 'corr', line 3, column 2 to column 14)", + " (in 'corr', line 4, column 9 to column 10)", + " (in 'corr', line 4, column 2 to column 14)"}; #include -class model_corr - : public stan::model::model_base_crtp { +class model_corr final : public model_base_crtp { private: - int N; - vector_d y; - vector_d x; + int N; + Eigen::Matrix y; + Eigen::Matrix x; + public: - model_corr(stan::io::var_context& context__, - std::ostream* pstream__ = 0) - : model_base_crtp(0) { - ctor_body(context__, 0, pstream__); + ~model_corr() { } + + inline std::string model_name() const final { return "model_corr"; } + inline std::vector model_compile_info() const noexcept { + return std::vector{"stanc_version = stanc3 v2.26.1-4-gd72b68b7-dirty", "stancflags = "}; + } + + + model_corr(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_corr_namespace::model_corr"; + (void) function__; // suppress unused var warning + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + (void) DUMMY_VAR__; // suppress unused var warning + + try { + int pos__; + pos__ = std::numeric_limits::min(); + + pos__ = 1; + current_statement__ = 5; + 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; + current_statement__ = 5; + check_greater_or_equal(function__, "N", N, 0); + current_statement__ = 6; + validate_non_negative_index("y", "N", N); + current_statement__ = 7; + 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__ = 7; + assign(y_flat__, nil_index_list(), context__.vals_r("y"), + "assigning variable y_flat__"); + current_statement__ = 7; + pos__ = 1; + current_statement__ = 7; + for (int sym1__ = 1; sym1__ <= N; ++sym1__) { + current_statement__ = 7; + assign(y, cons_list(index_uni(sym1__), nil_index_list()), + y_flat__[(pos__ - 1)], "assigning variable y"); + current_statement__ = 7; + pos__ = (pos__ + 1);} + } + current_statement__ = 8; + validate_non_negative_index("x", "N", N); + current_statement__ = 9; + 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__ = 9; + assign(x_flat__, nil_index_list(), context__.vals_r("x"), + "assigning variable x_flat__"); + current_statement__ = 9; + pos__ = 1; + current_statement__ = 9; + for (int sym1__ = 1; sym1__ <= N; ++sym1__) { + current_statement__ = 9; + assign(x, cons_list(index_uni(sym1__), nil_index_list()), + x_flat__[(pos__ - 1)], "assigning variable x"); + current_statement__ = 9; + 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 ***"); } - model_corr(stan::io::var_context& context__, - unsigned int random_seed__, - std::ostream* pstream__ = 0) - : model_base_crtp(0) { - ctor_body(context__, random_seed__, pstream__); + num_params_r__ = 0U; + + try { + num_params_r__ += 1; + num_params_r__ += 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); } - void ctor_body(stan::io::var_context& context__, - unsigned int random_seed__, - std::ostream* pstream__) { - typedef double local_scalar_t__; - boost::ecuyer1988 base_rng__ = - stan::services::util::create_rng(random_seed__, 0); - (void) base_rng__; // suppress unused var warning - current_statement_begin__ = -1; - static const char* function__ = "model_corr_namespace::model_corr"; - (void) function__; // dummy to suppress unused var warning - size_t pos__; - (void) pos__; // dummy to suppress unused var warning - std::vector vals_i__; - std::vector vals_r__; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - (void) DUMMY_VAR__; // suppress unused var warning - try { - // initialize data block variables from context__ - current_statement_begin__ = 2; - context__.validate_dims("data initialization", "N", "int", context__.to_vec()); - N = int(0); - vals_i__ = context__.vals_i("N"); - pos__ = 0; - N = vals_i__[pos__++]; - check_greater_or_equal(function__, "N", N, 0); - current_statement_begin__ = 3; - validate_non_negative_index("y", "N", N); - context__.validate_dims("data initialization", "y", "vector_d", context__.to_vec(N)); - y = Eigen::Matrix(N); - vals_r__ = context__.vals_r("y"); - pos__ = 0; - size_t y_j_1_max__ = N; - for (size_t j_1__ = 0; j_1__ < y_j_1_max__; ++j_1__) { - y(j_1__) = vals_r__[pos__++]; - } - current_statement_begin__ = 4; - validate_non_negative_index("x", "N", N); - context__.validate_dims("data initialization", "x", "vector_d", context__.to_vec(N)); - x = Eigen::Matrix(N); - vals_r__ = context__.vals_r("x"); - pos__ = 0; - size_t x_j_1_max__ = N; - for (size_t j_1__ = 0; j_1__ < x_j_1_max__; ++j_1__) { - x(j_1__) = vals_r__[pos__++]; - } - // initialize transformed data variables - // execute transformed data statements - // validate transformed data - // validate, set parameter ranges - num_params_r__ = 0U; - param_ranges_i__.clear(); - current_statement_begin__ = 7; - num_params_r__ += 1; - current_statement_begin__ = 8; - num_params_r__ += 1; - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__()); - // 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 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__; + static const char* function__ = "model_corr_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()); + (void) DUMMY_VAR__; // suppress unused var warning + + try { + local_scalar_t__ beta; + beta = DUMMY_VAR__; + + current_statement__ = 1; + beta = in__.scalar(); + current_statement__ = 1; + if (jacobian__) { + current_statement__ = 1; + beta = stan::math::lub_constrain(beta, -1, 1, lp__); + } else { + current_statement__ = 1; + beta = stan::math::lub_constrain(beta, -1, 1); + } + local_scalar_t__ sigma; + sigma = DUMMY_VAR__; + + current_statement__ = 2; + sigma = in__.scalar(); + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + sigma = stan::math::lb_constrain(sigma, 0, lp__); + } else { + current_statement__ = 2; + sigma = stan::math::lb_constrain(sigma, 0); + } + { + current_statement__ = 3; + lp_accum__.add(student_t_lpdf(sigma, 3, 0, 2)); + current_statement__ = 4; + lp_accum__.add(normal_lpdf(y, 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 ***"); } - ~model_corr() { } - void transform_inits(const stan::io::var_context& context__, - std::vector& params_i__, - std::vector& params_r__, - std::ostream* pstream__) const { - typedef double local_scalar_t__; - stan::io::writer writer__(params_r__, params_i__); - size_t pos__; - (void) pos__; // dummy call to supress warning - std::vector vals_r__; - std::vector vals_i__; - current_statement_begin__ = 7; - if (!(context__.contains_r("beta"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable beta missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("beta"); - pos__ = 0U; - context__.validate_dims("parameter initialization", "beta", "double", context__.to_vec()); - double beta(0); - beta = vals_r__[pos__++]; - try { - writer__.scalar_lub_unconstrain(-(1), 1, beta); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable beta: ") + e.what()), current_statement_begin__, prog_reader__()); - } - current_statement_begin__ = 8; - if (!(context__.contains_r("sigma"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable sigma missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("sigma"); - pos__ = 0U; - context__.validate_dims("parameter initialization", "sigma", "double", context__.to_vec()); - double sigma(0); - sigma = vals_r__[pos__++]; - try { - writer__.scalar_lb_unconstrain(0, sigma); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable sigma: ") + e.what()), current_statement_begin__, prog_reader__()); - } - params_r__ = writer__.data_r(); - params_i__ = writer__.data_i(); + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // 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; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "model_corr_namespace::write_array"; +(void) function__; // suppress unused var warning + (void) function__; // suppress unused var warning + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + (void) DUMMY_VAR__; // suppress unused var warning + + try { + double beta; + beta = std::numeric_limits::quiet_NaN(); + + current_statement__ = 1; + beta = in__.scalar(); + current_statement__ = 1; + beta = stan::math::lub_constrain(beta, -1, 1); + double sigma; + sigma = std::numeric_limits::quiet_NaN(); + + current_statement__ = 2; + sigma = in__.scalar(); + current_statement__ = 2; + sigma = stan::math::lb_constrain(sigma, 0); + vars__.emplace_back(beta); + vars__.emplace_back(sigma); + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); } - void transform_inits(const stan::io::var_context& context, - Eigen::Matrix& params_r, - std::ostream* pstream__) const { - std::vector params_r_vec; - std::vector params_i_vec; - transform_inits(context, params_i_vec, params_r_vec, pstream__); - params_r.resize(params_r_vec.size()); - for (int i = 0; i < params_r.size(); ++i) - params_r(i) = params_r_vec[i]; + } // 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; + vars__.clear(); + vars__.reserve(num_params_r__); + + try { + int pos__; + pos__ = std::numeric_limits::min(); + + pos__ = 1; + double beta; + beta = std::numeric_limits::quiet_NaN(); + + current_statement__ = 1; + beta = context__.vals_r("beta")[(1 - 1)]; + double beta_free__; + beta_free__ = std::numeric_limits::quiet_NaN(); + + current_statement__ = 1; + beta_free__ = stan::math::lub_free(beta, -1, 1); + double sigma; + sigma = std::numeric_limits::quiet_NaN(); + + current_statement__ = 2; + sigma = context__.vals_r("sigma")[(1 - 1)]; + double sigma_free__; + sigma_free__ = std::numeric_limits::quiet_NaN(); + + current_statement__ = 2; + sigma_free__ = stan::math::lb_free(sigma, 0); + vars__.emplace_back(beta_free__); + 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 ***"); } - template - T__ log_prob(std::vector& params_r__, - std::vector& params_i__, - std::ostream* pstream__ = 0) const { - typedef T__ local_scalar_t__; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - (void) DUMMY_VAR__; // dummy to suppress unused var warning - T__ lp__(0.0); - stan::math::accumulator lp_accum__; - try { - stan::io::reader in__(params_r__, params_i__); - // model parameters - current_statement_begin__ = 7; - local_scalar_t__ beta; - (void) beta; // dummy to suppress unused var warning - if (jacobian__) - beta = in__.scalar_lub_constrain(-(1), 1, lp__); - else - beta = in__.scalar_lub_constrain(-(1), 1); - current_statement_begin__ = 8; - local_scalar_t__ sigma; - (void) sigma; // dummy to suppress unused var warning - if (jacobian__) - sigma = in__.scalar_lb_constrain(0, lp__); - else - sigma = in__.scalar_lb_constrain(0); - // model body - current_statement_begin__ = 12; - lp_accum__.add(student_t_log(sigma, 3, 0, 2)); - current_statement_begin__ = 13; - lp_accum__.add(normal_log(y, multiply(beta, x), sigma)); - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__()); - // Next line prevents compiler griping about no return - throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); - } - lp_accum__.add(lp__); - return lp_accum__.sum(); - } // log_prob() - template - T_ log_prob(Eigen::Matrix& params_r, - std::ostream* pstream = 0) const { - std::vector vec_params_r; - vec_params_r.reserve(params_r.size()); - for (int i = 0; i < params_r.size(); ++i) - vec_params_r.push_back(params_r(i)); - std::vector vec_params_i; - return log_prob(vec_params_r, vec_params_i, pstream); + } // transform_inits_impl() + + inline void get_param_names(std::vector& names__) const { + + names__.clear(); + 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{}); + + } // 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() + "beta"); + param_names__.emplace_back(std::string() + "sigma"); + if (emit_transformed_parameters__) { + } - void get_param_names(std::vector& names__) const { - names__.resize(0); - names__.push_back("beta"); - names__.push_back("sigma"); + + if (emit_generated_quantities__) { + } - void get_dims(std::vector >& dimss__) const { - dimss__.resize(0); - std::vector dims__; - dims__.resize(0); - dimss__.push_back(dims__); - dims__.resize(0); - dimss__.push_back(dims__); + + } // 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() + "beta"); + param_names__.emplace_back(std::string() + "sigma"); + if (emit_transformed_parameters__) { + } - template - void write_array(RNG& base_rng__, - std::vector& params_r__, - std::vector& params_i__, - std::vector& vars__, - bool include_tparams__ = true, - bool include_gqs__ = true, - std::ostream* pstream__ = 0) const { - typedef double local_scalar_t__; - vars__.resize(0); - stan::io::reader in__(params_r__, params_i__); - static const char* function__ = "model_corr_namespace::write_array"; - (void) function__; // dummy to suppress unused var warning - // read-transform, write parameters - double beta = in__.scalar_lub_constrain(-(1), 1); - vars__.push_back(beta); - double sigma = in__.scalar_lb_constrain(0); - vars__.push_back(sigma); - double lp__ = 0.0; - (void) lp__; // dummy to suppress unused var warning - stan::math::accumulator lp_accum__; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - (void) DUMMY_VAR__; // suppress unused var warning - if (!include_tparams__ && !include_gqs__) return; - try { - if (!include_gqs__ && !include_tparams__) return; - if (!include_gqs__) return; - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__()); - // Next line prevents compiler griping about no return - throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); - } + + if (emit_generated_quantities__) { + } + + } // unconstrained_param_names() + + inline std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"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 { + stringstream s__; + s__ << "[{\"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 - void write_array(RNG& base_rng, - Eigen::Matrix& params_r, - Eigen::Matrix& vars, - bool include_tparams = true, - bool include_gqs = true, - std::ostream* pstream = 0) const { - std::vector params_r_vec(params_r.size()); - for (int i = 0; i < params_r.size(); ++i) - params_r_vec[i] = params_r(i); - std::vector vars_vec; - std::vector params_i_vec; - write_array(base_rng, params_r_vec, params_i_vec, vars_vec, include_tparams, include_gqs, pstream); + 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(i) = vars_vec[i]; + for (int i = 0; i < vars.size(); ++i) { + vars.coeffRef(i) = vars_vec[i]; + } } - std::string model_name() const { - return "model_corr"; + 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); } - void constrained_param_names(std::vector& param_names__, - bool include_tparams__ = true, - bool include_gqs__ = true) const { - std::stringstream param_name_stream__; - param_name_stream__.str(std::string()); - param_name_stream__ << "beta"; - param_names__.push_back(param_name_stream__.str()); - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma"; - param_names__.push_back(param_name_stream__.str()); - if (!include_gqs__ && !include_tparams__) return; - if (include_tparams__) { - } - if (!include_gqs__) return; + 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); } - void unconstrained_param_names(std::vector& param_names__, - bool include_tparams__ = true, - bool include_gqs__ = true) const { - std::stringstream param_name_stream__; - param_name_stream__.str(std::string()); - param_name_stream__ << "beta"; - param_names__.push_back(param_name_stream__.str()); - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma"; - param_names__.push_back(param_name_stream__.str()); - if (!include_gqs__ && !include_tparams__) return; - if (include_tparams__) { - } - if (!include_gqs__) return; + 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); } -}; // model -} // namespace -typedef model_corr_namespace::model_corr stan_model; + + 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_corr_namespace::model_corr; #ifndef USING_R +// Boilerplate stan::model::model_base& new_model( stan::io::var_context& data_context, unsigned int seed, @@ -322,5 +468,8 @@ stan::model::model_base& new_model( stan_model* m = new stan_model(data_context, seed, msg_stream); return *m; } +stan::math::profile_map& get_stan_profile_data() { + return model_corr_namespace::profiles__; +} #endif #endif diff --git a/src/stanExports_dfa.h b/src/stanExports_dfa.h index b82aa81..392b666 100644 --- a/src/stanExports_dfa.h +++ b/src/stanExports_dfa.h @@ -17,4892 +17,6258 @@ #ifndef MODELS_HPP #define MODELS_HPP #define STAN__SERVICES__COMMAND_HPP +#ifndef USE_STANC3 +#define USE_STANC3 +#endif #include -// Code generated by Stan version 2.21.0 +// Code generated by stanc v2.26.1-4-gd72b68b7-dirty #include namespace model_dfa_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::prob_grad; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; using namespace stan::math; -static int current_statement_begin__; -stan::io::program_reader prog_reader__() { - stan::io::program_reader reader; - reader.add_event(0, 0, "start", "model_dfa"); - reader.add_event(686, 684, "end", "model_dfa"); - return reader; -} +using stan::math::pow; +stan::math::profile_map profiles__; +static int current_statement__= 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'dfa', line 167, column 2 to column 41)", + " (in 'dfa', line 168, column 2 to column 15)", + " (in 'dfa', line 169, column 2 to column 68)", + " (in 'dfa', line 170, column 2 to column 73)", + " (in 'dfa', line 171, column 2 to column 61)", + " (in 'dfa', line 172, column 2 to column 39)", + " (in 'dfa', line 173, column 2 to column 56)", + " (in 'dfa', line 174, column 2 to column 31)", + " (in 'dfa', line 175, column 2 to column 31)", + " (in 'dfa', line 176, column 2 to column 51)", + " (in 'dfa', line 177, column 2 to column 53)", + " (in 'dfa', line 178, column 2 to column 51)", + " (in 'dfa', line 179, column 2 to column 32)", + " (in 'dfa', line 180, column 2 to column 19)", + " (in 'dfa', line 181, column 2 to column 40)", + " (in 'dfa', line 182, column 2 to column 44)", + " (in 'dfa', line 183, column 2 to column 35)", + " (in 'dfa', line 184, column 2 to column 37)", + " (in 'dfa', line 185, column 2 to column 67)", + " (in 'dfa', line 186, column 2 to column 51)", + " (in 'dfa', line 189, column 2 to column 19)", + " (in 'dfa', line 190, column 2 to column 16)", + " (in 'dfa', line 191, column 2 to column 19)", + " (in 'dfa', line 192, column 2 to column 48)", + " (in 'dfa', line 193, column 2 to column 50)", + " (in 'dfa', line 194, column 2 to column 47)", + " (in 'dfa', line 195, column 2 to column 20)", + " (in 'dfa', line 196, column 2 to column 22)", + " (in 'dfa', line 197, column 2 to column 16)", + " (in 'dfa', line 198, column 2 to column 22)", + " (in 'dfa', line 199, column 2 to column 50)", + " (in 'dfa', line 200, column 2 to column 79)", + " (in 'dfa', line 201, column 2 to column 84)", + " (in 'dfa', line 202, column 2 to column 33)", + " (in 'dfa', line 203, column 2 to column 65)", + " (in 'dfa', line 204, column 2 to column 67)", + " (in 'dfa', line 205, column 2 to column 47)", + " (in 'dfa', line 206, column 2 to column 46)", + " (in 'dfa', line 207, column 2 to column 15)", + " (in 'dfa', line 208, column 2 to column 22)", + " (in 'dfa', line 209, column 2 to column 62)", + " (in 'dfa', line 210, column 2 to column 41)", + " (in 'dfa', line 213, column 2 to column 31)", + " (in 'dfa', line 216, column 4 to column 21)", + " (in 'dfa', line 221, column 8 to column 40)", + " (in 'dfa', line 220, column 13 to line 222, column 7)", + " (in 'dfa', line 219, column 8 to column 40)", + " (in 'dfa', line 218, column 29 to line 220, column 7)", + " (in 'dfa', line 218, column 6 to line 222, column 7)", + " (in 'dfa', line 217, column 29 to line 223, column 5)", + " (in 'dfa', line 217, column 4 to line 223, column 5)", + " (in 'dfa', line 215, column 16 to line 224, column 3)", + " (in 'dfa', line 215, column 2 to line 224, column 3)", + " (in 'dfa', line 230, column 19 to column 34)", + " (in 'dfa', line 230, column 18 to column 35)", + " (in 'dfa', line 230, column 4 to column 35)", + " (in 'dfa', line 229, column 9 to line 232, column 3)", + " (in 'dfa', line 227, column 19 to column 39)", + " (in 'dfa', line 227, column 18 to column 40)", + " (in 'dfa', line 227, column 4 to column 40)", + " (in 'dfa', line 226, column 19 to line 229, column 3)", + " (in 'dfa', line 226, column 2 to line 232, column 3)", + " (in 'dfa', line 238, column 19 to column 36)", + " (in 'dfa', line 238, column 18 to column 37)", + " (in 'dfa', line 238, column 4 to column 37)", + " (in 'dfa', line 237, column 9 to line 240, column 3)", + " (in 'dfa', line 235, column 19 to column 43)", + " (in 'dfa', line 235, column 18 to column 44)", + " (in 'dfa', line 235, column 4 to column 44)", + " (in 'dfa', line 234, column 21 to line 237, column 3)", + " (in 'dfa', line 234, column 2 to line 240, column 3)", + " (in 'dfa', line 242, column 19 to column 52)", + " (in 'dfa', line 242, column 18 to column 53)", + " (in 'dfa', line 242, column 4 to column 53)", + " (in 'dfa', line 241, column 28 to line 243, column 3)", + " (in 'dfa', line 241, column 2 to line 243, column 3)", + " (in 'dfa', line 245, column 19 to column 56)", + " (in 'dfa', line 245, column 18 to column 57)", + " (in 'dfa', line 245, column 4 to column 57)", + " (in 'dfa', line 244, column 28 to line 246, column 3)", + " (in 'dfa', line 244, column 2 to line 246, column 3)", + " (in 'dfa', line 248, column 19 to column 55)", + " (in 'dfa', line 248, column 18 to column 56)", + " (in 'dfa', line 248, column 4 to column 56)", + " (in 'dfa', line 247, column 26 to line 249, column 3)", + " (in 'dfa', line 247, column 2 to line 249, column 3)", + " (in 'dfa', line 253, column 6 to column 52)", + " (in 'dfa', line 252, column 22 to line 254, column 5)", + " (in 'dfa', line 252, column 4 to line 254, column 5)", + " (in 'dfa', line 258, column 8 to column 56)", + " (in 'dfa', line 257, column 23 to line 259, column 7)", + " (in 'dfa', line 257, column 6 to line 259, column 7)", + " (in 'dfa', line 256, column 17 to line 260, column 5)", + " (in 'dfa', line 256, column 4 to line 260, column 5)", + " (in 'dfa', line 250, column 21 to line 261, column 3)", + " (in 'dfa', line 250, column 2 to line 261, column 3)", + " (in 'dfa', line 264, column 6 to column 40)", + " (in 'dfa', line 263, column 19 to line 265, column 5)", + " (in 'dfa', line 263, column 4 to line 265, column 5)", + " (in 'dfa', line 269, column 8 to column 43)", + " (in 'dfa', line 268, column 28 to line 270, column 7)", + " (in 'dfa', line 268, column 6 to line 270, column 7)", + " (in 'dfa', line 267, column 18 to line 271, column 5)", + " (in 'dfa', line 267, column 4 to line 271, column 5)", + " (in 'dfa', line 273, column 6 to column 23)", + " (in 'dfa', line 272, column 18 to line 274, column 5)", + " (in 'dfa', line 272, column 4 to line 274, column 5)", + " (in 'dfa', line 281, column 10 to column 27)", + " (in 'dfa', line 280, column 15 to line 282, column 9)", + " (in 'dfa', line 279, column 10 to column 28)", + " (in 'dfa', line 278, column 24 to line 280, column 9)", + " (in 'dfa', line 278, column 8 to line 282, column 9)", + " (in 'dfa', line 284, column 8 to column 35)", + " (in 'dfa', line 287, column 10 to column 59)", + " (in 'dfa', line 285, column 22 to line 288, column 9)", + " (in 'dfa', line 285, column 8 to line 288, column 9)", + " (in 'dfa', line 277, column 20 to line 289, column 7)", + " (in 'dfa', line 277, column 6 to line 289, column 7)", + " (in 'dfa', line 276, column 31 to line 290, column 5)", + " (in 'dfa', line 276, column 4 to line 290, column 5)", + " (in 'dfa', line 294, column 8 to column 23)", + " (in 'dfa', line 299, column 10 to column 53)", + " (in 'dfa', line 298, column 22 to line 300, column 9)", + " (in 'dfa', line 298, column 8 to line 300, column 9)", + " (in 'dfa', line 293, column 20 to line 301, column 7)", + " (in 'dfa', line 293, column 6 to line 301, column 7)", + " (in 'dfa', line 292, column 20 to line 302, column 5)", + " (in 'dfa', line 292, column 4 to line 302, column 5)", + " (in 'dfa', line 306, column 20 to column 67)", + " (in 'dfa', line 306, column 6 to column 67)", + " (in 'dfa', line 307, column 6 to column 37)", + " (in 'dfa', line 308, column 21 to column 41)", + " (in 'dfa', line 308, column 20 to column 42)", + " (in 'dfa', line 308, column 6 to column 42)", + " (in 'dfa', line 303, column 22 to line 309, column 5)", + " (in 'dfa', line 303, column 4 to line 309, column 5)", + " (in 'dfa', line 313, column 8 to column 75)", + " (in 'dfa', line 316, column 10 to column 41)", + " (in 'dfa', line 315, column 28 to line 317, column 9)", + " (in 'dfa', line 315, column 8 to line 317, column 9)", + " (in 'dfa', line 329, column 10 to column 177)", + " (in 'dfa', line 328, column 15 to line 330, column 9)", + " (in 'dfa', line 327, column 10 to column 84)", + " (in 'dfa', line 325, column 25 to line 328, column 9)", + " (in 'dfa', line 325, column 8 to line 330, column 9)", + " (in 'dfa', line 312, column 21 to line 331, column 7)", + " (in 'dfa', line 312, column 6 to line 331, column 7)", + " (in 'dfa', line 310, column 20 to line 332, column 5)", + " (in 'dfa', line 310, column 4 to line 332, column 5)", + " (in 'dfa', line 338, column 8 to column 49)", + " (in 'dfa', line 335, column 20 to line 339, column 7)", + " (in 'dfa', line 335, column 6 to line 339, column 7)", + " (in 'dfa', line 334, column 31 to line 340, column 5)", + " (in 'dfa', line 334, column 4 to line 340, column 5)", + " (in 'dfa', line 262, column 30 to line 341, column 3)", + " (in 'dfa', line 262, column 2 to line 341, column 3)", + " (in 'dfa', line 346, column 8 to column 23)", + " (in 'dfa', line 351, column 10 to column 53)", + " (in 'dfa', line 350, column 22 to line 352, column 9)", + " (in 'dfa', line 350, column 8 to line 352, column 9)", + " (in 'dfa', line 345, column 20 to line 353, column 7)", + " (in 'dfa', line 345, column 6 to line 353, column 7)", + " (in 'dfa', line 344, column 20 to line 354, column 5)", + " (in 'dfa', line 344, column 4 to line 354, column 5)", + " (in 'dfa', line 356, column 20 to column 67)", + " (in 'dfa', line 356, column 6 to column 67)", + " (in 'dfa', line 357, column 6 to column 37)", + " (in 'dfa', line 358, column 21 to column 41)", + " (in 'dfa', line 358, column 20 to column 42)", + " (in 'dfa', line 358, column 6 to column 42)", + " (in 'dfa', line 355, column 22 to line 359, column 5)", + " (in 'dfa', line 355, column 4 to line 359, column 5)", + " (in 'dfa', line 362, column 8 to column 75)", + " (in 'dfa', line 365, column 10 to column 41)", + " (in 'dfa', line 364, column 28 to line 366, column 9)", + " (in 'dfa', line 364, column 8 to line 366, column 9)", + " (in 'dfa', line 378, column 10 to column 177)", + " (in 'dfa', line 377, column 15 to line 379, column 9)", + " (in 'dfa', line 376, column 10 to column 84)", + " (in 'dfa', line 374, column 25 to line 377, column 9)", + " (in 'dfa', line 374, column 8 to line 379, column 9)", + " (in 'dfa', line 361, column 21 to line 380, column 7)", + " (in 'dfa', line 361, column 6 to line 380, column 7)", + " (in 'dfa', line 360, column 20 to line 381, column 5)", + " (in 'dfa', line 360, column 4 to line 381, column 5)", + " (in 'dfa', line 387, column 6 to column 35)", + " (in 'dfa', line 383, column 18 to line 388, column 5)", + " (in 'dfa', line 383, column 4 to line 388, column 5)", + " (in 'dfa', line 342, column 30 to line 389, column 3)", + " (in 'dfa', line 342, column 2 to line 389, column 3)", + " (in 'dfa', line 394, column 6 to column 125)", + " (in 'dfa', line 392, column 30 to line 395, column 5)", + " (in 'dfa', line 392, column 4 to line 395, column 5)", + " (in 'dfa', line 391, column 24 to line 396, column 3)", + " (in 'dfa', line 391, column 2 to line 396, column 3)", + " (in 'dfa', line 399, column 2 to column 15)", + " (in 'dfa', line 402, column 4 to column 26)", + " (in 'dfa', line 401, column 20 to line 403, column 3)", + " (in 'dfa', line 401, column 2 to line 403, column 3)", + " (in 'dfa', line 416, column 8 to column 117)", + " (in 'dfa', line 415, column 32 to line 417, column 7)", + " (in 'dfa', line 415, column 6 to line 417, column 7)", + " (in 'dfa', line 412, column 11 to line 418, column 5)", + " (in 'dfa', line 410, column 8 to column 130)", + " (in 'dfa', line 407, column 32 to line 411, column 7)", + " (in 'dfa', line 407, column 6 to line 411, column 7)", + " (in 'dfa', line 406, column 23 to line 412, column 5)", + " (in 'dfa', line 406, column 4 to line 418, column 5)", + " (in 'dfa', line 405, column 24 to line 419, column 3)", + " (in 'dfa', line 405, column 2 to line 419, column 3)", + " (in 'dfa', line 424, column 8 to column 29)", + " (in 'dfa', line 425, column 8 to column 31)", + " (in 'dfa', line 423, column 20 to line 426, column 7)", + " (in 'dfa', line 423, column 6 to line 426, column 7)", + " (in 'dfa', line 422, column 18 to line 427, column 5)", + " (in 'dfa', line 422, column 4 to line 427, column 5)", + " (in 'dfa', line 429, column 6 to column 99)", + " (in 'dfa', line 430, column 6 to column 56)", + " (in 'dfa', line 428, column 22 to line 431, column 5)", + " (in 'dfa', line 428, column 4 to line 431, column 5)", + " (in 'dfa', line 435, column 8 to column 57)", + " (in 'dfa', line 433, column 20 to line 436, column 7)", + " (in 'dfa', line 433, column 6 to line 436, column 7)", + " (in 'dfa', line 432, column 18 to line 437, column 5)", + " (in 'dfa', line 432, column 4 to line 437, column 5)", + " (in 'dfa', line 439, column 4 to column 88)", + " (in 'dfa', line 441, column 6 to column 35)", + " (in 'dfa', line 442, column 6 to column 56)", + " (in 'dfa', line 443, column 6 to column 51)", + " (in 'dfa', line 445, column 6 to column 113)", + " (in 'dfa', line 447, column 6 to column 107)", + " (in 'dfa', line 440, column 18 to line 448, column 5)", + " (in 'dfa', line 440, column 4 to line 448, column 5)", + " (in 'dfa', line 420, column 35 to line 449, column 3)", + " (in 'dfa', line 420, column 2 to line 449, column 3)", + " (in 'dfa', line 558, column 2 to column 27)", + " (in 'dfa', line 559, column 2 to column 31)", + " (in 'dfa', line 560, column 2 to column 31)", + " (in 'dfa', line 561, column 2 to column 20)", + " (in 'dfa', line 562, column 2 to column 24)", + " (in 'dfa', line 563, column 2 to column 43)", + " (in 'dfa', line 564, column 2 to column 40)", + " (in 'dfa', line 565, column 2 to column 17)", + " (in 'dfa', line 566, column 2 to column 8)", + " (in 'dfa', line 568, column 4 to column 53)", + " (in 'dfa', line 569, column 4 to column 45)", + " (in 'dfa', line 567, column 19 to line 570, column 3)", + " (in 'dfa', line 567, column 2 to line 570, column 3)", + " (in 'dfa', line 597, column 8 to column 208)", + " (in 'dfa', line 595, column 24 to line 598, column 7)", + " (in 'dfa', line 595, column 6 to line 598, column 7)", + " (in 'dfa', line 594, column 11 to line 599, column 5)", + " (in 'dfa', line 592, column 8 to column 112)", + " (in 'dfa', line 591, column 20 to line 593, column 7)", + " (in 'dfa', line 591, column 6 to line 593, column 7)", + " (in 'dfa', line 590, column 23 to line 594, column 5)", + " (in 'dfa', line 590, column 4 to line 599, column 5)", + " (in 'dfa', line 589, column 9 to line 600, column 3)", + " (in 'dfa', line 582, column 44 to column 206)", + " (in 'dfa', line 582, column 26 to column 206)", + " (in 'dfa', line 582, column 25 to column 207)", + " (in 'dfa', line 582, column 6 to column 207)", + " (in 'dfa', line 583, column 44 to column 212)", + " (in 'dfa', line 583, column 26 to column 212)", + " (in 'dfa', line 583, column 25 to column 213)", + " (in 'dfa', line 583, column 6 to column 213)", + " (in 'dfa', line 584, column 44 to column 156)", + " (in 'dfa', line 584, column 26 to column 156)", + " (in 'dfa', line 584, column 25 to column 157)", + " (in 'dfa', line 584, column 6 to column 157)", + " (in 'dfa', line 585, column 44 to column 192)", + " (in 'dfa', line 585, column 26 to column 192)", + " (in 'dfa', line 585, column 25 to column 193)", + " (in 'dfa', line 585, column 6 to column 193)", + " (in 'dfa', line 586, column 44 to column 160)", + " (in 'dfa', line 586, column 26 to column 160)", + " (in 'dfa', line 586, column 25 to column 161)", + " (in 'dfa', line 586, column 6 to column 161)", + " (in 'dfa', line 587, column 44 to column 178)", + " (in 'dfa', line 587, column 26 to column 178)", + " (in 'dfa', line 587, column 25 to column 179)", + " (in 'dfa', line 587, column 6 to column 179)", + " (in 'dfa', line 581, column 11 to line 588, column 5)", + " (in 'dfa', line 574, column 6 to column 12)", + " (in 'dfa', line 577, column 10 to column 20)", + " (in 'dfa', line 578, column 10 to column 72)", + " (in 'dfa', line 576, column 22 to line 579, column 9)", + " (in 'dfa', line 576, column 8 to line 579, column 9)", + " (in 'dfa', line 575, column 20 to line 580, column 7)", + " (in 'dfa', line 575, column 6 to line 580, column 7)", + " (in 'dfa', line 573, column 23 to line 581, column 5)", + " (in 'dfa', line 573, column 4 to line 588, column 5)", + " (in 'dfa', line 572, column 19 to line 589, column 3)", + " (in 'dfa', line 572, column 2 to line 600, column 3)", + " (in 'dfa', line 602, column 4 to column 23)", + " (in 'dfa', line 601, column 16 to line 603, column 3)", + " (in 'dfa', line 601, column 2 to line 603, column 3)", + " (in 'dfa', line 616, column 8 to column 76)", + " (in 'dfa', line 614, column 13 to line 617, column 7)", + " (in 'dfa', line 612, column 10 to column 91)", + " (in 'dfa', line 611, column 15 to line 613, column 9)", + " (in 'dfa', line 610, column 10 to column 88)", + " (in 'dfa', line 609, column 30 to line 611, column 9)", + " (in 'dfa', line 609, column 8 to line 613, column 9)", + " (in 'dfa', line 607, column 26 to line 614, column 7)", + " (in 'dfa', line 607, column 6 to line 617, column 7)", + " (in 'dfa', line 618, column 6 to column 43)", + " (in 'dfa', line 606, column 18 to line 619, column 5)", + " (in 'dfa', line 606, column 4 to line 619, column 5)", + " (in 'dfa', line 605, column 16 to line 620, column 3)", + " (in 'dfa', line 605, column 2 to line 620, column 3)", + " (in 'dfa', line 624, column 6 to column 67)", + " (in 'dfa', line 623, column 18 to line 625, column 5)", + " (in 'dfa', line 623, column 4 to line 625, column 5)", + " (in 'dfa', line 621, column 22 to line 626, column 3)", + " (in 'dfa', line 621, column 2 to line 626, column 3)", + " (in 'dfa', line 629, column 6 to column 75)", + " (in 'dfa', line 631, column 8 to column 41)", + " (in 'dfa', line 630, column 26 to line 632, column 7)", + " (in 'dfa', line 630, column 6 to line 632, column 7)", + " (in 'dfa', line 634, column 6 to column 147)", + " (in 'dfa', line 635, column 6 to column 91)", + " (in 'dfa', line 628, column 19 to line 636, column 5)", + " (in 'dfa', line 628, column 4 to line 636, column 5)", + " (in 'dfa', line 627, column 18 to line 637, column 3)", + " (in 'dfa', line 627, column 2 to line 637, column 3)", + " (in 'dfa', line 453, column 2 to column 20)", + " (in 'dfa', line 455, column 4 to column 22)", + " (in 'dfa', line 454, column 29 to line 456, column 3)", + " (in 'dfa', line 454, column 2 to line 456, column 3)", + " (in 'dfa', line 459, column 4 to column 26)", + " (in 'dfa', line 458, column 24 to line 460, column 3)", + " (in 'dfa', line 458, column 2 to line 460, column 3)", + " (in 'dfa', line 463, column 4 to column 22)", + " (in 'dfa', line 462, column 19 to line 464, column 3)", + " (in 'dfa', line 462, column 2 to line 464, column 3)", + " (in 'dfa', line 467, column 4 to column 24)", + " (in 'dfa', line 466, column 21 to line 468, column 3)", + " (in 'dfa', line 466, column 2 to line 468, column 3)", + " (in 'dfa', line 471, column 4 to column 32)", + " (in 'dfa', line 470, column 24 to line 472, column 3)", + " (in 'dfa', line 470, column 2 to line 472, column 3)", + " (in 'dfa', line 474, column 26 to column 53)", + " (in 'dfa', line 474, column 2 to column 53)", + " (in 'dfa', line 475, column 26 to column 55)", + " (in 'dfa', line 475, column 2 to column 55)", + " (in 'dfa', line 476, column 24 to column 53)", + " (in 'dfa', line 476, column 2 to column 53)", + " (in 'dfa', line 479, column 4 to column 33)", + " (in 'dfa', line 478, column 19 to line 480, column 3)", + " (in 'dfa', line 478, column 2 to line 480, column 3)", + " (in 'dfa', line 486, column 4 to column 63)", + " (in 'dfa', line 489, column 6 to column 37)", + " (in 'dfa', line 488, column 18 to line 490, column 5)", + " (in 'dfa', line 488, column 4 to line 490, column 5)", + " (in 'dfa', line 481, column 16 to line 491, column 3)", + " (in 'dfa', line 481, column 2 to line 491, column 3)", + " (in 'dfa', line 514, column 8 to column 33)", + " (in 'dfa', line 517, column 10 to column 69)", + " (in 'dfa', line 515, column 26 to line 518, column 9)", + " (in 'dfa', line 515, column 8 to line 518, column 9)", + " (in 'dfa', line 513, column 13 to line 519, column 7)", + " (in 'dfa', line 502, column 12 to column 61)", + " (in 'dfa', line 501, column 17 to line 503, column 11)", + " (in 'dfa', line 500, column 12 to column 58)", + " (in 'dfa', line 499, column 32 to line 501, column 11)", + " (in 'dfa', line 499, column 10 to line 503, column 11)", + " (in 'dfa', line 498, column 22 to line 504, column 9)", + " (in 'dfa', line 498, column 8 to line 504, column 9)", + " (in 'dfa', line 510, column 12 to column 84)", + " (in 'dfa', line 509, column 17 to line 511, column 11)", + " (in 'dfa', line 508, column 12 to column 81)", + " (in 'dfa', line 507, column 32 to line 509, column 11)", + " (in 'dfa', line 507, column 10 to line 511, column 11)", + " (in 'dfa', line 505, column 26 to line 512, column 9)", + " (in 'dfa', line 505, column 8 to line 512, column 9)", + " (in 'dfa', line 497, column 26 to line 513, column 7)", + " (in 'dfa', line 497, column 6 to line 519, column 7)", + " (in 'dfa', line 496, column 18 to line 520, column 5)", + " (in 'dfa', line 496, column 4 to line 520, column 5)", + " (in 'dfa', line 495, column 18 to line 521, column 3)", + " (in 'dfa', line 495, column 2 to line 521, column 3)", + " (in 'dfa', line 524, column 6 to column 33)", + " (in 'dfa', line 523, column 18 to line 525, column 5)", + " (in 'dfa', line 523, column 4 to line 525, column 5)", + " (in 'dfa', line 522, column 20 to line 526, column 3)", + " (in 'dfa', line 522, column 2 to line 526, column 3)", + " (in 'dfa', line 533, column 6 to column 36)", + " (in 'dfa', line 532, column 18 to line 534, column 5)", + " (in 'dfa', line 532, column 4 to line 534, column 5)", + " (in 'dfa', line 531, column 9 to line 535, column 3)", + " (in 'dfa', line 529, column 4 to column 21)", + " (in 'dfa', line 530, column 4 to column 24)", + " (in 'dfa', line 527, column 30 to line 531, column 3)", + " (in 'dfa', line 527, column 2 to line 535, column 3)", + " (in 'dfa', line 553, column 44 to column 241)", + " (in 'dfa', line 553, column 26 to column 241)", + " (in 'dfa', line 553, column 25 to column 242)", + " (in 'dfa', line 553, column 6 to column 242)", + " (in 'dfa', line 552, column 11 to line 554, column 5)", + " (in 'dfa', line 551, column 40 to column 141)", + " (in 'dfa', line 551, column 26 to column 141)", + " (in 'dfa', line 551, column 25 to column 142)", + " (in 'dfa', line 551, column 6 to column 142)", + " (in 'dfa', line 550, column 23 to line 552, column 5)", + " (in 'dfa', line 550, column 4 to line 554, column 5)", + " (in 'dfa', line 548, column 9 to line 555, column 3)", + " (in 'dfa', line 541, column 46 to column 205)", + " (in 'dfa', line 541, column 28 to column 205)", + " (in 'dfa', line 541, column 27 to column 206)", + " (in 'dfa', line 541, column 8 to column 206)", + " (in 'dfa', line 542, column 46 to column 211)", + " (in 'dfa', line 542, column 28 to column 211)", + " (in 'dfa', line 542, column 27 to column 212)", + " (in 'dfa', line 542, column 8 to column 212)", + " (in 'dfa', line 543, column 46 to column 155)", + " (in 'dfa', line 543, column 28 to column 155)", + " (in 'dfa', line 543, column 27 to column 156)", + " (in 'dfa', line 543, column 8 to column 156)", + " (in 'dfa', line 544, column 46 to column 191)", + " (in 'dfa', line 544, column 28 to column 191)", + " (in 'dfa', line 544, column 27 to column 192)", + " (in 'dfa', line 544, column 8 to column 192)", + " (in 'dfa', line 545, column 46 to column 159)", + " (in 'dfa', line 545, column 28 to column 159)", + " (in 'dfa', line 545, column 27 to column 160)", + " (in 'dfa', line 545, column 8 to column 160)", + " (in 'dfa', line 546, column 46 to column 177)", + " (in 'dfa', line 546, column 28 to column 177)", + " (in 'dfa', line 546, column 27 to column 178)", + " (in 'dfa', line 546, column 8 to column 178)", + " (in 'dfa', line 540, column 11 to line 547, column 5)", + " (in 'dfa', line 539, column 40 to column 95)", + " (in 'dfa', line 539, column 26 to column 95)", + " (in 'dfa', line 539, column 25 to column 96)", + " (in 'dfa', line 539, column 6 to column 96)", + " (in 'dfa', line 538, column 23 to line 540, column 5)", + " (in 'dfa', line 538, column 4 to line 547, column 5)", + " (in 'dfa', line 537, column 19 to line 548, column 3)", + " (in 'dfa', line 537, column 2 to line 555, column 3)", + " (in 'dfa', line 58, column 2 to column 17)", + " (in 'dfa', line 59, column 2 to column 17)", + " (in 'dfa', line 60, column 2 to column 17)", + " (in 'dfa', line 61, column 2 to column 18)", + " (in 'dfa', line 62, column 24 to column 26)", + " (in 'dfa', line 62, column 2 to column 28)", + " (in 'dfa', line 63, column 24 to column 26)", + " (in 'dfa', line 63, column 2 to column 28)", + " (in 'dfa', line 64, column 2 to column 26)", + " (in 'dfa', line 65, column 23 to column 24)", + " (in 'dfa', line 65, column 2 to column 26)", + " (in 'dfa', line 66, column 2 to column 21)", + " (in 'dfa', line 67, column 26 to column 31)", + " (in 'dfa', line 67, column 2 to column 33)", + " (in 'dfa', line 68, column 26 to column 31)", + " (in 'dfa', line 68, column 2 to column 33)", + " (in 'dfa', line 69, column 2 to column 21)", + " (in 'dfa', line 70, column 28 to column 33)", + " (in 'dfa', line 70, column 2 to column 35)", + " (in 'dfa', line 71, column 28 to column 33)", + " (in 'dfa', line 71, column 2 to column 35)", + " (in 'dfa', line 72, column 9 to column 14)", + " (in 'dfa', line 72, column 2 to column 16)", + " (in 'dfa', line 73, column 21 to column 26)", + " (in 'dfa', line 73, column 2 to column 28)", + " (in 'dfa', line 74, column 14 to column 19)", + " (in 'dfa', line 74, column 2 to column 21)", + " (in 'dfa', line 75, column 2 to column 20)", + " (in 'dfa', line 76, column 27 to column 31)", + " (in 'dfa', line 76, column 2 to column 33)", + " (in 'dfa', line 77, column 27 to column 31)", + " (in 'dfa', line 77, column 2 to column 33)", + " (in 'dfa', line 78, column 2 to column 25)", + " (in 'dfa', line 79, column 2 to column 18)", + " (in 'dfa', line 80, column 2 to column 17)", + " (in 'dfa', line 81, column 2 to column 14)", + " (in 'dfa', line 82, column 2 to column 14)", + " (in 'dfa', line 83, column 2 to column 16)", + " (in 'dfa', line 84, column 2 to column 29)", + " (in 'dfa', line 85, column 2 to column 27)", + " (in 'dfa', line 86, column 22 to column 35)", + " (in 'dfa', line 86, column 2 to column 39)", + " (in 'dfa', line 87, column 23 to column 36)", + " (in 'dfa', line 87, column 2 to column 38)", + " (in 'dfa', line 88, column 22 to column 35)", + " (in 'dfa', line 88, column 2 to column 37)", + " (in 'dfa', line 89, column 2 to column 29)", + " (in 'dfa', line 90, column 2 to column 27)", + " (in 'dfa', line 91, column 22 to column 35)", + " (in 'dfa', line 91, column 2 to column 39)", + " (in 'dfa', line 92, column 23 to column 36)", + " (in 'dfa', line 92, column 2 to column 38)", + " (in 'dfa', line 93, column 2 to column 18)", + " (in 'dfa', line 94, column 2 to column 27)", + " (in 'dfa', line 95, column 2 to column 34)", + " (in 'dfa', line 96, column 2 to column 33)", + " (in 'dfa', line 97, column 2 to column 31)", + " (in 'dfa', line 98, column 2 to column 22)", + " (in 'dfa', line 99, column 2 to column 26)", + " (in 'dfa', line 100, column 2 to column 22)", + " (in 'dfa', line 101, column 2 to column 23)", + " (in 'dfa', line 102, column 9 to column 10)", + " (in 'dfa', line 102, column 12 to column 19)", + " (in 'dfa', line 102, column 2 to column 30)", + " (in 'dfa', line 103, column 17 to column 24)", + " (in 'dfa', line 103, column 2 to column 26)", + " (in 'dfa', line 107, column 12 to column 19)", + " (in 'dfa', line 107, column 2 to column 38)", + " (in 'dfa', line 108, column 2 to column 16)", + " (in 'dfa', line 109, column 2 to column 41)", + " (in 'dfa', line 110, column 2 to column 41)", + " (in 'dfa', line 111, column 2 to column 39)", + " (in 'dfa', line 112, column 2 to column 44)", + " (in 'dfa', line 113, column 2 to column 25)", + " (in 'dfa', line 114, column 19 to column 24)", + " (in 'dfa', line 114, column 2 to column 26)", + " (in 'dfa', line 117, column 2 to column 13)", + " (in 'dfa', line 118, column 2 to column 15)", + " (in 'dfa', line 119, column 9 to column 10)", + " (in 'dfa', line 119, column 2 to column 18)", + " (in 'dfa', line 120, column 17 to column 18)", + " (in 'dfa', line 120, column 2 to column 20)", + " (in 'dfa', line 121, column 23 to column 28)", + " (in 'dfa', line 121, column 2 to column 30)", + " (in 'dfa', line 122, column 9 to column 29)", + " (in 'dfa', line 122, column 2 to column 41)", + " (in 'dfa', line 123, column 9 to column 16)", + " (in 'dfa', line 123, column 2 to column 26)", + " (in 'dfa', line 124, column 2 to column 23)", + " (in 'dfa', line 125, column 2 to column 21)", + " (in 'dfa', line 127, column 4 to column 45)", + " (in 'dfa', line 126, column 20 to line 128, column 3)", + " (in 'dfa', line 126, column 2 to line 128, column 3)", + " (in 'dfa', line 130, column 4 to column 21)", + " (in 'dfa', line 129, column 16 to line 131, column 3)", + " (in 'dfa', line 129, column 2 to line 131, column 3)", + " (in 'dfa', line 133, column 4 to column 17)", + " (in 'dfa', line 132, column 16 to line 134, column 3)", + " (in 'dfa', line 132, column 2 to line 134, column 3)", + " (in 'dfa', line 136, column 4 to column 19)", + " (in 'dfa', line 135, column 22 to line 137, column 3)", + " (in 'dfa', line 135, column 2 to line 137, column 3)", + " (in 'dfa', line 139, column 2 to column 19)", + " (in 'dfa', line 144, column 6 to column 19)", + " (in 'dfa', line 143, column 11 to line 145, column 5)", + " (in 'dfa', line 142, column 6 to column 23)", + " (in 'dfa', line 141, column 21 to line 143, column 5)", + " (in 'dfa', line 141, column 4 to line 145, column 5)", + " (in 'dfa', line 140, column 21 to line 146, column 3)", + " (in 'dfa', line 140, column 2 to line 146, column 3)", + " (in 'dfa', line 156, column 4 to column 15)", + " (in 'dfa', line 154, column 9 to line 157, column 3)", + " (in 'dfa', line 149, column 4 to column 15)", + " (in 'dfa', line 152, column 6 to column 17)", + " (in 'dfa', line 150, column 23 to line 153, column 5)", + " (in 'dfa', line 150, column 4 to line 153, column 5)", + " (in 'dfa', line 147, column 19 to line 154, column 3)", + " (in 'dfa', line 147, column 2 to line 157, column 3)", + " (in 'dfa', line 160, column 18 to column 35)", + " (in 'dfa', line 160, column 4 to column 35)", + " (in 'dfa', line 159, column 28 to line 161, column 3)", + " (in 'dfa', line 159, column 2 to line 161, column 3)", + " (in 'dfa', line 163, column 2 to column 23)", + " (in 'dfa', line 164, column 29 to column 47)", + " (in 'dfa', line 164, column 2 to column 47)", + " (in 'dfa', line 167, column 9 to column 19)", + " (in 'dfa', line 167, column 20 to column 34)", + " (in 'dfa', line 168, column 9 to column 10)", + " (in 'dfa', line 169, column 18 to column 62)", + " (in 'dfa', line 170, column 44 to column 69)", + " (in 'dfa', line 171, column 30 to column 54)", + " (in 'dfa', line 172, column 17 to column 37)", + " (in 'dfa', line 172, column 10 to column 11)", + " (in 'dfa', line 173, column 9 to column 23)", + " (in 'dfa', line 173, column 25 to column 45)", + " (in 'dfa', line 174, column 9 to column 20)", + " (in 'dfa', line 174, column 22 to column 23)", + " (in 'dfa', line 175, column 9 to column 20)", + " (in 'dfa', line 175, column 22 to column 23)", + " (in 'dfa', line 176, column 22 to column 49)", + " (in 'dfa', line 177, column 24 to column 51)", + " (in 'dfa', line 178, column 24 to column 49)", + " (in 'dfa', line 179, column 19 to column 30)", + " (in 'dfa', line 180, column 13 to column 17)", + " (in 'dfa', line 181, column 29 to column 38)", + " (in 'dfa', line 182, column 31 to column 42)", + " (in 'dfa', line 183, column 25 to column 33)", + " (in 'dfa', line 184, column 23 to column 29)", + " (in 'dfa', line 185, column 30 to column 65)", + " (in 'dfa', line 186, column 39 to column 49)", + " (in 'dfa', line 186, column 9 to column 24)", + " (in 'dfa', line 189, column 9 to column 10)", + " (in 'dfa', line 189, column 11 to column 12)", + " (in 'dfa', line 190, column 9 to column 10)", + " (in 'dfa', line 190, column 11 to column 12)", + " (in 'dfa', line 191, column 9 to column 10)", + " (in 'dfa', line 191, column 11 to column 12)", + " (in 'dfa', line 192, column 18 to column 36)", + " (in 'dfa', line 193, column 18 to column 36)", + " (in 'dfa', line 194, column 18 to column 34)", + " (in 'dfa', line 195, column 9 to column 10)", + " (in 'dfa', line 196, column 9 to column 10)", + " (in 'dfa', line 197, column 9 to column 10)", + " (in 'dfa', line 197, column 11 to column 12)", + " (in 'dfa', line 198, column 9 to column 10)", + " (in 'dfa', line 199, column 18 to column 39)", + " (in 'dfa', line 200, column 9 to column 35)", + " (in 'dfa', line 200, column 37 to column 63)", + " (in 'dfa', line 201, column 9 to column 39)", + " (in 'dfa', line 201, column 41 to column 71)", + " (in 'dfa', line 202, column 9 to column 17)", + " (in 'dfa', line 202, column 18 to column 19)", + " (in 'dfa', line 203, column 9 to column 30)", + " (in 'dfa', line 203, column 32 to column 53)", + " (in 'dfa', line 204, column 9 to column 30)", + " (in 'dfa', line 204, column 32 to column 53)", + " (in 'dfa', line 205, column 9 to column 30)", + " (in 'dfa', line 206, column 9 to column 30)", + " (in 'dfa', line 208, column 9 to column 10)", + " (in 'dfa', line 209, column 9 to column 23)", + " (in 'dfa', line 209, column 25 to column 45)", + " (in 'dfa', line 210, column 38 to column 39)", + " (in 'dfa', line 210, column 9 to column 16)", + " (in 'dfa', line 210, column 18 to column 25)", + " (in 'dfa', line 213, column 9 to column 14)", + " (in 'dfa', line 558, column 9 to column 17)", + " (in 'dfa', line 559, column 9 to column 15)", + " (in 'dfa', line 559, column 17 to column 23)", + " (in 'dfa', line 560, column 9 to column 15)", + " (in 'dfa', line 560, column 17 to column 23)", + " (in 'dfa', line 561, column 9 to column 10)", + " (in 'dfa', line 561, column 11 to column 12)", + " (in 'dfa', line 562, column 9 to column 10)", + " (in 'dfa', line 563, column 9 to column 16)", + " (in 'dfa', line 563, column 18 to column 25)", + " (in 'dfa', line 564, column 13 to column 20)", + " (in 'dfa', line 7, column 13 to column 16)", + " (in 'dfa', line 7, column 17 to column 20)", + " (in 'dfa', line 7, column 6 to column 29)", + " (in 'dfa', line 8, column 6 to column 18)", + " (in 'dfa', line 9, column 6 to column 18)", + " (in 'dfa', line 10, column 6 to column 18)", + " (in 'dfa', line 13, column 10 to column 32)", + " (in 'dfa', line 14, column 10 to column 22)", + " (in 'dfa', line 17, column 14 to column 36)", + " (in 'dfa', line 18, column 14 to column 49)", + " (in 'dfa', line 16, column 27 to line 19, column 13)", + " (in 'dfa', line 16, column 12 to line 19, column 13)", + " (in 'dfa', line 15, column 25 to line 20, column 11)", + " (in 'dfa', line 15, column 10 to line 20, column 11)", + " (in 'dfa', line 12, column 23 to line 21, column 9)", + " (in 'dfa', line 12, column 8 to line 21, column 9)", + " (in 'dfa', line 11, column 21 to line 22, column 7)", + " (in 'dfa', line 11, column 6 to line 22, column 7)", + " (in 'dfa', line 23, column 6 to column 20)", + " (in 'dfa', line 6, column 4 to line 24, column 5)", + " (in 'dfa', line 3, column 43 to line 25, column 3)", + " (in 'dfa', line 29, column 13 to column 16)", + " (in 'dfa', line 29, column 6 to column 27)", + " (in 'dfa', line 30, column 6 to column 18)", + " (in 'dfa', line 31, column 6 to column 18)", + " (in 'dfa', line 34, column 10 to column 32)", + " (in 'dfa', line 35, column 10 to column 41)", + " (in 'dfa', line 33, column 23 to line 36, column 9)", + " (in 'dfa', line 33, column 8 to line 36, column 9)", + " (in 'dfa', line 32, column 21 to line 37, column 7)", + " (in 'dfa', line 32, column 6 to line 37, column 7)", + " (in 'dfa', line 38, column 6 to column 20)", + " (in 'dfa', line 28, column 4 to line 39, column 5)", + " (in 'dfa', line 26, column 46 to line 40, column 3)", + " (in 'dfa', line 44, column 13 to column 16)", + " (in 'dfa', line 44, column 6 to column 27)", + " (in 'dfa', line 45, column 6 to column 18)", + " (in 'dfa', line 46, column 6 to column 18)", + " (in 'dfa', line 49, column 10 to column 32)", + " (in 'dfa', line 50, column 10 to column 35)", + " (in 'dfa', line 48, column 23 to line 51, column 9)", + " (in 'dfa', line 48, column 8 to line 51, column 9)", + " (in 'dfa', line 47, column 21 to line 52, column 7)", + " (in 'dfa', line 47, column 6 to line 52, column 7)", + " (in 'dfa', line 53, column 6 to column 20)", + " (in 'dfa', line 43, column 4 to line 54, column 5)", + " (in 'dfa', line 41, column 47 to line 55, column 3)"}; template -Eigen::Matrix::type, Eigen::Dynamic, Eigen::Dynamic> -subset(const Eigen::Matrix& x, - const int& drop, - const int& P, std::ostream* pstream__) { - typedef typename boost::math::tools::promote_args::type local_scalar_t__; - typedef local_scalar_t__ fun_return_scalar_t__; - const static bool propto__ = true; - (void) propto__; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - (void) DUMMY_VAR__; // suppress unused var warning - int current_statement_begin__ = -1; - try { - { - current_statement_begin__ = 9; - validate_non_negative_index("result", "(P - 1)", (P - 1)); - validate_non_negative_index("result", "(P - 1)", (P - 1)); - Eigen::Matrix result((P - 1), (P - 1)); - stan::math::initialize(result, DUMMY_VAR__); - stan::math::fill(result, DUMMY_VAR__); - current_statement_begin__ = 11; - int rowindx(0); - (void) rowindx; // dummy to suppress unused var warning - stan::math::fill(rowindx, std::numeric_limits::min()); - current_statement_begin__ = 12; - int colindx(0); - (void) colindx; // dummy to suppress unused var warning - stan::math::fill(colindx, std::numeric_limits::min()); - current_statement_begin__ = 13; - stan::math::assign(rowindx, 0); - current_statement_begin__ = 14; - for (int i = 1; i <= P; ++i) { - current_statement_begin__ = 15; - if (as_bool(logical_neq(i, drop))) { - current_statement_begin__ = 16; - stan::math::assign(rowindx, (rowindx + 1)); - current_statement_begin__ = 17; - stan::math::assign(colindx, 0); - current_statement_begin__ = 18; - for (int j = 1; j <= P; ++j) { - current_statement_begin__ = 19; - if (as_bool(logical_neq(j, drop))) { - current_statement_begin__ = 20; - stan::math::assign(colindx, (colindx + 1)); - current_statement_begin__ = 21; - stan::model::assign(result, - stan::model::cons_list(stan::model::index_uni(rowindx), stan::model::cons_list(stan::model::index_uni(colindx), stan::model::nil_index_list())), - get_base1(x, i, j, "x", 1), - "assigning variable result"); - } - } - } - } - current_statement_begin__ = 27; - return stan::math::promote_scalar(result); - } - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__()); - // Next line prevents compiler griping about no return - throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); +Eigen::Matrix>, -1, -1> +subset(const T0__& x_arg__, const int& drop, const int& P, + std::ostream* pstream__) { + using local_scalar_t__ = stan::promote_args_t>; + const auto& x = to_ref(x_arg__); + const static bool propto__ = true; + (void) propto__; + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + (void) DUMMY_VAR__; // suppress unused var warning + + try { + { + current_statement__ = 637; + validate_non_negative_index("result", "P - 1", (P - 1)); + current_statement__ = 638; + validate_non_negative_index("result", "P - 1", (P - 1)); + Eigen::Matrix result; + result = Eigen::Matrix((P - 1), (P - 1)); + stan::math::fill(result, DUMMY_VAR__); + + int rowindx; + rowindx = std::numeric_limits::min(); + + int colindx; + colindx = std::numeric_limits::min(); + + current_statement__ = 642; + rowindx = 0; + current_statement__ = 654; + for (int i = 1; i <= P; ++i) { + current_statement__ = 652; + if (logical_neq(i, drop)) { + current_statement__ = 643; + rowindx = (rowindx + 1); + current_statement__ = 644; + colindx = 0; + current_statement__ = 650; + for (int j = 1; j <= P; ++j) { + current_statement__ = 648; + if (logical_neq(j, drop)) { + current_statement__ = 645; + colindx = (colindx + 1); + current_statement__ = 646; + assign(result, + cons_list(index_uni(rowindx), + cons_list(index_uni(colindx), nil_index_list())), + rvalue(x, + cons_list(index_uni(i), + cons_list(index_uni(j), nil_index_list())), "x"), + "assigning variable result"); + } } + } } + current_statement__ = 655; + return result; } + } 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 subset_functor__ { - template - Eigen::Matrix::type, Eigen::Dynamic, Eigen::Dynamic> - operator()(const Eigen::Matrix& x, - const int& drop, - const int& P, std::ostream* pstream__) const { - return subset(x, drop, P, pstream__); - } +template +Eigen::Matrix>, -1, -1> +operator()(const T0__& x, const int& drop, const int& P, + std::ostream* pstream__) const +{ +return subset(x, drop, P, pstream__); +} }; template -Eigen::Matrix::type, Eigen::Dynamic, Eigen::Dynamic> -subsetvec(const Eigen::Matrix& x, - const int& drop, - const int& P, std::ostream* pstream__) { - typedef typename boost::math::tools::promote_args::type local_scalar_t__; - typedef local_scalar_t__ fun_return_scalar_t__; - const static bool propto__ = true; - (void) propto__; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - (void) DUMMY_VAR__; // suppress unused var warning - int current_statement_begin__ = -1; - try { - { - current_statement_begin__ = 34; - validate_non_negative_index("result", "(P - 1)", (P - 1)); - validate_non_negative_index("result", "1", 1); - Eigen::Matrix result((P - 1), 1); - stan::math::initialize(result, DUMMY_VAR__); - stan::math::fill(result, DUMMY_VAR__); - current_statement_begin__ = 36; - int rowindx(0); - (void) rowindx; // dummy to suppress unused var warning - stan::math::fill(rowindx, std::numeric_limits::min()); - current_statement_begin__ = 37; - stan::math::assign(rowindx, 0); - current_statement_begin__ = 38; - for (int i = 1; i <= P; ++i) { - current_statement_begin__ = 39; - if (as_bool(logical_neq(i, drop))) { - current_statement_begin__ = 40; - stan::math::assign(rowindx, (rowindx + 1)); - current_statement_begin__ = 41; - stan::model::assign(result, - stan::model::cons_list(stan::model::index_uni(rowindx), stan::model::cons_list(stan::model::index_uni(1), stan::model::nil_index_list())), - get_base1(x, i, drop, "x", 1), - "assigning variable result"); - } - } - current_statement_begin__ = 45; - return stan::math::promote_scalar(result); - } - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__()); - // Next line prevents compiler griping about no return - throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); +Eigen::Matrix>, -1, -1> +subsetvec(const T0__& x_arg__, const int& drop, const int& P, + std::ostream* pstream__) { + using local_scalar_t__ = stan::promote_args_t>; + const auto& x = to_ref(x_arg__); + const static bool propto__ = true; + (void) propto__; + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + (void) DUMMY_VAR__; // suppress unused var warning + + try { + { + current_statement__ = 658; + validate_non_negative_index("result", "P - 1", (P - 1)); + Eigen::Matrix result; + result = Eigen::Matrix((P - 1), 1); + stan::math::fill(result, DUMMY_VAR__); + + int rowindx; + rowindx = std::numeric_limits::min(); + + current_statement__ = 661; + rowindx = 0; + current_statement__ = 667; + for (int i = 1; i <= P; ++i) { + current_statement__ = 665; + if (logical_neq(i, drop)) { + current_statement__ = 662; + rowindx = (rowindx + 1); + current_statement__ = 663; + assign(result, + cons_list(index_uni(rowindx), + cons_list(index_uni(1), nil_index_list())), + rvalue(x, + cons_list(index_uni(i), + cons_list(index_uni(drop), nil_index_list())), "x"), + "assigning variable result"); + } } + current_statement__ = 668; + return result; } + } 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 subsetvec_functor__ { - template - Eigen::Matrix::type, Eigen::Dynamic, Eigen::Dynamic> - operator()(const Eigen::Matrix& x, - const int& drop, - const int& P, std::ostream* pstream__) const { - return subsetvec(x, drop, P, pstream__); - } +template +Eigen::Matrix>, -1, -1> +operator()(const T0__& x, const int& drop, const int& P, + std::ostream* pstream__) const +{ +return subsetvec(x, drop, P, pstream__); +} }; template -Eigen::Matrix::type, Eigen::Dynamic, Eigen::Dynamic> -subsetvec2(const Eigen::Matrix& x, - const int& drop, - const int& P, std::ostream* pstream__) { - typedef typename boost::math::tools::promote_args::type local_scalar_t__; - typedef local_scalar_t__ fun_return_scalar_t__; - const static bool propto__ = true; - (void) propto__; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - (void) DUMMY_VAR__; // suppress unused var warning - int current_statement_begin__ = -1; - try { - { - current_statement_begin__ = 52; - validate_non_negative_index("result", "(P - 1)", (P - 1)); - validate_non_negative_index("result", "1", 1); - Eigen::Matrix result((P - 1), 1); - stan::math::initialize(result, DUMMY_VAR__); - stan::math::fill(result, DUMMY_VAR__); - current_statement_begin__ = 54; - int rowindx(0); - (void) rowindx; // dummy to suppress unused var warning - stan::math::fill(rowindx, std::numeric_limits::min()); - current_statement_begin__ = 55; - stan::math::assign(rowindx, 0); - current_statement_begin__ = 56; - for (int i = 1; i <= P; ++i) { - current_statement_begin__ = 57; - if (as_bool(logical_neq(i, drop))) { - current_statement_begin__ = 58; - stan::math::assign(rowindx, (rowindx + 1)); - current_statement_begin__ = 59; - stan::model::assign(result, - stan::model::cons_list(stan::model::index_uni(rowindx), stan::model::cons_list(stan::model::index_uni(1), stan::model::nil_index_list())), - get_base1(x, i, "x", 1), - "assigning variable result"); - } - } - current_statement_begin__ = 63; - return stan::math::promote_scalar(result); - } - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__()); - // Next line prevents compiler griping about no return - throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); +Eigen::Matrix>, -1, -1> +subsetvec2(const T0__& x_arg__, const int& drop, const int& P, + std::ostream* pstream__) { + using local_scalar_t__ = stan::promote_args_t>; + const auto& x = to_ref(x_arg__); + const static bool propto__ = true; + (void) propto__; + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + (void) DUMMY_VAR__; // suppress unused var warning + + try { + { + current_statement__ = 671; + validate_non_negative_index("result", "P - 1", (P - 1)); + Eigen::Matrix result; + result = Eigen::Matrix((P - 1), 1); + stan::math::fill(result, DUMMY_VAR__); + + int rowindx; + rowindx = std::numeric_limits::min(); + + current_statement__ = 674; + rowindx = 0; + current_statement__ = 680; + for (int i = 1; i <= P; ++i) { + current_statement__ = 678; + if (logical_neq(i, drop)) { + current_statement__ = 675; + rowindx = (rowindx + 1); + current_statement__ = 676; + assign(result, + cons_list(index_uni(rowindx), + cons_list(index_uni(1), nil_index_list())), x[(i - 1)], + "assigning variable result"); + } } + current_statement__ = 681; + return result; } + } 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 subsetvec2_functor__ { - template - Eigen::Matrix::type, Eigen::Dynamic, Eigen::Dynamic> - operator()(const Eigen::Matrix& x, - const int& drop, - const int& P, std::ostream* pstream__) const { - return subsetvec2(x, drop, P, pstream__); - } +template +Eigen::Matrix>, -1, -1> +operator()(const T0__& x, const int& drop, const int& P, + std::ostream* pstream__) const +{ +return subsetvec2(x, drop, P, pstream__); +} }; #include -class model_dfa - : public stan::model::model_base_crtp { +class model_dfa final : public model_base_crtp { private: - int N; - int P; - int K; - int nZ; - std::vector row_indx; - std::vector col_indx; - int nVariances; - std::vector varIndx; - int nZero; - std::vector row_indx_z; - std::vector col_indx_z; - int n_pos; - std::vector row_indx_pos; - std::vector col_indx_pos; - std::vector y; - std::vector y_int; - std::vector offset; - int n_na; - std::vector row_indx_na; - std::vector col_indx_na; - double nu_fixed; - int estimate_nu; - int use_normal; - int est_cor; - int est_phi; - int est_theta; - int num_obs_covar; - int n_obs_covar; - std::vector > obs_covar_index; - std::vector obs_covar_value; - std::vector match_obs_covar; - int num_pro_covar; - int n_pro_covar; - std::vector > pro_covar_index; - std::vector pro_covar_value; - std::vector z_bound; - int long_format; - int proportional_model; - int est_sigma_process; - int n_sigma_process; - int est_rw; - int est_spline; - int est_gp; - int n_knots; - matrix_d X_spline; - std::vector knot_locs; - matrix_d distKnots21_pred; - int obs_model; - int est_sigma_params; - int est_gamma_params; - int est_nb2_params; - int use_expansion_prior; - std::vector gp_theta_prior; - std::vector weights_vec; - int n_pcor; - int n_loglik; - vector_d zeros; - std::vector data_locs; - std::vector log_weights_vec; - vector_d alpha_vec; - vector_d muZeros; - double gp_delta; - double lower_bound_z; + int N; + int P; + int K; + int nZ; + std::vector row_indx; + std::vector col_indx; + int nVariances; + std::vector varIndx; + int nZero; + std::vector row_indx_z; + std::vector col_indx_z; + int n_pos; + std::vector row_indx_pos; + std::vector col_indx_pos; + std::vector y; + std::vector y_int; + std::vector offset; + int n_na; + std::vector row_indx_na; + std::vector col_indx_na; + double nu_fixed; + int estimate_nu; + int use_normal; + int est_cor; + int est_phi; + int est_theta; + int num_obs_covar; + int n_obs_covar; + std::vector> obs_covar_index; + std::vector obs_covar_value; + std::vector match_obs_covar; + int num_pro_covar; + int n_pro_covar; + std::vector> pro_covar_index; + std::vector pro_covar_value; + std::vector z_bound; + int long_format; + int proportional_model; + int est_sigma_process; + int n_sigma_process; + int est_rw; + int est_spline; + int est_gp; + int n_knots; + Eigen::Matrix X_spline; + std::vector knot_locs; + Eigen::Matrix distKnots21_pred; + int obs_model; + int est_sigma_params; + int est_gamma_params; + int est_nb2_params; + int use_expansion_prior; + std::vector gp_theta_prior; + std::vector weights_vec; + int n_pcor; + int n_loglik; + Eigen::Matrix zeros; + std::vector data_locs; + std::vector log_weights_vec; + Eigen::Matrix alpha_vec; + Eigen::Matrix muZeros; + double gp_delta; + double lower_bound_z; + int devs_1dim__; + int devs_2dim__; + int psi_1dim__; + int z_1dim__; + int zpos_1dim__; + int p_z_1dim__; + int spline_a_1dim__; + int spline_a_2dim__; + int sigma_1dim__; + int gamma_a_1dim__; + int nb2_phi_1dim__; + int phi_1dim__; + int theta_1dim__; + int gp_theta_1dim__; + int sigma_process_1dim__; + int effectsKnots_1dim__; + int effectsKnots_2dim__; + int sigma_vec_1dim__; + int gamma_a_vec_1dim__; + int nb_phi_vec_1dim__; + int psi_root_1dim__; + int Sigma_derived_1dim__; + int Sigma_derived_2dim__; + int Sigma_temp_1dim__; + int Sigma_temp_2dim__; + int sigma12_vec_1dim__; + int temp_sums_1dim__; + int temp_sums_2dim__; + int temp_counts_1dim__; + int temp_counts_2dim__; + int cond_sigma_vec_1dim__; + int cond_mean_vec_1dim__; + int spline_a_trans_1dim__; + int spline_a_trans_2dim__; + public: - model_dfa(stan::io::var_context& context__, - std::ostream* pstream__ = 0) - : model_base_crtp(0) { - ctor_body(context__, 0, pstream__); + ~model_dfa() { } + + inline std::string model_name() const final { return "model_dfa"; } + inline std::vector model_compile_info() const noexcept { + return std::vector{"stanc_version = stanc3 v2.26.1-4-gd72b68b7-dirty", "stancflags = "}; + } + + + model_dfa(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_dfa_namespace::model_dfa"; + (void) function__; // suppress unused var warning + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + (void) DUMMY_VAR__; // suppress unused var warning + + try { + int pos__; + pos__ = std::numeric_limits::min(); + + pos__ = 1; + current_statement__ = 441; + context__.validate_dims("data initialization","N","int", + context__.to_vec()); + N = std::numeric_limits::min(); + + current_statement__ = 441; + N = context__.vals_i("N")[(1 - 1)]; + current_statement__ = 441; + current_statement__ = 441; + check_greater_or_equal(function__, "N", N, 0); + current_statement__ = 442; + context__.validate_dims("data initialization","P","int", + context__.to_vec()); + P = std::numeric_limits::min(); + + current_statement__ = 442; + P = context__.vals_i("P")[(1 - 1)]; + current_statement__ = 442; + current_statement__ = 442; + check_greater_or_equal(function__, "P", P, 0); + current_statement__ = 443; + context__.validate_dims("data initialization","K","int", + context__.to_vec()); + K = std::numeric_limits::min(); + + current_statement__ = 443; + K = context__.vals_i("K")[(1 - 1)]; + current_statement__ = 443; + current_statement__ = 443; + check_greater_or_equal(function__, "K", K, 0); + current_statement__ = 444; + context__.validate_dims("data initialization","nZ","int", + context__.to_vec()); + nZ = std::numeric_limits::min(); + + current_statement__ = 444; + nZ = context__.vals_i("nZ")[(1 - 1)]; + current_statement__ = 444; + current_statement__ = 444; + check_greater_or_equal(function__, "nZ", nZ, 0); + current_statement__ = 445; + validate_non_negative_index("row_indx", "nZ", nZ); + current_statement__ = 446; + context__.validate_dims("data initialization","row_indx","int", + context__.to_vec(nZ)); + row_indx = std::vector(nZ, std::numeric_limits::min()); + + current_statement__ = 446; + assign(row_indx, nil_index_list(), context__.vals_i("row_indx"), + "assigning variable row_indx"); + current_statement__ = 446; + for (int sym1__ = 1; sym1__ <= nZ; ++sym1__) { + current_statement__ = 446; + current_statement__ = 446; + check_greater_or_equal(function__, "row_indx[sym1__]", + row_indx[(sym1__ - 1)], 0);} + current_statement__ = 447; + validate_non_negative_index("col_indx", "nZ", nZ); + current_statement__ = 448; + context__.validate_dims("data initialization","col_indx","int", + context__.to_vec(nZ)); + col_indx = std::vector(nZ, std::numeric_limits::min()); + + current_statement__ = 448; + assign(col_indx, nil_index_list(), context__.vals_i("col_indx"), + "assigning variable col_indx"); + current_statement__ = 448; + for (int sym1__ = 1; sym1__ <= nZ; ++sym1__) { + current_statement__ = 448; + current_statement__ = 448; + check_greater_or_equal(function__, "col_indx[sym1__]", + col_indx[(sym1__ - 1)], 0);} + current_statement__ = 449; + context__.validate_dims("data initialization","nVariances","int", + context__.to_vec()); + nVariances = std::numeric_limits::min(); + + current_statement__ = 449; + nVariances = context__.vals_i("nVariances")[(1 - 1)]; + current_statement__ = 449; + current_statement__ = 449; + check_greater_or_equal(function__, "nVariances", nVariances, 0); + current_statement__ = 450; + validate_non_negative_index("varIndx", "P", P); + current_statement__ = 451; + context__.validate_dims("data initialization","varIndx","int", + context__.to_vec(P)); + varIndx = std::vector(P, std::numeric_limits::min()); + + current_statement__ = 451; + assign(varIndx, nil_index_list(), context__.vals_i("varIndx"), + "assigning variable varIndx"); + current_statement__ = 451; + for (int sym1__ = 1; sym1__ <= P; ++sym1__) { + current_statement__ = 451; + current_statement__ = 451; + check_greater_or_equal(function__, "varIndx[sym1__]", + varIndx[(sym1__ - 1)], 0);} + current_statement__ = 452; + context__.validate_dims("data initialization","nZero","int", + context__.to_vec()); + nZero = std::numeric_limits::min(); + + current_statement__ = 452; + nZero = context__.vals_i("nZero")[(1 - 1)]; + current_statement__ = 452; + current_statement__ = 452; + check_greater_or_equal(function__, "nZero", nZero, 0); + current_statement__ = 453; + validate_non_negative_index("row_indx_z", "nZero", nZero); + current_statement__ = 454; + context__.validate_dims("data initialization","row_indx_z","int", + context__.to_vec(nZero)); + row_indx_z = std::vector(nZero, std::numeric_limits::min()); + + current_statement__ = 454; + assign(row_indx_z, nil_index_list(), context__.vals_i("row_indx_z"), + "assigning variable row_indx_z"); + current_statement__ = 454; + for (int sym1__ = 1; sym1__ <= nZero; ++sym1__) { + current_statement__ = 454; + current_statement__ = 454; + check_greater_or_equal(function__, "row_indx_z[sym1__]", + row_indx_z[(sym1__ - 1)], 0);} + current_statement__ = 455; + validate_non_negative_index("col_indx_z", "nZero", nZero); + current_statement__ = 456; + context__.validate_dims("data initialization","col_indx_z","int", + context__.to_vec(nZero)); + col_indx_z = std::vector(nZero, std::numeric_limits::min()); + + current_statement__ = 456; + assign(col_indx_z, nil_index_list(), context__.vals_i("col_indx_z"), + "assigning variable col_indx_z"); + current_statement__ = 456; + for (int sym1__ = 1; sym1__ <= nZero; ++sym1__) { + current_statement__ = 456; + current_statement__ = 456; + check_greater_or_equal(function__, "col_indx_z[sym1__]", + col_indx_z[(sym1__ - 1)], 0);} + current_statement__ = 457; + context__.validate_dims("data initialization","n_pos","int", + context__.to_vec()); + n_pos = std::numeric_limits::min(); + + current_statement__ = 457; + n_pos = context__.vals_i("n_pos")[(1 - 1)]; + current_statement__ = 457; + current_statement__ = 457; + check_greater_or_equal(function__, "n_pos", n_pos, 0); + current_statement__ = 458; + validate_non_negative_index("row_indx_pos", "n_pos", n_pos); + current_statement__ = 459; + context__.validate_dims("data initialization","row_indx_pos","int", + context__.to_vec(n_pos)); + row_indx_pos = std::vector(n_pos, std::numeric_limits::min()); + + current_statement__ = 459; + assign(row_indx_pos, nil_index_list(), + context__.vals_i("row_indx_pos"), "assigning variable row_indx_pos"); + current_statement__ = 459; + for (int sym1__ = 1; sym1__ <= n_pos; ++sym1__) { + current_statement__ = 459; + current_statement__ = 459; + check_greater_or_equal(function__, "row_indx_pos[sym1__]", + row_indx_pos[(sym1__ - 1)], 0);} + current_statement__ = 460; + validate_non_negative_index("col_indx_pos", "n_pos", n_pos); + current_statement__ = 461; + context__.validate_dims("data initialization","col_indx_pos","int", + context__.to_vec(n_pos)); + col_indx_pos = std::vector(n_pos, std::numeric_limits::min()); + + current_statement__ = 461; + assign(col_indx_pos, nil_index_list(), + context__.vals_i("col_indx_pos"), "assigning variable col_indx_pos"); + current_statement__ = 461; + for (int sym1__ = 1; sym1__ <= n_pos; ++sym1__) { + current_statement__ = 461; + current_statement__ = 461; + check_greater_or_equal(function__, "col_indx_pos[sym1__]", + col_indx_pos[(sym1__ - 1)], 0);} + current_statement__ = 462; + validate_non_negative_index("y", "n_pos", n_pos); + current_statement__ = 463; + context__.validate_dims("data initialization","y","double", + context__.to_vec(n_pos)); + y = std::vector(n_pos, std::numeric_limits::quiet_NaN()); + + current_statement__ = 463; + assign(y, nil_index_list(), context__.vals_r("y"), + "assigning variable y"); + current_statement__ = 464; + validate_non_negative_index("y_int", "n_pos", n_pos); + current_statement__ = 465; + context__.validate_dims("data initialization","y_int","int", + context__.to_vec(n_pos)); + y_int = std::vector(n_pos, std::numeric_limits::min()); + + current_statement__ = 465; + assign(y_int, nil_index_list(), context__.vals_i("y_int"), + "assigning variable y_int"); + current_statement__ = 465; + for (int sym1__ = 1; sym1__ <= n_pos; ++sym1__) { + current_statement__ = 465; + current_statement__ = 465; + check_greater_or_equal(function__, "y_int[sym1__]", + y_int[(sym1__ - 1)], 0);} + current_statement__ = 466; + validate_non_negative_index("offset", "n_pos", n_pos); + current_statement__ = 467; + context__.validate_dims("data initialization","offset","double", + context__.to_vec(n_pos)); + offset = std::vector(n_pos, std::numeric_limits::quiet_NaN()); + + current_statement__ = 467; + assign(offset, nil_index_list(), context__.vals_r("offset"), + "assigning variable offset"); + current_statement__ = 468; + context__.validate_dims("data initialization","n_na","int", + context__.to_vec()); + n_na = std::numeric_limits::min(); + + current_statement__ = 468; + n_na = context__.vals_i("n_na")[(1 - 1)]; + current_statement__ = 468; + current_statement__ = 468; + check_greater_or_equal(function__, "n_na", n_na, 0); + current_statement__ = 469; + validate_non_negative_index("row_indx_na", "n_na", n_na); + current_statement__ = 470; + context__.validate_dims("data initialization","row_indx_na","int", + context__.to_vec(n_na)); + row_indx_na = std::vector(n_na, std::numeric_limits::min()); + + current_statement__ = 470; + assign(row_indx_na, nil_index_list(), context__.vals_i("row_indx_na"), + "assigning variable row_indx_na"); + current_statement__ = 470; + for (int sym1__ = 1; sym1__ <= n_na; ++sym1__) { + current_statement__ = 470; + current_statement__ = 470; + check_greater_or_equal(function__, "row_indx_na[sym1__]", + row_indx_na[(sym1__ - 1)], 0);} + current_statement__ = 471; + validate_non_negative_index("col_indx_na", "n_na", n_na); + current_statement__ = 472; + context__.validate_dims("data initialization","col_indx_na","int", + context__.to_vec(n_na)); + col_indx_na = std::vector(n_na, std::numeric_limits::min()); + + current_statement__ = 472; + assign(col_indx_na, nil_index_list(), context__.vals_i("col_indx_na"), + "assigning variable col_indx_na"); + current_statement__ = 472; + for (int sym1__ = 1; sym1__ <= n_na; ++sym1__) { + current_statement__ = 472; + current_statement__ = 472; + check_greater_or_equal(function__, "col_indx_na[sym1__]", + col_indx_na[(sym1__ - 1)], 0);} + current_statement__ = 473; + context__.validate_dims("data initialization","nu_fixed","double", + context__.to_vec()); + nu_fixed = std::numeric_limits::quiet_NaN(); + + current_statement__ = 473; + nu_fixed = context__.vals_r("nu_fixed")[(1 - 1)]; + current_statement__ = 473; + current_statement__ = 473; + check_greater_or_equal(function__, "nu_fixed", nu_fixed, 1); + current_statement__ = 474; + context__.validate_dims("data initialization","estimate_nu","int", + context__.to_vec()); + estimate_nu = std::numeric_limits::min(); + + current_statement__ = 474; + estimate_nu = context__.vals_i("estimate_nu")[(1 - 1)]; + current_statement__ = 475; + context__.validate_dims("data initialization","use_normal","int", + context__.to_vec()); + use_normal = std::numeric_limits::min(); + + current_statement__ = 475; + use_normal = context__.vals_i("use_normal")[(1 - 1)]; + current_statement__ = 476; + context__.validate_dims("data initialization","est_cor","int", + context__.to_vec()); + est_cor = std::numeric_limits::min(); + + current_statement__ = 476; + est_cor = context__.vals_i("est_cor")[(1 - 1)]; + current_statement__ = 477; + context__.validate_dims("data initialization","est_phi","int", + context__.to_vec()); + est_phi = std::numeric_limits::min(); + + current_statement__ = 477; + est_phi = context__.vals_i("est_phi")[(1 - 1)]; + current_statement__ = 478; + context__.validate_dims("data initialization","est_theta","int", + context__.to_vec()); + est_theta = std::numeric_limits::min(); + + current_statement__ = 478; + est_theta = context__.vals_i("est_theta")[(1 - 1)]; + current_statement__ = 479; + context__.validate_dims("data initialization","num_obs_covar","int", + context__.to_vec()); + num_obs_covar = std::numeric_limits::min(); + + current_statement__ = 479; + num_obs_covar = context__.vals_i("num_obs_covar")[(1 - 1)]; + current_statement__ = 479; + current_statement__ = 479; + check_greater_or_equal(function__, "num_obs_covar", num_obs_covar, 0); + current_statement__ = 480; + context__.validate_dims("data initialization","n_obs_covar","int", + context__.to_vec()); + n_obs_covar = std::numeric_limits::min(); + + current_statement__ = 480; + n_obs_covar = context__.vals_i("n_obs_covar")[(1 - 1)]; + current_statement__ = 480; + current_statement__ = 480; + check_greater_or_equal(function__, "n_obs_covar", n_obs_covar, 0); + current_statement__ = 481; + validate_non_negative_index("obs_covar_index", "num_obs_covar", + num_obs_covar); + current_statement__ = 482; + context__.validate_dims("data initialization","obs_covar_index","int", + context__.to_vec(num_obs_covar, 3)); + obs_covar_index = std::vector>(num_obs_covar, std::vector(3, std::numeric_limits::min())); + + { + std::vector obs_covar_index_flat__; + current_statement__ = 482; + assign(obs_covar_index_flat__, nil_index_list(), + context__.vals_i("obs_covar_index"), + "assigning variable obs_covar_index_flat__"); + current_statement__ = 482; + pos__ = 1; + current_statement__ = 482; + for (int sym1__ = 1; sym1__ <= 3; ++sym1__) { + current_statement__ = 482; + for (int sym2__ = 1; sym2__ <= num_obs_covar; ++sym2__) { + current_statement__ = 482; + assign(obs_covar_index, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + obs_covar_index_flat__[(pos__ - 1)], + "assigning variable obs_covar_index"); + current_statement__ = 482; + pos__ = (pos__ + 1);}} + } + current_statement__ = 483; + validate_non_negative_index("obs_covar_value", "num_obs_covar", + num_obs_covar); + current_statement__ = 484; + context__.validate_dims("data initialization","obs_covar_value", + "double",context__.to_vec(num_obs_covar)); + obs_covar_value = std::vector(num_obs_covar, std::numeric_limits::quiet_NaN()); + + current_statement__ = 484; + assign(obs_covar_value, nil_index_list(), + context__.vals_r("obs_covar_value"), + "assigning variable obs_covar_value"); + current_statement__ = 485; + validate_non_negative_index("match_obs_covar", "num_obs_covar", + num_obs_covar); + current_statement__ = 486; + context__.validate_dims("data initialization","match_obs_covar","int", + context__.to_vec(num_obs_covar)); + match_obs_covar = std::vector(num_obs_covar, std::numeric_limits::min()); + + current_statement__ = 486; + assign(match_obs_covar, nil_index_list(), + context__.vals_i("match_obs_covar"), + "assigning variable match_obs_covar"); + current_statement__ = 487; + context__.validate_dims("data initialization","num_pro_covar","int", + context__.to_vec()); + num_pro_covar = std::numeric_limits::min(); + + current_statement__ = 487; + num_pro_covar = context__.vals_i("num_pro_covar")[(1 - 1)]; + current_statement__ = 487; + current_statement__ = 487; + check_greater_or_equal(function__, "num_pro_covar", num_pro_covar, 0); + current_statement__ = 488; + context__.validate_dims("data initialization","n_pro_covar","int", + context__.to_vec()); + n_pro_covar = std::numeric_limits::min(); + + current_statement__ = 488; + n_pro_covar = context__.vals_i("n_pro_covar")[(1 - 1)]; + current_statement__ = 488; + current_statement__ = 488; + check_greater_or_equal(function__, "n_pro_covar", n_pro_covar, 0); + current_statement__ = 489; + validate_non_negative_index("pro_covar_index", "num_pro_covar", + num_pro_covar); + current_statement__ = 490; + context__.validate_dims("data initialization","pro_covar_index","int", + context__.to_vec(num_pro_covar, 3)); + pro_covar_index = std::vector>(num_pro_covar, std::vector(3, std::numeric_limits::min())); + + { + std::vector pro_covar_index_flat__; + current_statement__ = 490; + assign(pro_covar_index_flat__, nil_index_list(), + context__.vals_i("pro_covar_index"), + "assigning variable pro_covar_index_flat__"); + current_statement__ = 490; + pos__ = 1; + current_statement__ = 490; + for (int sym1__ = 1; sym1__ <= 3; ++sym1__) { + current_statement__ = 490; + for (int sym2__ = 1; sym2__ <= num_pro_covar; ++sym2__) { + current_statement__ = 490; + assign(pro_covar_index, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + pro_covar_index_flat__[(pos__ - 1)], + "assigning variable pro_covar_index"); + current_statement__ = 490; + pos__ = (pos__ + 1);}} + } + current_statement__ = 491; + validate_non_negative_index("pro_covar_value", "num_pro_covar", + num_pro_covar); + current_statement__ = 492; + context__.validate_dims("data initialization","pro_covar_value", + "double",context__.to_vec(num_pro_covar)); + pro_covar_value = std::vector(num_pro_covar, std::numeric_limits::quiet_NaN()); + + current_statement__ = 492; + assign(pro_covar_value, nil_index_list(), + context__.vals_r("pro_covar_value"), + "assigning variable pro_covar_value"); + current_statement__ = 493; + context__.validate_dims("data initialization","z_bound","double", + context__.to_vec(2)); + z_bound = std::vector(2, std::numeric_limits::quiet_NaN()); + + current_statement__ = 493; + assign(z_bound, nil_index_list(), context__.vals_r("z_bound"), + "assigning variable z_bound"); + current_statement__ = 494; + context__.validate_dims("data initialization","long_format","int", + context__.to_vec()); + long_format = std::numeric_limits::min(); + + current_statement__ = 494; + long_format = context__.vals_i("long_format")[(1 - 1)]; + current_statement__ = 494; + current_statement__ = 494; + check_greater_or_equal(function__, "long_format", long_format, 0); + current_statement__ = 495; + context__.validate_dims("data initialization","proportional_model", + "int",context__.to_vec()); + proportional_model = std::numeric_limits::min(); + + current_statement__ = 495; + proportional_model = context__.vals_i("proportional_model")[(1 - 1)]; + current_statement__ = 495; + current_statement__ = 495; + check_greater_or_equal(function__, "proportional_model", + proportional_model, 0); + current_statement__ = 496; + context__.validate_dims("data initialization","est_sigma_process", + "int",context__.to_vec()); + est_sigma_process = std::numeric_limits::min(); + + current_statement__ = 496; + est_sigma_process = context__.vals_i("est_sigma_process")[(1 - 1)]; + current_statement__ = 496; + current_statement__ = 496; + check_greater_or_equal(function__, "est_sigma_process", + est_sigma_process, 0); + current_statement__ = 497; + context__.validate_dims("data initialization","n_sigma_process","int", + context__.to_vec()); + n_sigma_process = std::numeric_limits::min(); + + current_statement__ = 497; + n_sigma_process = context__.vals_i("n_sigma_process")[(1 - 1)]; + current_statement__ = 497; + current_statement__ = 497; + check_greater_or_equal(function__, "n_sigma_process", n_sigma_process, + 0); + current_statement__ = 498; + context__.validate_dims("data initialization","est_rw","int", + context__.to_vec()); + est_rw = std::numeric_limits::min(); + + current_statement__ = 498; + est_rw = context__.vals_i("est_rw")[(1 - 1)]; + current_statement__ = 498; + current_statement__ = 498; + check_greater_or_equal(function__, "est_rw", est_rw, 0); + current_statement__ = 499; + context__.validate_dims("data initialization","est_spline","int", + context__.to_vec()); + est_spline = std::numeric_limits::min(); + + current_statement__ = 499; + est_spline = context__.vals_i("est_spline")[(1 - 1)]; + current_statement__ = 499; + current_statement__ = 499; + check_greater_or_equal(function__, "est_spline", est_spline, 0); + current_statement__ = 500; + context__.validate_dims("data initialization","est_gp","int", + context__.to_vec()); + est_gp = std::numeric_limits::min(); + + current_statement__ = 500; + est_gp = context__.vals_i("est_gp")[(1 - 1)]; + current_statement__ = 500; + current_statement__ = 500; + check_greater_or_equal(function__, "est_gp", est_gp, 0); + current_statement__ = 501; + context__.validate_dims("data initialization","n_knots","int", + context__.to_vec()); + n_knots = std::numeric_limits::min(); + + current_statement__ = 501; + n_knots = context__.vals_i("n_knots")[(1 - 1)]; + current_statement__ = 501; + current_statement__ = 501; + check_greater_or_equal(function__, "n_knots", n_knots, 0); + current_statement__ = 502; + validate_non_negative_index("X_spline", "N", N); + current_statement__ = 503; + validate_non_negative_index("X_spline", "n_knots", n_knots); + current_statement__ = 504; + context__.validate_dims("data initialization","X_spline","double", + context__.to_vec(N, n_knots)); + X_spline = Eigen::Matrix(N, n_knots); + stan::math::fill(X_spline, std::numeric_limits::quiet_NaN()); + + { + std::vector X_spline_flat__; + current_statement__ = 504; + assign(X_spline_flat__, nil_index_list(), + context__.vals_r("X_spline"), "assigning variable X_spline_flat__"); + current_statement__ = 504; + pos__ = 1; + current_statement__ = 504; + for (int sym1__ = 1; sym1__ <= n_knots; ++sym1__) { + current_statement__ = 504; + for (int sym2__ = 1; sym2__ <= N; ++sym2__) { + current_statement__ = 504; + assign(X_spline, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + X_spline_flat__[(pos__ - 1)], "assigning variable X_spline"); + current_statement__ = 504; + pos__ = (pos__ + 1);}} + } + current_statement__ = 505; + validate_non_negative_index("knot_locs", "n_knots", n_knots); + current_statement__ = 506; + context__.validate_dims("data initialization","knot_locs","double", + context__.to_vec(n_knots)); + knot_locs = std::vector(n_knots, std::numeric_limits::quiet_NaN()); + + current_statement__ = 506; + assign(knot_locs, nil_index_list(), context__.vals_r("knot_locs"), + "assigning variable knot_locs"); + current_statement__ = 507; + validate_non_negative_index("distKnots21_pred", "n_knots", n_knots); + current_statement__ = 508; + context__.validate_dims("data initialization","distKnots21_pred", + "double",context__.to_vec(1, n_knots)); + distKnots21_pred = Eigen::Matrix(1, n_knots); + stan::math::fill(distKnots21_pred, std::numeric_limits::quiet_NaN()); + + { + std::vector distKnots21_pred_flat__; + current_statement__ = 508; + assign(distKnots21_pred_flat__, nil_index_list(), + context__.vals_r("distKnots21_pred"), + "assigning variable distKnots21_pred_flat__"); + current_statement__ = 508; + pos__ = 1; + current_statement__ = 508; + for (int sym1__ = 1; sym1__ <= n_knots; ++sym1__) { + current_statement__ = 508; + for (int sym2__ = 1; sym2__ <= 1; ++sym2__) { + current_statement__ = 508; + assign(distKnots21_pred, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + distKnots21_pred_flat__[(pos__ - 1)], + "assigning variable distKnots21_pred"); + current_statement__ = 508; + pos__ = (pos__ + 1);}} + } + current_statement__ = 509; + context__.validate_dims("data initialization","obs_model","int", + context__.to_vec()); + obs_model = std::numeric_limits::min(); + + current_statement__ = 509; + obs_model = context__.vals_i("obs_model")[(1 - 1)]; + current_statement__ = 510; + context__.validate_dims("data initialization","est_sigma_params","int", + context__.to_vec()); + est_sigma_params = std::numeric_limits::min(); + + current_statement__ = 510; + est_sigma_params = context__.vals_i("est_sigma_params")[(1 - 1)]; + current_statement__ = 510; + current_statement__ = 510; + check_greater_or_equal(function__, "est_sigma_params", + est_sigma_params, 0); + current_statement__ = 510; + current_statement__ = 510; + check_less_or_equal(function__, "est_sigma_params", est_sigma_params, 1); + current_statement__ = 511; + context__.validate_dims("data initialization","est_gamma_params","int", + context__.to_vec()); + est_gamma_params = std::numeric_limits::min(); + + current_statement__ = 511; + est_gamma_params = context__.vals_i("est_gamma_params")[(1 - 1)]; + current_statement__ = 511; + current_statement__ = 511; + check_greater_or_equal(function__, "est_gamma_params", + est_gamma_params, 0); + current_statement__ = 511; + current_statement__ = 511; + check_less_or_equal(function__, "est_gamma_params", est_gamma_params, 1); + current_statement__ = 512; + context__.validate_dims("data initialization","est_nb2_params","int", + context__.to_vec()); + est_nb2_params = std::numeric_limits::min(); + + current_statement__ = 512; + est_nb2_params = context__.vals_i("est_nb2_params")[(1 - 1)]; + current_statement__ = 512; + current_statement__ = 512; + check_greater_or_equal(function__, "est_nb2_params", est_nb2_params, 0); + current_statement__ = 512; + current_statement__ = 512; + check_less_or_equal(function__, "est_nb2_params", est_nb2_params, 1); + current_statement__ = 513; + context__.validate_dims("data initialization","use_expansion_prior", + "int",context__.to_vec()); + use_expansion_prior = std::numeric_limits::min(); + + current_statement__ = 513; + use_expansion_prior = context__.vals_i("use_expansion_prior")[(1 - 1)]; + current_statement__ = 513; + current_statement__ = 513; + check_greater_or_equal(function__, "use_expansion_prior", + use_expansion_prior, 0); + current_statement__ = 513; + current_statement__ = 513; + check_less_or_equal(function__, "use_expansion_prior", + use_expansion_prior, 1); + current_statement__ = 514; + context__.validate_dims("data initialization","gp_theta_prior", + "double",context__.to_vec(2)); + gp_theta_prior = std::vector(2, std::numeric_limits::quiet_NaN()); + + current_statement__ = 514; + assign(gp_theta_prior, nil_index_list(), + context__.vals_r("gp_theta_prior"), + "assigning variable gp_theta_prior"); + current_statement__ = 515; + validate_non_negative_index("weights_vec", "n_pos", n_pos); + current_statement__ = 516; + context__.validate_dims("data initialization","weights_vec","double", + context__.to_vec(n_pos)); + weights_vec = std::vector(n_pos, std::numeric_limits::quiet_NaN()); + + current_statement__ = 516; + assign(weights_vec, nil_index_list(), context__.vals_r("weights_vec"), + "assigning variable weights_vec"); + current_statement__ = 517; + n_pcor = std::numeric_limits::min(); + + current_statement__ = 518; + n_loglik = std::numeric_limits::min(); + + current_statement__ = 519; + validate_non_negative_index("zeros", "K", K); + current_statement__ = 520; + zeros = Eigen::Matrix(K); + stan::math::fill(zeros, std::numeric_limits::quiet_NaN()); + + current_statement__ = 521; + validate_non_negative_index("data_locs", "N", N); + current_statement__ = 522; + data_locs = std::vector(N, std::numeric_limits::quiet_NaN()); + + current_statement__ = 523; + validate_non_negative_index("log_weights_vec", "n_pos", n_pos); + current_statement__ = 524; + log_weights_vec = std::vector(n_pos, std::numeric_limits::quiet_NaN()); + + current_statement__ = 525; + validate_non_negative_index("alpha_vec", "K * proportional_model", + (K * proportional_model)); + current_statement__ = 526; + alpha_vec = Eigen::Matrix((K * proportional_model)); + stan::math::fill(alpha_vec, std::numeric_limits::quiet_NaN()); + + current_statement__ = 527; + validate_non_negative_index("muZeros", "n_knots", n_knots); + current_statement__ = 528; + muZeros = Eigen::Matrix(n_knots); + stan::math::fill(muZeros, std::numeric_limits::quiet_NaN()); + + current_statement__ = 529; + gp_delta = std::numeric_limits::quiet_NaN(); + + current_statement__ = 529; + gp_delta = 1e-9; + current_statement__ = 530; + lower_bound_z = std::numeric_limits::quiet_NaN(); + + current_statement__ = 533; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 531; + assign(log_weights_vec, cons_list(index_uni(i), nil_index_list()), + stan::math::log(weights_vec[(i - 1)]), + "assigning variable log_weights_vec");} + current_statement__ = 536; + for (int i = 1; i <= N; ++i) { + current_statement__ = 534; + assign(data_locs, cons_list(index_uni(i), nil_index_list()), i, + "assigning variable data_locs");} + current_statement__ = 539; + for (int k = 1; k <= K; ++k) { + current_statement__ = 537; + assign(zeros, cons_list(index_uni(k), nil_index_list()), 0, + "assigning variable zeros");} + current_statement__ = 542; + for (int k = 1; k <= n_knots; ++k) { + current_statement__ = 540; + assign(muZeros, cons_list(index_uni(k), nil_index_list()), 0, + "assigning variable muZeros");} + current_statement__ = 543; + n_loglik = n_pos; + current_statement__ = 550; + if (logical_eq(long_format, 0)) { + current_statement__ = 548; + if (logical_eq(est_cor, 0)) { + current_statement__ = 546; + n_loglik = (P * N); + } else { + current_statement__ = 544; + n_loglik = N; + } + } + current_statement__ = 558; + if (logical_eq(est_cor, 0)) { + current_statement__ = 553; + n_pcor = P; + current_statement__ = 556; + if (logical_lt(nVariances, 2)) { + current_statement__ = 554; + n_pcor = 2; + } + } else { + current_statement__ = 551; + n_pcor = P; + } + current_statement__ = 562; + if (logical_eq(proportional_model, 1)) { + current_statement__ = 560; + for (int k = 1; k <= K; ++k) { + current_statement__ = 559; + assign(alpha_vec, cons_list(index_uni(k), nil_index_list()), 1, + "assigning variable alpha_vec");} + } + current_statement__ = 563; + lower_bound_z = -100; + current_statement__ = 565; + if (logical_eq(use_expansion_prior, 1)) { + current_statement__ = 564; + lower_bound_z = 0; + } + current_statement__ = 566; + devs_1dim__ = std::numeric_limits::min(); + + current_statement__ = 566; + devs_1dim__ = (K * est_rw); + current_statement__ = 566; + validate_non_negative_index("devs", "K * est_rw", devs_1dim__); + current_statement__ = 567; + devs_2dim__ = std::numeric_limits::min(); + + current_statement__ = 567; + devs_2dim__ = ((N - 1) * est_rw); + current_statement__ = 567; + validate_non_negative_index("devs", "(N - 1) * est_rw", devs_2dim__); + current_statement__ = 568; + validate_non_negative_index("x0", "K", K); + current_statement__ = 569; + psi_1dim__ = std::numeric_limits::min(); + + current_statement__ = 569; + psi_1dim__ = ((K * (1 - proportional_model)) * use_expansion_prior); + current_statement__ = 569; + validate_non_negative_index("psi", + "K * (1 - proportional_model) * use_expansion_prior", + psi_1dim__); + current_statement__ = 570; + z_1dim__ = std::numeric_limits::min(); + + current_statement__ = 570; + z_1dim__ = (nZ * (1 - proportional_model)); + current_statement__ = 570; + validate_non_negative_index("z", "nZ * (1 - proportional_model)", + z_1dim__); + current_statement__ = 571; + zpos_1dim__ = std::numeric_limits::min(); + + current_statement__ = 571; + zpos_1dim__ = (K * (1 - proportional_model)); + current_statement__ = 571; + validate_non_negative_index("zpos", "K * (1 - proportional_model)", + zpos_1dim__); + current_statement__ = 572; + p_z_1dim__ = std::numeric_limits::min(); + + current_statement__ = 572; + p_z_1dim__ = (P * proportional_model); + current_statement__ = 572; + validate_non_negative_index("p_z", "P * proportional_model", p_z_1dim__); + current_statement__ = 573; + validate_positive_index("p_z", "K", K); + current_statement__ = 574; + spline_a_1dim__ = std::numeric_limits::min(); + + current_statement__ = 574; + spline_a_1dim__ = (K * est_spline); + current_statement__ = 574; + validate_non_negative_index("spline_a", "K * est_spline", + spline_a_1dim__); + current_statement__ = 575; + spline_a_2dim__ = std::numeric_limits::min(); + + current_statement__ = 575; + spline_a_2dim__ = (n_knots * est_spline); + current_statement__ = 575; + validate_non_negative_index("spline_a", "n_knots * est_spline", + spline_a_2dim__); + current_statement__ = 576; + validate_non_negative_index("b_obs", "n_obs_covar", n_obs_covar); + current_statement__ = 577; + validate_non_negative_index("b_obs", "P", P); + current_statement__ = 578; + validate_non_negative_index("b_pro", "n_pro_covar", n_pro_covar); + current_statement__ = 579; + validate_non_negative_index("b_pro", "K", K); + current_statement__ = 580; + sigma_1dim__ = std::numeric_limits::min(); + + current_statement__ = 580; + sigma_1dim__ = (nVariances * est_sigma_params); + current_statement__ = 580; + validate_non_negative_index("sigma", "nVariances * est_sigma_params", + sigma_1dim__); + current_statement__ = 581; + gamma_a_1dim__ = std::numeric_limits::min(); + + current_statement__ = 581; + gamma_a_1dim__ = (nVariances * est_gamma_params); + current_statement__ = 581; + validate_non_negative_index("gamma_a", "nVariances * est_gamma_params", + gamma_a_1dim__); + current_statement__ = 582; + nb2_phi_1dim__ = std::numeric_limits::min(); + + current_statement__ = 582; + nb2_phi_1dim__ = (nVariances * est_nb2_params); + current_statement__ = 582; + validate_non_negative_index("nb2_phi", "nVariances * est_nb2_params", + nb2_phi_1dim__); + current_statement__ = 583; + validate_non_negative_index("nu", "estimate_nu", estimate_nu); + current_statement__ = 584; + validate_non_negative_index("ymiss", "n_na", n_na); + current_statement__ = 585; + phi_1dim__ = std::numeric_limits::min(); + + current_statement__ = 585; + phi_1dim__ = (est_phi * K); + current_statement__ = 585; + validate_non_negative_index("phi", "est_phi * K", phi_1dim__); + current_statement__ = 586; + theta_1dim__ = std::numeric_limits::min(); + + current_statement__ = 586; + theta_1dim__ = (est_theta * K); + current_statement__ = 586; + validate_non_negative_index("theta", "est_theta * K", theta_1dim__); + current_statement__ = 587; + gp_theta_1dim__ = std::numeric_limits::min(); + + current_statement__ = 587; + gp_theta_1dim__ = (est_gp * K); + current_statement__ = 587; + validate_non_negative_index("gp_theta", "est_gp * K", gp_theta_1dim__); + current_statement__ = 588; + validate_non_negative_index("Lcorr", "n_pcor", n_pcor); + current_statement__ = 588; + validate_non_negative_index("Lcorr", "n_pcor", n_pcor); + current_statement__ = 589; + sigma_process_1dim__ = std::numeric_limits::min(); + + current_statement__ = 589; + sigma_process_1dim__ = (est_sigma_process * n_sigma_process); + current_statement__ = 589; + validate_non_negative_index("sigma_process", + "est_sigma_process * n_sigma_process", + sigma_process_1dim__); + current_statement__ = 590; + effectsKnots_1dim__ = std::numeric_limits::min(); + + current_statement__ = 590; + effectsKnots_1dim__ = (K * est_gp); + current_statement__ = 590; + validate_non_negative_index("effectsKnots", "K * est_gp", + effectsKnots_1dim__); + current_statement__ = 591; + effectsKnots_2dim__ = std::numeric_limits::min(); + + current_statement__ = 591; + effectsKnots_2dim__ = (n_knots * est_gp); + current_statement__ = 591; + validate_non_negative_index("effectsKnots", "n_knots * est_gp", + effectsKnots_2dim__); + current_statement__ = 592; + validate_non_negative_index("pred", "P", P); + current_statement__ = 593; + validate_non_negative_index("pred", "N", N); + current_statement__ = 594; + validate_non_negative_index("Z", "P", P); + current_statement__ = 595; + validate_non_negative_index("Z", "K", K); + current_statement__ = 596; + validate_non_negative_index("yall", "P", P); + current_statement__ = 597; + validate_non_negative_index("yall", "N", N); + current_statement__ = 598; + sigma_vec_1dim__ = std::numeric_limits::min(); + + current_statement__ = 598; + sigma_vec_1dim__ = (P * est_sigma_params); + current_statement__ = 598; + validate_non_negative_index("sigma_vec", "P * est_sigma_params", + sigma_vec_1dim__); + current_statement__ = 599; + gamma_a_vec_1dim__ = std::numeric_limits::min(); + + current_statement__ = 599; + gamma_a_vec_1dim__ = (P * est_gamma_params); + current_statement__ = 599; + validate_non_negative_index("gamma_a_vec", "P * est_gamma_params", + gamma_a_vec_1dim__); + current_statement__ = 600; + nb_phi_vec_1dim__ = std::numeric_limits::min(); + + current_statement__ = 600; + nb_phi_vec_1dim__ = (P * est_nb2_params); + current_statement__ = 600; + validate_non_negative_index("nb_phi_vec", "P * est_nb2_params", + nb_phi_vec_1dim__); + current_statement__ = 601; + validate_non_negative_index("phi_vec", "K", K); + current_statement__ = 602; + validate_non_negative_index("theta_vec", "K", K); + current_statement__ = 603; + validate_non_negative_index("x", "K", K); + current_statement__ = 604; + validate_non_negative_index("x", "N", N); + current_statement__ = 605; + validate_non_negative_index("indicator", "K", K); + current_statement__ = 606; + psi_root_1dim__ = std::numeric_limits::min(); + + current_statement__ = 606; + psi_root_1dim__ = (K * use_expansion_prior); + current_statement__ = 606; + validate_non_negative_index("psi_root", "K * use_expansion_prior", + psi_root_1dim__); + current_statement__ = 607; + Sigma_derived_1dim__ = std::numeric_limits::min(); + + current_statement__ = 607; + Sigma_derived_1dim__ = ((n_pcor * long_format) * est_cor); + current_statement__ = 607; + validate_non_negative_index("Sigma_derived", + "n_pcor * long_format * est_cor", + Sigma_derived_1dim__); + current_statement__ = 608; + Sigma_derived_2dim__ = std::numeric_limits::min(); + + current_statement__ = 608; + Sigma_derived_2dim__ = ((n_pcor * long_format) * est_cor); + current_statement__ = 608; + validate_non_negative_index("Sigma_derived", + "n_pcor * long_format * est_cor", + Sigma_derived_2dim__); + current_statement__ = 609; + Sigma_temp_1dim__ = std::numeric_limits::min(); + + current_statement__ = 609; + Sigma_temp_1dim__ = (((n_pcor - 1) * long_format) * est_cor); + current_statement__ = 609; + validate_non_negative_index("Sigma_temp", + "(n_pcor - 1) * long_format * est_cor", + Sigma_temp_1dim__); + current_statement__ = 610; + Sigma_temp_2dim__ = std::numeric_limits::min(); + + current_statement__ = 610; + Sigma_temp_2dim__ = (((n_pcor - 1) * long_format) * est_cor); + current_statement__ = 610; + validate_non_negative_index("Sigma_temp", + "(n_pcor - 1) * long_format * est_cor", + Sigma_temp_2dim__); + current_statement__ = 611; + sigma12_vec_1dim__ = std::numeric_limits::min(); + + current_statement__ = 611; + sigma12_vec_1dim__ = (n_pcor - 1); + current_statement__ = 611; + validate_non_negative_index("sigma12_vec", "n_pcor - 1", + sigma12_vec_1dim__); + current_statement__ = 612; + validate_non_negative_index("sigma12_vec", "1", 1); + current_statement__ = 613; + temp_sums_1dim__ = std::numeric_limits::min(); + + current_statement__ = 613; + temp_sums_1dim__ = ((P * long_format) * est_cor); + current_statement__ = 613; + validate_non_negative_index("temp_sums", "P * long_format * est_cor", + temp_sums_1dim__); + current_statement__ = 614; + temp_sums_2dim__ = std::numeric_limits::min(); + + current_statement__ = 614; + temp_sums_2dim__ = ((N * long_format) * est_cor); + current_statement__ = 614; + validate_non_negative_index("temp_sums", "N * long_format * est_cor", + temp_sums_2dim__); + current_statement__ = 615; + temp_counts_1dim__ = std::numeric_limits::min(); + + current_statement__ = 615; + temp_counts_1dim__ = ((P * long_format) * est_cor); + current_statement__ = 615; + validate_non_negative_index("temp_counts", "P * long_format * est_cor", + temp_counts_1dim__); + current_statement__ = 616; + temp_counts_2dim__ = std::numeric_limits::min(); + + current_statement__ = 616; + temp_counts_2dim__ = ((N * long_format) * est_cor); + current_statement__ = 616; + validate_non_negative_index("temp_counts", "N * long_format * est_cor", + temp_counts_2dim__); + current_statement__ = 617; + cond_sigma_vec_1dim__ = std::numeric_limits::min(); + + current_statement__ = 617; + cond_sigma_vec_1dim__ = ((P * long_format) * est_cor); + current_statement__ = 617; + validate_non_negative_index("cond_sigma_vec", + "P * long_format * est_cor", + cond_sigma_vec_1dim__); + current_statement__ = 618; + cond_mean_vec_1dim__ = std::numeric_limits::min(); + + current_statement__ = 618; + cond_mean_vec_1dim__ = ((P * long_format) * est_cor); + current_statement__ = 618; + validate_non_negative_index("cond_mean_vec", + "P * long_format * est_cor", + cond_mean_vec_1dim__); + current_statement__ = 619; + validate_non_negative_index("sigma_pro", "K", K); + current_statement__ = 620; + spline_a_trans_1dim__ = std::numeric_limits::min(); + + current_statement__ = 620; + spline_a_trans_1dim__ = (K * est_spline); + current_statement__ = 620; + validate_non_negative_index("spline_a_trans", "K * est_spline", + spline_a_trans_1dim__); + current_statement__ = 621; + spline_a_trans_2dim__ = std::numeric_limits::min(); + + current_statement__ = 621; + spline_a_trans_2dim__ = (n_knots * est_spline); + current_statement__ = 621; + validate_non_negative_index("spline_a_trans", "n_knots * est_spline", + spline_a_trans_2dim__); + current_statement__ = 622; + validate_non_negative_index("SigmaKnots", "K", K); + current_statement__ = 623; + validate_non_negative_index("SigmaKnots", "n_knots", n_knots); + current_statement__ = 624; + validate_non_negative_index("SigmaKnots", "n_knots", n_knots); + current_statement__ = 625; + validate_non_negative_index("obs_cov_offset", "n_pos", n_pos); + current_statement__ = 626; + validate_non_negative_index("log_lik", "n_loglik", n_loglik); + current_statement__ = 627; + validate_non_negative_index("Omega", "n_pcor", n_pcor); + current_statement__ = 628; + validate_non_negative_index("Omega", "n_pcor", n_pcor); + current_statement__ = 629; + validate_non_negative_index("Sigma", "n_pcor", n_pcor); + current_statement__ = 630; + validate_non_negative_index("Sigma", "n_pcor", n_pcor); + current_statement__ = 631; + validate_non_negative_index("xstar", "K", K); + current_statement__ = 632; + validate_non_negative_index("xstar", "1", 1); + current_statement__ = 633; + validate_non_negative_index("future_devs", "K", K); + current_statement__ = 634; + validate_non_negative_index("SigmaKnots_pred", "n_knots", n_knots); + current_statement__ = 635; + validate_non_negative_index("SigmaKnots_pred", "n_knots", n_knots); + current_statement__ = 636; + validate_non_negative_index("SigmaOffDiag_pred", "n_knots", n_knots); + } 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 ***"); } - model_dfa(stan::io::var_context& context__, - unsigned int random_seed__, - std::ostream* pstream__ = 0) - : model_base_crtp(0) { - ctor_body(context__, random_seed__, pstream__); + num_params_r__ = 0U; + + try { + num_params_r__ += devs_1dim__ * devs_2dim__; + num_params_r__ += K; + num_params_r__ += psi_1dim__; + num_params_r__ += z_1dim__; + num_params_r__ += zpos_1dim__; + num_params_r__ += p_z_1dim__ * (K - 1); + num_params_r__ += spline_a_1dim__ * spline_a_2dim__; + num_params_r__ += n_obs_covar * P; + num_params_r__ += n_pro_covar * K; + num_params_r__ += sigma_1dim__; + num_params_r__ += gamma_a_1dim__; + num_params_r__ += nb2_phi_1dim__; + num_params_r__ += estimate_nu; + num_params_r__ += n_na; + num_params_r__ += phi_1dim__; + num_params_r__ += theta_1dim__; + num_params_r__ += gp_theta_1dim__; + num_params_r__ += ((n_pcor * (n_pcor - 1)) / 2); + num_params_r__ += sigma_process_1dim__; + num_params_r__ += effectsKnots_1dim__ * effectsKnots_2dim__; + } 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 ***"); } - void ctor_body(stan::io::var_context& context__, - unsigned int random_seed__, - std::ostream* pstream__) { - typedef double local_scalar_t__; - boost::ecuyer1988 base_rng__ = - stan::services::util::create_rng(random_seed__, 0); - (void) base_rng__; // suppress unused var warning - current_statement_begin__ = -1; - static const char* function__ = "model_dfa_namespace::model_dfa"; - (void) function__; // dummy to suppress unused var warning - size_t pos__; - (void) pos__; // dummy to suppress unused var warning - std::vector vals_i__; - std::vector vals_r__; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - (void) DUMMY_VAR__; // suppress unused var warning - try { - // initialize data block variables from context__ - current_statement_begin__ = 68; - context__.validate_dims("data initialization", "N", "int", context__.to_vec()); - N = int(0); - vals_i__ = context__.vals_i("N"); - pos__ = 0; - N = vals_i__[pos__++]; - check_greater_or_equal(function__, "N", N, 0); - current_statement_begin__ = 69; - context__.validate_dims("data initialization", "P", "int", context__.to_vec()); - P = int(0); - vals_i__ = context__.vals_i("P"); - pos__ = 0; - P = vals_i__[pos__++]; - check_greater_or_equal(function__, "P", P, 0); - current_statement_begin__ = 70; - context__.validate_dims("data initialization", "K", "int", context__.to_vec()); - K = int(0); - vals_i__ = context__.vals_i("K"); - pos__ = 0; - K = vals_i__[pos__++]; - check_greater_or_equal(function__, "K", K, 0); - current_statement_begin__ = 71; - context__.validate_dims("data initialization", "nZ", "int", context__.to_vec()); - nZ = int(0); - vals_i__ = context__.vals_i("nZ"); - pos__ = 0; - nZ = vals_i__[pos__++]; - check_greater_or_equal(function__, "nZ", nZ, 0); - current_statement_begin__ = 72; - validate_non_negative_index("row_indx", "nZ", nZ); - context__.validate_dims("data initialization", "row_indx", "int", context__.to_vec(nZ)); - row_indx = std::vector(nZ, int(0)); - vals_i__ = context__.vals_i("row_indx"); - pos__ = 0; - size_t row_indx_k_0_max__ = nZ; - for (size_t k_0__ = 0; k_0__ < row_indx_k_0_max__; ++k_0__) { - row_indx[k_0__] = vals_i__[pos__++]; - } - size_t row_indx_i_0_max__ = nZ; - for (size_t i_0__ = 0; i_0__ < row_indx_i_0_max__; ++i_0__) { - check_greater_or_equal(function__, "row_indx[i_0__]", row_indx[i_0__], 0); - } - current_statement_begin__ = 73; - validate_non_negative_index("col_indx", "nZ", nZ); - context__.validate_dims("data initialization", "col_indx", "int", context__.to_vec(nZ)); - col_indx = std::vector(nZ, int(0)); - vals_i__ = context__.vals_i("col_indx"); - pos__ = 0; - size_t col_indx_k_0_max__ = nZ; - for (size_t k_0__ = 0; k_0__ < col_indx_k_0_max__; ++k_0__) { - col_indx[k_0__] = vals_i__[pos__++]; - } - size_t col_indx_i_0_max__ = nZ; - for (size_t i_0__ = 0; i_0__ < col_indx_i_0_max__; ++i_0__) { - check_greater_or_equal(function__, "col_indx[i_0__]", col_indx[i_0__], 0); - } - current_statement_begin__ = 74; - context__.validate_dims("data initialization", "nVariances", "int", context__.to_vec()); - nVariances = int(0); - vals_i__ = context__.vals_i("nVariances"); - pos__ = 0; - nVariances = vals_i__[pos__++]; - check_greater_or_equal(function__, "nVariances", nVariances, 0); - current_statement_begin__ = 75; - validate_non_negative_index("varIndx", "P", P); - context__.validate_dims("data initialization", "varIndx", "int", context__.to_vec(P)); - varIndx = std::vector(P, int(0)); - vals_i__ = context__.vals_i("varIndx"); - pos__ = 0; - size_t varIndx_k_0_max__ = P; - for (size_t k_0__ = 0; k_0__ < varIndx_k_0_max__; ++k_0__) { - varIndx[k_0__] = vals_i__[pos__++]; - } - size_t varIndx_i_0_max__ = P; - for (size_t i_0__ = 0; i_0__ < varIndx_i_0_max__; ++i_0__) { - check_greater_or_equal(function__, "varIndx[i_0__]", varIndx[i_0__], 0); - } - current_statement_begin__ = 76; - context__.validate_dims("data initialization", "nZero", "int", context__.to_vec()); - nZero = int(0); - vals_i__ = context__.vals_i("nZero"); - pos__ = 0; - nZero = vals_i__[pos__++]; - check_greater_or_equal(function__, "nZero", nZero, 0); - current_statement_begin__ = 77; - validate_non_negative_index("row_indx_z", "nZero", nZero); - context__.validate_dims("data initialization", "row_indx_z", "int", context__.to_vec(nZero)); - row_indx_z = std::vector(nZero, int(0)); - vals_i__ = context__.vals_i("row_indx_z"); - pos__ = 0; - size_t row_indx_z_k_0_max__ = nZero; - for (size_t k_0__ = 0; k_0__ < row_indx_z_k_0_max__; ++k_0__) { - row_indx_z[k_0__] = vals_i__[pos__++]; - } - size_t row_indx_z_i_0_max__ = nZero; - for (size_t i_0__ = 0; i_0__ < row_indx_z_i_0_max__; ++i_0__) { - check_greater_or_equal(function__, "row_indx_z[i_0__]", row_indx_z[i_0__], 0); - } - current_statement_begin__ = 78; - validate_non_negative_index("col_indx_z", "nZero", nZero); - context__.validate_dims("data initialization", "col_indx_z", "int", context__.to_vec(nZero)); - col_indx_z = std::vector(nZero, int(0)); - vals_i__ = context__.vals_i("col_indx_z"); - pos__ = 0; - size_t col_indx_z_k_0_max__ = nZero; - for (size_t k_0__ = 0; k_0__ < col_indx_z_k_0_max__; ++k_0__) { - col_indx_z[k_0__] = vals_i__[pos__++]; - } - size_t col_indx_z_i_0_max__ = nZero; - for (size_t i_0__ = 0; i_0__ < col_indx_z_i_0_max__; ++i_0__) { - check_greater_or_equal(function__, "col_indx_z[i_0__]", col_indx_z[i_0__], 0); - } - current_statement_begin__ = 79; - context__.validate_dims("data initialization", "n_pos", "int", context__.to_vec()); - n_pos = int(0); - vals_i__ = context__.vals_i("n_pos"); - pos__ = 0; - n_pos = vals_i__[pos__++]; - check_greater_or_equal(function__, "n_pos", n_pos, 0); - current_statement_begin__ = 80; - validate_non_negative_index("row_indx_pos", "n_pos", n_pos); - context__.validate_dims("data initialization", "row_indx_pos", "int", context__.to_vec(n_pos)); - row_indx_pos = std::vector(n_pos, int(0)); - vals_i__ = context__.vals_i("row_indx_pos"); - pos__ = 0; - size_t row_indx_pos_k_0_max__ = n_pos; - for (size_t k_0__ = 0; k_0__ < row_indx_pos_k_0_max__; ++k_0__) { - row_indx_pos[k_0__] = vals_i__[pos__++]; - } - size_t row_indx_pos_i_0_max__ = n_pos; - for (size_t i_0__ = 0; i_0__ < row_indx_pos_i_0_max__; ++i_0__) { - check_greater_or_equal(function__, "row_indx_pos[i_0__]", row_indx_pos[i_0__], 0); - } - current_statement_begin__ = 81; - validate_non_negative_index("col_indx_pos", "n_pos", n_pos); - context__.validate_dims("data initialization", "col_indx_pos", "int", context__.to_vec(n_pos)); - col_indx_pos = std::vector(n_pos, int(0)); - vals_i__ = context__.vals_i("col_indx_pos"); - pos__ = 0; - size_t col_indx_pos_k_0_max__ = n_pos; - for (size_t k_0__ = 0; k_0__ < col_indx_pos_k_0_max__; ++k_0__) { - col_indx_pos[k_0__] = vals_i__[pos__++]; - } - size_t col_indx_pos_i_0_max__ = n_pos; - for (size_t i_0__ = 0; i_0__ < col_indx_pos_i_0_max__; ++i_0__) { - check_greater_or_equal(function__, "col_indx_pos[i_0__]", col_indx_pos[i_0__], 0); - } - current_statement_begin__ = 82; - validate_non_negative_index("y", "n_pos", n_pos); - context__.validate_dims("data initialization", "y", "double", context__.to_vec(n_pos)); - y = std::vector(n_pos, double(0)); - vals_r__ = context__.vals_r("y"); - pos__ = 0; - size_t y_k_0_max__ = n_pos; - for (size_t k_0__ = 0; k_0__ < y_k_0_max__; ++k_0__) { - y[k_0__] = vals_r__[pos__++]; - } - current_statement_begin__ = 83; - validate_non_negative_index("y_int", "n_pos", n_pos); - context__.validate_dims("data initialization", "y_int", "int", context__.to_vec(n_pos)); - y_int = std::vector(n_pos, int(0)); - vals_i__ = context__.vals_i("y_int"); - pos__ = 0; - size_t y_int_k_0_max__ = n_pos; - for (size_t k_0__ = 0; k_0__ < y_int_k_0_max__; ++k_0__) { - y_int[k_0__] = vals_i__[pos__++]; - } - size_t y_int_i_0_max__ = n_pos; - for (size_t i_0__ = 0; i_0__ < y_int_i_0_max__; ++i_0__) { - check_greater_or_equal(function__, "y_int[i_0__]", y_int[i_0__], 0); - } - current_statement_begin__ = 84; - validate_non_negative_index("offset", "n_pos", n_pos); - context__.validate_dims("data initialization", "offset", "double", context__.to_vec(n_pos)); - offset = std::vector(n_pos, double(0)); - vals_r__ = context__.vals_r("offset"); - pos__ = 0; - size_t offset_k_0_max__ = n_pos; - for (size_t k_0__ = 0; k_0__ < offset_k_0_max__; ++k_0__) { - offset[k_0__] = vals_r__[pos__++]; - } - current_statement_begin__ = 85; - context__.validate_dims("data initialization", "n_na", "int", context__.to_vec()); - n_na = int(0); - vals_i__ = context__.vals_i("n_na"); - pos__ = 0; - n_na = vals_i__[pos__++]; - check_greater_or_equal(function__, "n_na", n_na, 0); - current_statement_begin__ = 86; - validate_non_negative_index("row_indx_na", "n_na", n_na); - context__.validate_dims("data initialization", "row_indx_na", "int", context__.to_vec(n_na)); - row_indx_na = std::vector(n_na, int(0)); - vals_i__ = context__.vals_i("row_indx_na"); - pos__ = 0; - size_t row_indx_na_k_0_max__ = n_na; - for (size_t k_0__ = 0; k_0__ < row_indx_na_k_0_max__; ++k_0__) { - row_indx_na[k_0__] = vals_i__[pos__++]; - } - size_t row_indx_na_i_0_max__ = n_na; - for (size_t i_0__ = 0; i_0__ < row_indx_na_i_0_max__; ++i_0__) { - check_greater_or_equal(function__, "row_indx_na[i_0__]", row_indx_na[i_0__], 0); - } - current_statement_begin__ = 87; - validate_non_negative_index("col_indx_na", "n_na", n_na); - context__.validate_dims("data initialization", "col_indx_na", "int", context__.to_vec(n_na)); - col_indx_na = std::vector(n_na, int(0)); - vals_i__ = context__.vals_i("col_indx_na"); - pos__ = 0; - size_t col_indx_na_k_0_max__ = n_na; - for (size_t k_0__ = 0; k_0__ < col_indx_na_k_0_max__; ++k_0__) { - col_indx_na[k_0__] = vals_i__[pos__++]; - } - size_t col_indx_na_i_0_max__ = n_na; - for (size_t i_0__ = 0; i_0__ < col_indx_na_i_0_max__; ++i_0__) { - check_greater_or_equal(function__, "col_indx_na[i_0__]", col_indx_na[i_0__], 0); - } - current_statement_begin__ = 88; - context__.validate_dims("data initialization", "nu_fixed", "double", context__.to_vec()); - nu_fixed = double(0); - vals_r__ = context__.vals_r("nu_fixed"); - pos__ = 0; - nu_fixed = vals_r__[pos__++]; - check_greater_or_equal(function__, "nu_fixed", nu_fixed, 1); - current_statement_begin__ = 89; - context__.validate_dims("data initialization", "estimate_nu", "int", context__.to_vec()); - estimate_nu = int(0); - vals_i__ = context__.vals_i("estimate_nu"); - pos__ = 0; - estimate_nu = vals_i__[pos__++]; - current_statement_begin__ = 90; - context__.validate_dims("data initialization", "use_normal", "int", context__.to_vec()); - use_normal = int(0); - vals_i__ = context__.vals_i("use_normal"); - pos__ = 0; - use_normal = vals_i__[pos__++]; - current_statement_begin__ = 91; - context__.validate_dims("data initialization", "est_cor", "int", context__.to_vec()); - est_cor = int(0); - vals_i__ = context__.vals_i("est_cor"); - pos__ = 0; - est_cor = vals_i__[pos__++]; - current_statement_begin__ = 92; - context__.validate_dims("data initialization", "est_phi", "int", context__.to_vec()); - est_phi = int(0); - vals_i__ = context__.vals_i("est_phi"); - pos__ = 0; - est_phi = vals_i__[pos__++]; - current_statement_begin__ = 93; - context__.validate_dims("data initialization", "est_theta", "int", context__.to_vec()); - est_theta = int(0); - vals_i__ = context__.vals_i("est_theta"); - pos__ = 0; - est_theta = vals_i__[pos__++]; - current_statement_begin__ = 94; - context__.validate_dims("data initialization", "num_obs_covar", "int", context__.to_vec()); - num_obs_covar = int(0); - vals_i__ = context__.vals_i("num_obs_covar"); - pos__ = 0; - num_obs_covar = vals_i__[pos__++]; - check_greater_or_equal(function__, "num_obs_covar", num_obs_covar, 0); - current_statement_begin__ = 95; - context__.validate_dims("data initialization", "n_obs_covar", "int", context__.to_vec()); - n_obs_covar = int(0); - vals_i__ = context__.vals_i("n_obs_covar"); - pos__ = 0; - n_obs_covar = vals_i__[pos__++]; - check_greater_or_equal(function__, "n_obs_covar", n_obs_covar, 0); - current_statement_begin__ = 96; - validate_non_negative_index("obs_covar_index", "num_obs_covar", num_obs_covar); - validate_non_negative_index("obs_covar_index", "3", 3); - context__.validate_dims("data initialization", "obs_covar_index", "int", context__.to_vec(num_obs_covar,3)); - obs_covar_index = std::vector >(num_obs_covar, std::vector(3, int(0))); - vals_i__ = context__.vals_i("obs_covar_index"); - pos__ = 0; - size_t obs_covar_index_k_0_max__ = num_obs_covar; - size_t obs_covar_index_k_1_max__ = 3; - for (size_t k_1__ = 0; k_1__ < obs_covar_index_k_1_max__; ++k_1__) { - for (size_t k_0__ = 0; k_0__ < obs_covar_index_k_0_max__; ++k_0__) { - obs_covar_index[k_0__][k_1__] = vals_i__[pos__++]; - } - } - current_statement_begin__ = 97; - validate_non_negative_index("obs_covar_value", "num_obs_covar", num_obs_covar); - context__.validate_dims("data initialization", "obs_covar_value", "double", context__.to_vec(num_obs_covar)); - obs_covar_value = std::vector(num_obs_covar, double(0)); - vals_r__ = context__.vals_r("obs_covar_value"); - pos__ = 0; - size_t obs_covar_value_k_0_max__ = num_obs_covar; - for (size_t k_0__ = 0; k_0__ < obs_covar_value_k_0_max__; ++k_0__) { - obs_covar_value[k_0__] = vals_r__[pos__++]; - } - current_statement_begin__ = 98; - validate_non_negative_index("match_obs_covar", "num_obs_covar", num_obs_covar); - context__.validate_dims("data initialization", "match_obs_covar", "int", context__.to_vec(num_obs_covar)); - match_obs_covar = std::vector(num_obs_covar, int(0)); - vals_i__ = context__.vals_i("match_obs_covar"); - pos__ = 0; - size_t match_obs_covar_k_0_max__ = num_obs_covar; - for (size_t k_0__ = 0; k_0__ < match_obs_covar_k_0_max__; ++k_0__) { - match_obs_covar[k_0__] = vals_i__[pos__++]; - } - current_statement_begin__ = 99; - context__.validate_dims("data initialization", "num_pro_covar", "int", context__.to_vec()); - num_pro_covar = int(0); - vals_i__ = context__.vals_i("num_pro_covar"); - pos__ = 0; - num_pro_covar = vals_i__[pos__++]; - check_greater_or_equal(function__, "num_pro_covar", num_pro_covar, 0); - current_statement_begin__ = 100; - context__.validate_dims("data initialization", "n_pro_covar", "int", context__.to_vec()); - n_pro_covar = int(0); - vals_i__ = context__.vals_i("n_pro_covar"); - pos__ = 0; - n_pro_covar = vals_i__[pos__++]; - check_greater_or_equal(function__, "n_pro_covar", n_pro_covar, 0); - current_statement_begin__ = 101; - validate_non_negative_index("pro_covar_index", "num_pro_covar", num_pro_covar); - validate_non_negative_index("pro_covar_index", "3", 3); - context__.validate_dims("data initialization", "pro_covar_index", "int", context__.to_vec(num_pro_covar,3)); - pro_covar_index = std::vector >(num_pro_covar, std::vector(3, int(0))); - vals_i__ = context__.vals_i("pro_covar_index"); - pos__ = 0; - size_t pro_covar_index_k_0_max__ = num_pro_covar; - size_t pro_covar_index_k_1_max__ = 3; - for (size_t k_1__ = 0; k_1__ < pro_covar_index_k_1_max__; ++k_1__) { - for (size_t k_0__ = 0; k_0__ < pro_covar_index_k_0_max__; ++k_0__) { - pro_covar_index[k_0__][k_1__] = vals_i__[pos__++]; - } - } - current_statement_begin__ = 102; - validate_non_negative_index("pro_covar_value", "num_pro_covar", num_pro_covar); - context__.validate_dims("data initialization", "pro_covar_value", "double", context__.to_vec(num_pro_covar)); - pro_covar_value = std::vector(num_pro_covar, double(0)); - vals_r__ = context__.vals_r("pro_covar_value"); - pos__ = 0; - size_t pro_covar_value_k_0_max__ = num_pro_covar; - for (size_t k_0__ = 0; k_0__ < pro_covar_value_k_0_max__; ++k_0__) { - pro_covar_value[k_0__] = vals_r__[pos__++]; - } - current_statement_begin__ = 103; - validate_non_negative_index("z_bound", "2", 2); - context__.validate_dims("data initialization", "z_bound", "double", context__.to_vec(2)); - z_bound = std::vector(2, double(0)); - vals_r__ = context__.vals_r("z_bound"); - pos__ = 0; - size_t z_bound_k_0_max__ = 2; - for (size_t k_0__ = 0; k_0__ < z_bound_k_0_max__; ++k_0__) { - z_bound[k_0__] = vals_r__[pos__++]; - } - current_statement_begin__ = 104; - context__.validate_dims("data initialization", "long_format", "int", context__.to_vec()); - long_format = int(0); - vals_i__ = context__.vals_i("long_format"); - pos__ = 0; - long_format = vals_i__[pos__++]; - check_greater_or_equal(function__, "long_format", long_format, 0); - current_statement_begin__ = 105; - context__.validate_dims("data initialization", "proportional_model", "int", context__.to_vec()); - proportional_model = int(0); - vals_i__ = context__.vals_i("proportional_model"); - pos__ = 0; - proportional_model = vals_i__[pos__++]; - check_greater_or_equal(function__, "proportional_model", proportional_model, 0); - current_statement_begin__ = 106; - context__.validate_dims("data initialization", "est_sigma_process", "int", context__.to_vec()); - est_sigma_process = int(0); - vals_i__ = context__.vals_i("est_sigma_process"); - pos__ = 0; - est_sigma_process = vals_i__[pos__++]; - check_greater_or_equal(function__, "est_sigma_process", est_sigma_process, 0); - current_statement_begin__ = 107; - context__.validate_dims("data initialization", "n_sigma_process", "int", context__.to_vec()); - n_sigma_process = int(0); - vals_i__ = context__.vals_i("n_sigma_process"); - pos__ = 0; - n_sigma_process = vals_i__[pos__++]; - check_greater_or_equal(function__, "n_sigma_process", n_sigma_process, 0); - current_statement_begin__ = 108; - context__.validate_dims("data initialization", "est_rw", "int", context__.to_vec()); - est_rw = int(0); - vals_i__ = context__.vals_i("est_rw"); - pos__ = 0; - est_rw = vals_i__[pos__++]; - check_greater_or_equal(function__, "est_rw", est_rw, 0); - current_statement_begin__ = 109; - context__.validate_dims("data initialization", "est_spline", "int", context__.to_vec()); - est_spline = int(0); - vals_i__ = context__.vals_i("est_spline"); - pos__ = 0; - est_spline = vals_i__[pos__++]; - check_greater_or_equal(function__, "est_spline", est_spline, 0); - current_statement_begin__ = 110; - context__.validate_dims("data initialization", "est_gp", "int", context__.to_vec()); - est_gp = int(0); - vals_i__ = context__.vals_i("est_gp"); - pos__ = 0; - est_gp = vals_i__[pos__++]; - check_greater_or_equal(function__, "est_gp", est_gp, 0); - current_statement_begin__ = 111; - context__.validate_dims("data initialization", "n_knots", "int", context__.to_vec()); - n_knots = int(0); - vals_i__ = context__.vals_i("n_knots"); - pos__ = 0; - n_knots = vals_i__[pos__++]; - check_greater_or_equal(function__, "n_knots", n_knots, 0); - current_statement_begin__ = 112; - validate_non_negative_index("X_spline", "N", N); - validate_non_negative_index("X_spline", "n_knots", n_knots); - context__.validate_dims("data initialization", "X_spline", "matrix_d", context__.to_vec(N,n_knots)); - X_spline = Eigen::Matrix(N, n_knots); - vals_r__ = context__.vals_r("X_spline"); - pos__ = 0; - size_t X_spline_j_2_max__ = n_knots; - size_t X_spline_j_1_max__ = N; - for (size_t j_2__ = 0; j_2__ < X_spline_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < X_spline_j_1_max__; ++j_1__) { - X_spline(j_1__, j_2__) = vals_r__[pos__++]; - } - } - current_statement_begin__ = 113; - validate_non_negative_index("knot_locs", "n_knots", n_knots); - context__.validate_dims("data initialization", "knot_locs", "double", context__.to_vec(n_knots)); - knot_locs = std::vector(n_knots, double(0)); - vals_r__ = context__.vals_r("knot_locs"); - pos__ = 0; - size_t knot_locs_k_0_max__ = n_knots; - for (size_t k_0__ = 0; k_0__ < knot_locs_k_0_max__; ++k_0__) { - knot_locs[k_0__] = vals_r__[pos__++]; - } - current_statement_begin__ = 117; - validate_non_negative_index("distKnots21_pred", "1", 1); - validate_non_negative_index("distKnots21_pred", "n_knots", n_knots); - context__.validate_dims("data initialization", "distKnots21_pred", "matrix_d", context__.to_vec(1,n_knots)); - distKnots21_pred = Eigen::Matrix(1, n_knots); - vals_r__ = context__.vals_r("distKnots21_pred"); - pos__ = 0; - size_t distKnots21_pred_j_2_max__ = n_knots; - size_t distKnots21_pred_j_1_max__ = 1; - for (size_t j_2__ = 0; j_2__ < distKnots21_pred_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < distKnots21_pred_j_1_max__; ++j_1__) { - distKnots21_pred(j_1__, j_2__) = vals_r__[pos__++]; - } - } - current_statement_begin__ = 118; - context__.validate_dims("data initialization", "obs_model", "int", context__.to_vec()); - obs_model = int(0); - vals_i__ = context__.vals_i("obs_model"); - pos__ = 0; - obs_model = vals_i__[pos__++]; - current_statement_begin__ = 119; - context__.validate_dims("data initialization", "est_sigma_params", "int", context__.to_vec()); - est_sigma_params = int(0); - vals_i__ = context__.vals_i("est_sigma_params"); - pos__ = 0; - est_sigma_params = vals_i__[pos__++]; - check_greater_or_equal(function__, "est_sigma_params", est_sigma_params, 0); - check_less_or_equal(function__, "est_sigma_params", est_sigma_params, 1); - current_statement_begin__ = 120; - context__.validate_dims("data initialization", "est_gamma_params", "int", context__.to_vec()); - est_gamma_params = int(0); - vals_i__ = context__.vals_i("est_gamma_params"); - pos__ = 0; - est_gamma_params = vals_i__[pos__++]; - check_greater_or_equal(function__, "est_gamma_params", est_gamma_params, 0); - check_less_or_equal(function__, "est_gamma_params", est_gamma_params, 1); - current_statement_begin__ = 121; - context__.validate_dims("data initialization", "est_nb2_params", "int", context__.to_vec()); - est_nb2_params = int(0); - vals_i__ = context__.vals_i("est_nb2_params"); - pos__ = 0; - est_nb2_params = vals_i__[pos__++]; - check_greater_or_equal(function__, "est_nb2_params", est_nb2_params, 0); - check_less_or_equal(function__, "est_nb2_params", est_nb2_params, 1); - current_statement_begin__ = 122; - context__.validate_dims("data initialization", "use_expansion_prior", "int", context__.to_vec()); - use_expansion_prior = int(0); - vals_i__ = context__.vals_i("use_expansion_prior"); - pos__ = 0; - use_expansion_prior = vals_i__[pos__++]; - check_greater_or_equal(function__, "use_expansion_prior", use_expansion_prior, 0); - check_less_or_equal(function__, "use_expansion_prior", use_expansion_prior, 1); - current_statement_begin__ = 123; - validate_non_negative_index("gp_theta_prior", "2", 2); - context__.validate_dims("data initialization", "gp_theta_prior", "double", context__.to_vec(2)); - gp_theta_prior = std::vector(2, double(0)); - vals_r__ = context__.vals_r("gp_theta_prior"); - pos__ = 0; - size_t gp_theta_prior_k_0_max__ = 2; - for (size_t k_0__ = 0; k_0__ < gp_theta_prior_k_0_max__; ++k_0__) { - gp_theta_prior[k_0__] = vals_r__[pos__++]; - } - current_statement_begin__ = 124; - validate_non_negative_index("weights_vec", "n_pos", n_pos); - context__.validate_dims("data initialization", "weights_vec", "double", context__.to_vec(n_pos)); - weights_vec = std::vector(n_pos, double(0)); - vals_r__ = context__.vals_r("weights_vec"); - pos__ = 0; - size_t weights_vec_k_0_max__ = n_pos; - for (size_t k_0__ = 0; k_0__ < weights_vec_k_0_max__; ++k_0__) { - weights_vec[k_0__] = vals_r__[pos__++]; - } - // initialize transformed data variables - current_statement_begin__ = 127; - n_pcor = int(0); - stan::math::fill(n_pcor, std::numeric_limits::min()); - current_statement_begin__ = 128; - n_loglik = int(0); - stan::math::fill(n_loglik, std::numeric_limits::min()); - current_statement_begin__ = 129; - validate_non_negative_index("zeros", "K", K); - zeros = Eigen::Matrix(K); - stan::math::fill(zeros, DUMMY_VAR__); - current_statement_begin__ = 130; - validate_non_negative_index("data_locs", "N", N); - data_locs = std::vector(N, double(0)); - stan::math::fill(data_locs, DUMMY_VAR__); - current_statement_begin__ = 131; - validate_non_negative_index("log_weights_vec", "n_pos", n_pos); - log_weights_vec = std::vector(n_pos, double(0)); - stan::math::fill(log_weights_vec, DUMMY_VAR__); - current_statement_begin__ = 132; - validate_non_negative_index("alpha_vec", "(K * proportional_model)", (K * proportional_model)); - alpha_vec = Eigen::Matrix((K * proportional_model)); - stan::math::fill(alpha_vec, DUMMY_VAR__); - current_statement_begin__ = 133; - validate_non_negative_index("muZeros", "n_knots", n_knots); - muZeros = Eigen::Matrix(n_knots); - stan::math::fill(muZeros, DUMMY_VAR__); - current_statement_begin__ = 134; - gp_delta = double(0); - stan::math::fill(gp_delta, DUMMY_VAR__); - stan::math::assign(gp_delta,1e-9); - current_statement_begin__ = 135; - lower_bound_z = double(0); - stan::math::fill(lower_bound_z, DUMMY_VAR__); - // execute transformed data statements - current_statement_begin__ = 137; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 138; - stan::model::assign(log_weights_vec, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - stan::math::log(get_base1(weights_vec, i, "weights_vec", 1)), - "assigning variable log_weights_vec"); - } - current_statement_begin__ = 140; - for (int i = 1; i <= N; ++i) { - current_statement_begin__ = 141; - stan::model::assign(data_locs, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - i, - "assigning variable data_locs"); - } - current_statement_begin__ = 143; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 144; - stan::model::assign(zeros, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - 0, - "assigning variable zeros"); - } - current_statement_begin__ = 146; - for (int k = 1; k <= n_knots; ++k) { - current_statement_begin__ = 147; - stan::model::assign(muZeros, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - 0, - "assigning variable muZeros"); - } - current_statement_begin__ = 151; - stan::math::assign(n_loglik, n_pos); - current_statement_begin__ = 152; - if (as_bool(logical_eq(long_format, 0))) { - current_statement_begin__ = 153; - if (as_bool(logical_eq(est_cor, 0))) { - current_statement_begin__ = 154; - stan::math::assign(n_loglik, (P * N)); - } else { - current_statement_begin__ = 156; - stan::math::assign(n_loglik, N); - } - } - current_statement_begin__ = 160; - if (as_bool(logical_eq(est_cor, 0))) { - current_statement_begin__ = 162; - stan::math::assign(n_pcor, P); - current_statement_begin__ = 163; - if (as_bool(logical_lt(nVariances, 2))) { - current_statement_begin__ = 165; - stan::math::assign(n_pcor, 2); - } + } + 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__; + static const char* function__ = "model_dfa_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()); + (void) DUMMY_VAR__; // suppress unused var warning + + try { + Eigen::Matrix devs; + devs = Eigen::Matrix(devs_1dim__, devs_2dim__); + stan::math::fill(devs, DUMMY_VAR__); + + current_statement__ = 1; + devs = in__.matrix(devs_1dim__, devs_2dim__); + Eigen::Matrix x0; + x0 = Eigen::Matrix(K); + stan::math::fill(x0, DUMMY_VAR__); + + current_statement__ = 2; + x0 = in__.vector(K); + Eigen::Matrix psi; + psi = Eigen::Matrix(psi_1dim__); + stan::math::fill(psi, DUMMY_VAR__); + + current_statement__ = 3; + psi = in__.vector(psi_1dim__); + current_statement__ = 3; + for (int sym1__ = 1; sym1__ <= psi_1dim__; ++sym1__) { + current_statement__ = 3; + if (jacobian__) { + current_statement__ = 3; + assign(psi, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(psi[(sym1__ - 1)], 0, lp__), + "assigning variable psi"); + } else { + current_statement__ = 3; + assign(psi, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(psi[(sym1__ - 1)], 0), + "assigning variable psi"); + }} + Eigen::Matrix z; + z = Eigen::Matrix(z_1dim__); + stan::math::fill(z, DUMMY_VAR__); + + current_statement__ = 4; + z = in__.vector(z_1dim__); + current_statement__ = 4; + for (int sym1__ = 1; sym1__ <= z_1dim__; ++sym1__) { + current_statement__ = 4; + if (jacobian__) { + current_statement__ = 4; + assign(z, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(z[(sym1__ - 1)], z_bound[(1 - 1)], + z_bound[(2 - 1)], lp__), "assigning variable z"); + } else { + current_statement__ = 4; + assign(z, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(z[(sym1__ - 1)], z_bound[(1 - 1)], + z_bound[(2 - 1)]), "assigning variable z"); + }} + Eigen::Matrix zpos; + zpos = Eigen::Matrix(zpos_1dim__); + stan::math::fill(zpos, DUMMY_VAR__); + + current_statement__ = 5; + zpos = in__.vector(zpos_1dim__); + current_statement__ = 5; + for (int sym1__ = 1; sym1__ <= zpos_1dim__; ++sym1__) { + current_statement__ = 5; + if (jacobian__) { + current_statement__ = 5; + assign(zpos, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(zpos[(sym1__ - 1)], lower_bound_z, lp__), + "assigning variable zpos"); + } else { + current_statement__ = 5; + assign(zpos, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(zpos[(sym1__ - 1)], lower_bound_z), + "assigning variable zpos"); + }} + std::vector> p_z; + p_z = std::vector>(p_z_1dim__, Eigen::Matrix(K)); + stan::math::fill(p_z, DUMMY_VAR__); + + std::vector> p_z_in__; + p_z_in__ = std::vector>(p_z_1dim__, Eigen::Matrix( + (K - 1))); + stan::math::fill(p_z_in__, DUMMY_VAR__); + + current_statement__ = 6; + for (int sym1__ = 1; sym1__ <= p_z_1dim__; ++sym1__) { + current_statement__ = 6; + assign(p_z_in__, cons_list(index_uni(sym1__), nil_index_list()), + in__.vector((K - 1)), "assigning variable p_z_in__");} + current_statement__ = 6; + for (int sym1__ = 1; sym1__ <= p_z_1dim__; ++sym1__) { + current_statement__ = 6; + if (jacobian__) { + current_statement__ = 6; + assign(p_z, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::simplex_constrain(p_z_in__[(sym1__ - 1)], lp__), + "assigning variable p_z"); + } else { + current_statement__ = 6; + assign(p_z, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::simplex_constrain(p_z_in__[(sym1__ - 1)]), + "assigning variable p_z"); + }} + Eigen::Matrix spline_a; + spline_a = Eigen::Matrix(spline_a_1dim__, spline_a_2dim__); + stan::math::fill(spline_a, DUMMY_VAR__); + + current_statement__ = 7; + spline_a = in__.matrix(spline_a_1dim__, spline_a_2dim__); + Eigen::Matrix b_obs; + b_obs = Eigen::Matrix(n_obs_covar, P); + stan::math::fill(b_obs, DUMMY_VAR__); + + current_statement__ = 8; + b_obs = in__.matrix(n_obs_covar, P); + Eigen::Matrix b_pro; + b_pro = Eigen::Matrix(n_pro_covar, K); + stan::math::fill(b_pro, DUMMY_VAR__); + + current_statement__ = 9; + b_pro = in__.matrix(n_pro_covar, K); + std::vector sigma; + sigma = std::vector(sigma_1dim__, DUMMY_VAR__); + + current_statement__ = 10; + for (int sym1__ = 1; sym1__ <= sigma_1dim__; ++sym1__) { + current_statement__ = 10; + assign(sigma, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable sigma");} + current_statement__ = 10; + for (int sym1__ = 1; sym1__ <= sigma_1dim__; ++sym1__) { + current_statement__ = 10; + if (jacobian__) { + current_statement__ = 10; + assign(sigma, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(sigma[(sym1__ - 1)], 0, lp__), + "assigning variable sigma"); + } else { + current_statement__ = 10; + assign(sigma, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(sigma[(sym1__ - 1)], 0), + "assigning variable sigma"); + }} + std::vector gamma_a; + gamma_a = std::vector(gamma_a_1dim__, DUMMY_VAR__); + + current_statement__ = 11; + for (int sym1__ = 1; sym1__ <= gamma_a_1dim__; ++sym1__) { + current_statement__ = 11; + assign(gamma_a, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable gamma_a");} + current_statement__ = 11; + for (int sym1__ = 1; sym1__ <= gamma_a_1dim__; ++sym1__) { + current_statement__ = 11; + if (jacobian__) { + current_statement__ = 11; + assign(gamma_a, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(gamma_a[(sym1__ - 1)], 0, lp__), + "assigning variable gamma_a"); + } else { + current_statement__ = 11; + assign(gamma_a, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(gamma_a[(sym1__ - 1)], 0), + "assigning variable gamma_a"); + }} + std::vector nb2_phi; + nb2_phi = std::vector(nb2_phi_1dim__, DUMMY_VAR__); + + current_statement__ = 12; + for (int sym1__ = 1; sym1__ <= nb2_phi_1dim__; ++sym1__) { + current_statement__ = 12; + assign(nb2_phi, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable nb2_phi");} + current_statement__ = 12; + for (int sym1__ = 1; sym1__ <= nb2_phi_1dim__; ++sym1__) { + current_statement__ = 12; + if (jacobian__) { + current_statement__ = 12; + assign(nb2_phi, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(nb2_phi[(sym1__ - 1)], 0, lp__), + "assigning variable nb2_phi"); + } else { + current_statement__ = 12; + assign(nb2_phi, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(nb2_phi[(sym1__ - 1)], 0), + "assigning variable nb2_phi"); + }} + std::vector nu; + nu = std::vector(estimate_nu, DUMMY_VAR__); + + current_statement__ = 13; + for (int sym1__ = 1; sym1__ <= estimate_nu; ++sym1__) { + current_statement__ = 13; + assign(nu, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable nu");} + current_statement__ = 13; + for (int sym1__ = 1; sym1__ <= estimate_nu; ++sym1__) { + current_statement__ = 13; + if (jacobian__) { + current_statement__ = 13; + assign(nu, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(nu[(sym1__ - 1)], 2, lp__), + "assigning variable nu"); + } else { + current_statement__ = 13; + assign(nu, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(nu[(sym1__ - 1)], 2), + "assigning variable nu"); + }} + std::vector ymiss; + ymiss = std::vector(n_na, DUMMY_VAR__); + + current_statement__ = 14; + for (int sym1__ = 1; sym1__ <= n_na; ++sym1__) { + current_statement__ = 14; + assign(ymiss, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable ymiss");} + std::vector phi; + phi = std::vector(phi_1dim__, DUMMY_VAR__); + + current_statement__ = 15; + for (int sym1__ = 1; sym1__ <= phi_1dim__; ++sym1__) { + current_statement__ = 15; + assign(phi, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable phi");} + current_statement__ = 15; + for (int sym1__ = 1; sym1__ <= phi_1dim__; ++sym1__) { + current_statement__ = 15; + if (jacobian__) { + current_statement__ = 15; + assign(phi, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(phi[(sym1__ - 1)], -1, 1, lp__), + "assigning variable phi"); + } else { + current_statement__ = 15; + assign(phi, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(phi[(sym1__ - 1)], -1, 1), + "assigning variable phi"); + }} + std::vector theta; + theta = std::vector(theta_1dim__, DUMMY_VAR__); + + current_statement__ = 16; + for (int sym1__ = 1; sym1__ <= theta_1dim__; ++sym1__) { + current_statement__ = 16; + assign(theta, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable theta");} + current_statement__ = 16; + for (int sym1__ = 1; sym1__ <= theta_1dim__; ++sym1__) { + current_statement__ = 16; + if (jacobian__) { + current_statement__ = 16; + assign(theta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(theta[(sym1__ - 1)], -1, 1, lp__), + "assigning variable theta"); + } else { + current_statement__ = 16; + assign(theta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(theta[(sym1__ - 1)], -1, 1), + "assigning variable theta"); + }} + std::vector gp_theta; + gp_theta = std::vector(gp_theta_1dim__, DUMMY_VAR__); + + current_statement__ = 17; + for (int sym1__ = 1; sym1__ <= gp_theta_1dim__; ++sym1__) { + current_statement__ = 17; + assign(gp_theta, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable gp_theta");} + current_statement__ = 17; + for (int sym1__ = 1; sym1__ <= gp_theta_1dim__; ++sym1__) { + current_statement__ = 17; + if (jacobian__) { + current_statement__ = 17; + assign(gp_theta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(gp_theta[(sym1__ - 1)], 0, lp__), + "assigning variable gp_theta"); + } else { + current_statement__ = 17; + assign(gp_theta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(gp_theta[(sym1__ - 1)], 0), + "assigning variable gp_theta"); + }} + Eigen::Matrix Lcorr; + Lcorr = Eigen::Matrix(n_pcor, n_pcor); + stan::math::fill(Lcorr, DUMMY_VAR__); + + Eigen::Matrix Lcorr_in__; + Lcorr_in__ = Eigen::Matrix(((n_pcor * + (n_pcor - 1)) / + 2)); + stan::math::fill(Lcorr_in__, DUMMY_VAR__); + + current_statement__ = 18; + Lcorr_in__ = in__.vector(((n_pcor * (n_pcor - 1)) / 2)); + current_statement__ = 18; + if (jacobian__) { + current_statement__ = 18; + assign(Lcorr, nil_index_list(), + stan::math::cholesky_corr_constrain(Lcorr_in__, n_pcor, lp__), + "assigning variable Lcorr"); + } else { + current_statement__ = 18; + assign(Lcorr, nil_index_list(), + stan::math::cholesky_corr_constrain(Lcorr_in__, n_pcor), + "assigning variable Lcorr"); + } + std::vector sigma_process; + sigma_process = std::vector(sigma_process_1dim__, DUMMY_VAR__); + + current_statement__ = 19; + for (int sym1__ = 1; sym1__ <= sigma_process_1dim__; ++sym1__) { + current_statement__ = 19; + assign(sigma_process, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable sigma_process");} + current_statement__ = 19; + for (int sym1__ = 1; sym1__ <= sigma_process_1dim__; ++sym1__) { + current_statement__ = 19; + if (jacobian__) { + current_statement__ = 19; + assign(sigma_process, + cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(sigma_process[(sym1__ - 1)], 0, lp__), + "assigning variable sigma_process"); + } else { + current_statement__ = 19; + assign(sigma_process, + cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(sigma_process[(sym1__ - 1)], 0), + "assigning variable sigma_process"); + }} + std::vector> effectsKnots; + effectsKnots = std::vector>(effectsKnots_1dim__, Eigen::Matrix(effectsKnots_2dim__)); + stan::math::fill(effectsKnots, DUMMY_VAR__); + + current_statement__ = 20; + for (int sym1__ = 1; sym1__ <= effectsKnots_1dim__; ++sym1__) { + current_statement__ = 20; + assign(effectsKnots, cons_list(index_uni(sym1__), nil_index_list()), + in__.vector(effectsKnots_2dim__), "assigning variable effectsKnots"); + } + Eigen::Matrix pred; + pred = Eigen::Matrix(P, N); + stan::math::fill(pred, DUMMY_VAR__); + + Eigen::Matrix Z; + Z = Eigen::Matrix(P, K); + stan::math::fill(Z, DUMMY_VAR__); + + Eigen::Matrix yall; + yall = Eigen::Matrix(P, N); + stan::math::fill(yall, DUMMY_VAR__); + + Eigen::Matrix sigma_vec; + sigma_vec = Eigen::Matrix(sigma_vec_1dim__); + stan::math::fill(sigma_vec, DUMMY_VAR__); + + Eigen::Matrix gamma_a_vec; + gamma_a_vec = Eigen::Matrix(gamma_a_vec_1dim__); + stan::math::fill(gamma_a_vec, DUMMY_VAR__); + + Eigen::Matrix nb_phi_vec; + nb_phi_vec = Eigen::Matrix(nb_phi_vec_1dim__); + stan::math::fill(nb_phi_vec, DUMMY_VAR__); + + Eigen::Matrix phi_vec; + phi_vec = Eigen::Matrix(K); + stan::math::fill(phi_vec, DUMMY_VAR__); + + Eigen::Matrix theta_vec; + theta_vec = Eigen::Matrix(K); + stan::math::fill(theta_vec, DUMMY_VAR__); + + Eigen::Matrix x; + x = Eigen::Matrix(K, N); + stan::math::fill(x, DUMMY_VAR__); + + Eigen::Matrix indicator; + indicator = Eigen::Matrix(K); + stan::math::fill(indicator, DUMMY_VAR__); + + Eigen::Matrix psi_root; + psi_root = Eigen::Matrix(psi_root_1dim__); + stan::math::fill(psi_root, DUMMY_VAR__); + + Eigen::Matrix Sigma_derived; + Sigma_derived = Eigen::Matrix(Sigma_derived_1dim__, Sigma_derived_2dim__); + stan::math::fill(Sigma_derived, DUMMY_VAR__); + + Eigen::Matrix Sigma_temp; + Sigma_temp = Eigen::Matrix(Sigma_temp_1dim__, Sigma_temp_2dim__); + stan::math::fill(Sigma_temp, DUMMY_VAR__); + + Eigen::Matrix sigma12_vec; + sigma12_vec = Eigen::Matrix(sigma12_vec_1dim__, 1); + stan::math::fill(sigma12_vec, DUMMY_VAR__); + + Eigen::Matrix temp_sums; + temp_sums = Eigen::Matrix(temp_sums_1dim__, temp_sums_2dim__); + stan::math::fill(temp_sums, DUMMY_VAR__); + + Eigen::Matrix temp_counts; + temp_counts = Eigen::Matrix(temp_counts_1dim__, temp_counts_2dim__); + stan::math::fill(temp_counts, DUMMY_VAR__); + + Eigen::Matrix cond_sigma_vec; + cond_sigma_vec = Eigen::Matrix(cond_sigma_vec_1dim__); + stan::math::fill(cond_sigma_vec, DUMMY_VAR__); + + Eigen::Matrix cond_mean_vec; + cond_mean_vec = Eigen::Matrix(cond_mean_vec_1dim__); + stan::math::fill(cond_mean_vec, DUMMY_VAR__); + + local_scalar_t__ sigma11; + sigma11 = DUMMY_VAR__; + + Eigen::Matrix sigma_pro; + sigma_pro = Eigen::Matrix(K); + stan::math::fill(sigma_pro, DUMMY_VAR__); + + Eigen::Matrix spline_a_trans; + spline_a_trans = Eigen::Matrix(spline_a_trans_1dim__, spline_a_trans_2dim__); + stan::math::fill(spline_a_trans, DUMMY_VAR__); + + std::vector> SigmaKnots; + SigmaKnots = std::vector>(K, Eigen::Matrix(n_knots, n_knots)); + stan::math::fill(SigmaKnots, DUMMY_VAR__); + + Eigen::Matrix obs_cov_offset; + obs_cov_offset = Eigen::Matrix(n_pos); + stan::math::fill(obs_cov_offset, DUMMY_VAR__); + + current_statement__ = 53; + for (int k = 1; k <= K; ++k) { + current_statement__ = 44; + assign(sigma_pro, cons_list(index_uni(k), nil_index_list()), 1, + "assigning variable sigma_pro"); + current_statement__ = 51; + if (logical_eq(est_sigma_process, 1)) { + current_statement__ = 49; + if (logical_eq(n_sigma_process, 1)) { + current_statement__ = 47; + assign(sigma_pro, cons_list(index_uni(k), nil_index_list()), + sigma_process[(1 - 1)], "assigning variable sigma_pro"); + } else { + current_statement__ = 45; + assign(sigma_pro, cons_list(index_uni(k), nil_index_list()), + sigma_process[(k - 1)], "assigning variable sigma_pro"); + } + } } + current_statement__ = 62; + if (logical_eq(est_phi, 1)) { + current_statement__ = 60; + for (int k = 1; k <= K; ++k) { + current_statement__ = 58; + assign(phi_vec, cons_list(index_uni(k), nil_index_list()), + phi[(k - 1)], "assigning variable phi_vec");} + } else { + current_statement__ = 56; + for (int k = 1; k <= K; ++k) { + current_statement__ = 54; + assign(phi_vec, cons_list(index_uni(k), nil_index_list()), 1, + "assigning variable phi_vec");} + } + current_statement__ = 71; + if (logical_eq(est_theta, 1)) { + current_statement__ = 69; + for (int k = 1; k <= K; ++k) { + current_statement__ = 67; + assign(theta_vec, cons_list(index_uni(k), nil_index_list()), + theta[(k - 1)], "assigning variable theta_vec");} + } else { + current_statement__ = 65; + for (int k = 1; k <= K; ++k) { + current_statement__ = 63; + assign(theta_vec, cons_list(index_uni(k), nil_index_list()), 0, + "assigning variable theta_vec");} + } + current_statement__ = 76; + if (logical_eq(est_sigma_params, 1)) { + current_statement__ = 74; + for (int p = 1; p <= P; ++p) { + current_statement__ = 72; + assign(sigma_vec, cons_list(index_uni(p), nil_index_list()), + sigma[(varIndx[(p - 1)] - 1)], "assigning variable sigma_vec");} + } + current_statement__ = 81; + if (logical_eq(est_gamma_params, 1)) { + current_statement__ = 79; + for (int p = 1; p <= P; ++p) { + current_statement__ = 77; + assign(gamma_a_vec, cons_list(index_uni(p), nil_index_list()), + gamma_a[(varIndx[(p - 1)] - 1)], "assigning variable gamma_a_vec"); + } + } + current_statement__ = 86; + if (logical_eq(est_nb2_params, 1)) { + current_statement__ = 84; + for (int p = 1; p <= P; ++p) { + current_statement__ = 82; + assign(nb_phi_vec, cons_list(index_uni(p), nil_index_list()), + nb2_phi[(varIndx[(p - 1)] - 1)], "assigning variable nb_phi_vec"); + } + } + current_statement__ = 96; + if (logical_eq(long_format, 0)) { + current_statement__ = 89; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 87; + assign(yall, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), nil_index_list())), + y[(i - 1)], "assigning variable yall");} + current_statement__ = 94; + if (logical_gt(n_na, 0)) { + current_statement__ = 92; + for (int i = 1; i <= n_na; ++i) { + current_statement__ = 90; + assign(yall, + cons_list(index_uni(row_indx_na[(i - 1)]), + cons_list(index_uni(col_indx_na[(i - 1)]), nil_index_list())), + ymiss[(i - 1)], "assigning variable yall");} + } + } + current_statement__ = 156; + if (logical_eq(proportional_model, 0)) { + current_statement__ = 99; + for (int i = 1; i <= nZ; ++i) { + current_statement__ = 97; + assign(Z, + cons_list(index_uni(row_indx[(i - 1)]), + cons_list(index_uni(col_indx[(i - 1)]), nil_index_list())), + z[(i - 1)], "assigning variable Z");} + current_statement__ = 104; + if (logical_gt(nZero, 2)) { + current_statement__ = 102; + for (int i = 1; i <= (nZero - 2); ++i) { + current_statement__ = 100; + assign(Z, + cons_list(index_uni(row_indx_z[(i - 1)]), + cons_list(index_uni(col_indx_z[(i - 1)]), nil_index_list())), + 0, "assigning variable Z");} + } + current_statement__ = 107; + for (int k = 1; k <= K; ++k) { + current_statement__ = 105; + assign(Z, + cons_list(index_uni(k), + cons_list(index_uni(k), nil_index_list())), zpos[(k - 1)], + "assigning variable Z");} + current_statement__ = 120; + if (logical_eq(use_expansion_prior, 1)) { + current_statement__ = 118; + for (int k = 1; k <= K; ++k) { + current_statement__ = 112; + if (logical_lt(zpos[(k - 1)], 0)) { + current_statement__ = 110; + assign(indicator, cons_list(index_uni(k), nil_index_list()), + -1, "assigning variable indicator"); } else { - current_statement_begin__ = 169; - stan::math::assign(n_pcor, P); - } - current_statement_begin__ = 173; - if (as_bool(logical_eq(proportional_model, 1))) { - current_statement_begin__ = 174; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 174; - stan::model::assign(alpha_vec, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - 1, - "assigning variable alpha_vec"); - } - } - current_statement_begin__ = 178; - stan::math::assign(lower_bound_z, -(100)); - current_statement_begin__ = 179; - if (as_bool(logical_eq(use_expansion_prior, 1))) { - current_statement_begin__ = 179; - stan::math::assign(lower_bound_z, 0); - } - // validate transformed data - // validate, set parameter ranges - num_params_r__ = 0U; - param_ranges_i__.clear(); - current_statement_begin__ = 183; - validate_non_negative_index("devs", "(K * est_rw)", (K * est_rw)); - validate_non_negative_index("devs", "((N - 1) * est_rw)", ((N - 1) * est_rw)); - num_params_r__ += ((K * est_rw) * ((N - 1) * est_rw)); - current_statement_begin__ = 184; - validate_non_negative_index("x0", "K", K); - num_params_r__ += K; - current_statement_begin__ = 185; - validate_non_negative_index("psi", "((K * (1 - proportional_model)) * use_expansion_prior)", ((K * (1 - proportional_model)) * use_expansion_prior)); - num_params_r__ += ((K * (1 - proportional_model)) * use_expansion_prior); - current_statement_begin__ = 186; - validate_non_negative_index("z", "(nZ * (1 - proportional_model))", (nZ * (1 - proportional_model))); - num_params_r__ += (nZ * (1 - proportional_model)); - current_statement_begin__ = 187; - validate_non_negative_index("zpos", "(K * (1 - proportional_model))", (K * (1 - proportional_model))); - num_params_r__ += (K * (1 - proportional_model)); - current_statement_begin__ = 188; - validate_non_negative_index("p_z", "K", K); - validate_non_negative_index("p_z", "(P * proportional_model)", (P * proportional_model)); - num_params_r__ += ((K - 1) * (P * proportional_model)); - current_statement_begin__ = 189; - validate_non_negative_index("spline_a", "(K * est_spline)", (K * est_spline)); - validate_non_negative_index("spline_a", "(n_knots * est_spline)", (n_knots * est_spline)); - num_params_r__ += ((K * est_spline) * (n_knots * est_spline)); - current_statement_begin__ = 190; - validate_non_negative_index("b_obs", "n_obs_covar", n_obs_covar); - validate_non_negative_index("b_obs", "P", P); - num_params_r__ += (n_obs_covar * P); - current_statement_begin__ = 191; - validate_non_negative_index("b_pro", "n_pro_covar", n_pro_covar); - validate_non_negative_index("b_pro", "K", K); - num_params_r__ += (n_pro_covar * K); - current_statement_begin__ = 192; - validate_non_negative_index("sigma", "(nVariances * est_sigma_params)", (nVariances * est_sigma_params)); - num_params_r__ += (1 * (nVariances * est_sigma_params)); - current_statement_begin__ = 193; - validate_non_negative_index("gamma_a", "(nVariances * est_gamma_params)", (nVariances * est_gamma_params)); - num_params_r__ += (1 * (nVariances * est_gamma_params)); - current_statement_begin__ = 194; - validate_non_negative_index("nb2_phi", "(nVariances * est_nb2_params)", (nVariances * est_nb2_params)); - num_params_r__ += (1 * (nVariances * est_nb2_params)); - current_statement_begin__ = 195; - validate_non_negative_index("nu", "estimate_nu", estimate_nu); - num_params_r__ += (1 * estimate_nu); - current_statement_begin__ = 196; - validate_non_negative_index("ymiss", "n_na", n_na); - num_params_r__ += (1 * n_na); - current_statement_begin__ = 197; - validate_non_negative_index("phi", "(est_phi * K)", (est_phi * K)); - num_params_r__ += (1 * (est_phi * K)); - current_statement_begin__ = 198; - validate_non_negative_index("theta", "(est_theta * K)", (est_theta * K)); - num_params_r__ += (1 * (est_theta * K)); - current_statement_begin__ = 199; - validate_non_negative_index("gp_theta", "(est_gp * K)", (est_gp * K)); - num_params_r__ += (1 * (est_gp * K)); - current_statement_begin__ = 200; - validate_non_negative_index("Lcorr", "n_pcor", n_pcor); - validate_non_negative_index("Lcorr", "n_pcor", n_pcor); - num_params_r__ += ((n_pcor * (n_pcor - 1)) / 2); - current_statement_begin__ = 201; - validate_non_negative_index("sigma_process", "(est_sigma_process * n_sigma_process)", (est_sigma_process * n_sigma_process)); - num_params_r__ += (1 * (est_sigma_process * n_sigma_process)); - current_statement_begin__ = 202; - validate_non_negative_index("effectsKnots", "(n_knots * est_gp)", (n_knots * est_gp)); - validate_non_negative_index("effectsKnots", "(K * est_gp)", (K * est_gp)); - num_params_r__ += ((n_knots * est_gp) * (K * est_gp)); - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__()); - // Next line prevents compiler griping about no return - throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); - } - } - ~model_dfa() { } - void transform_inits(const stan::io::var_context& context__, - std::vector& params_i__, - std::vector& params_r__, - std::ostream* pstream__) const { - typedef double local_scalar_t__; - stan::io::writer writer__(params_r__, params_i__); - size_t pos__; - (void) pos__; // dummy call to supress warning - std::vector vals_r__; - std::vector vals_i__; - current_statement_begin__ = 183; - if (!(context__.contains_r("devs"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable devs missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("devs"); - pos__ = 0U; - validate_non_negative_index("devs", "(K * est_rw)", (K * est_rw)); - validate_non_negative_index("devs", "((N - 1) * est_rw)", ((N - 1) * est_rw)); - context__.validate_dims("parameter initialization", "devs", "matrix_d", context__.to_vec((K * est_rw),((N - 1) * est_rw))); - Eigen::Matrix devs((K * est_rw), ((N - 1) * est_rw)); - size_t devs_j_2_max__ = ((N - 1) * est_rw); - size_t devs_j_1_max__ = (K * est_rw); - for (size_t j_2__ = 0; j_2__ < devs_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < devs_j_1_max__; ++j_1__) { - devs(j_1__, j_2__) = vals_r__[pos__++]; - } - } - try { - writer__.matrix_unconstrain(devs); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable devs: ") + e.what()), current_statement_begin__, prog_reader__()); - } - current_statement_begin__ = 184; - if (!(context__.contains_r("x0"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable x0 missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("x0"); - pos__ = 0U; - validate_non_negative_index("x0", "K", K); - context__.validate_dims("parameter initialization", "x0", "vector_d", context__.to_vec(K)); - Eigen::Matrix x0(K); - size_t x0_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < x0_j_1_max__; ++j_1__) { - x0(j_1__) = vals_r__[pos__++]; - } - try { - writer__.vector_unconstrain(x0); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable x0: ") + e.what()), current_statement_begin__, prog_reader__()); - } - current_statement_begin__ = 185; - if (!(context__.contains_r("psi"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable psi missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("psi"); - pos__ = 0U; - validate_non_negative_index("psi", "((K * (1 - proportional_model)) * use_expansion_prior)", ((K * (1 - proportional_model)) * use_expansion_prior)); - context__.validate_dims("parameter initialization", "psi", "vector_d", context__.to_vec(((K * (1 - proportional_model)) * use_expansion_prior))); - Eigen::Matrix psi(((K * (1 - proportional_model)) * use_expansion_prior)); - size_t psi_j_1_max__ = ((K * (1 - proportional_model)) * use_expansion_prior); - for (size_t j_1__ = 0; j_1__ < psi_j_1_max__; ++j_1__) { - psi(j_1__) = vals_r__[pos__++]; - } - try { - writer__.vector_lb_unconstrain(0, psi); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable psi: ") + e.what()), current_statement_begin__, prog_reader__()); - } - current_statement_begin__ = 186; - if (!(context__.contains_r("z"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable z missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("z"); - pos__ = 0U; - validate_non_negative_index("z", "(nZ * (1 - proportional_model))", (nZ * (1 - proportional_model))); - context__.validate_dims("parameter initialization", "z", "vector_d", context__.to_vec((nZ * (1 - proportional_model)))); - Eigen::Matrix z((nZ * (1 - proportional_model))); - size_t z_j_1_max__ = (nZ * (1 - proportional_model)); - for (size_t j_1__ = 0; j_1__ < z_j_1_max__; ++j_1__) { - z(j_1__) = vals_r__[pos__++]; - } - try { - writer__.vector_lub_unconstrain(get_base1(z_bound, 1, "z_bound", 1), get_base1(z_bound, 2, "z_bound", 1), z); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable z: ") + e.what()), current_statement_begin__, prog_reader__()); - } - current_statement_begin__ = 187; - if (!(context__.contains_r("zpos"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable zpos missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("zpos"); - pos__ = 0U; - validate_non_negative_index("zpos", "(K * (1 - proportional_model))", (K * (1 - proportional_model))); - context__.validate_dims("parameter initialization", "zpos", "vector_d", context__.to_vec((K * (1 - proportional_model)))); - Eigen::Matrix zpos((K * (1 - proportional_model))); - size_t zpos_j_1_max__ = (K * (1 - proportional_model)); - for (size_t j_1__ = 0; j_1__ < zpos_j_1_max__; ++j_1__) { - zpos(j_1__) = vals_r__[pos__++]; - } - try { - writer__.vector_lb_unconstrain(lower_bound_z, zpos); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable zpos: ") + e.what()), current_statement_begin__, prog_reader__()); - } - current_statement_begin__ = 188; - if (!(context__.contains_r("p_z"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable p_z missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("p_z"); - pos__ = 0U; - validate_non_negative_index("p_z", "K", K); - validate_non_negative_index("p_z", "(P * proportional_model)", (P * proportional_model)); - context__.validate_dims("parameter initialization", "p_z", "vector_d", context__.to_vec((P * proportional_model),K)); - std::vector > p_z((P * proportional_model), Eigen::Matrix(K)); - size_t p_z_j_1_max__ = K; - size_t p_z_k_0_max__ = (P * proportional_model); - for (size_t j_1__ = 0; j_1__ < p_z_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < p_z_k_0_max__; ++k_0__) { - p_z[k_0__](j_1__) = vals_r__[pos__++]; - } - } - size_t p_z_i_0_max__ = (P * proportional_model); - for (size_t i_0__ = 0; i_0__ < p_z_i_0_max__; ++i_0__) { - try { - writer__.simplex_unconstrain(p_z[i_0__]); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable p_z: ") + e.what()), current_statement_begin__, prog_reader__()); - } - } - current_statement_begin__ = 189; - if (!(context__.contains_r("spline_a"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable spline_a missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("spline_a"); - pos__ = 0U; - validate_non_negative_index("spline_a", "(K * est_spline)", (K * est_spline)); - validate_non_negative_index("spline_a", "(n_knots * est_spline)", (n_knots * est_spline)); - context__.validate_dims("parameter initialization", "spline_a", "matrix_d", context__.to_vec((K * est_spline),(n_knots * est_spline))); - Eigen::Matrix spline_a((K * est_spline), (n_knots * est_spline)); - size_t spline_a_j_2_max__ = (n_knots * est_spline); - size_t spline_a_j_1_max__ = (K * est_spline); - for (size_t j_2__ = 0; j_2__ < spline_a_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < spline_a_j_1_max__; ++j_1__) { - spline_a(j_1__, j_2__) = vals_r__[pos__++]; - } - } - try { - writer__.matrix_unconstrain(spline_a); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable spline_a: ") + e.what()), current_statement_begin__, prog_reader__()); - } - current_statement_begin__ = 190; - if (!(context__.contains_r("b_obs"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable b_obs missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("b_obs"); - pos__ = 0U; - validate_non_negative_index("b_obs", "n_obs_covar", n_obs_covar); - validate_non_negative_index("b_obs", "P", P); - context__.validate_dims("parameter initialization", "b_obs", "matrix_d", context__.to_vec(n_obs_covar,P)); - Eigen::Matrix b_obs(n_obs_covar, P); - size_t b_obs_j_2_max__ = P; - size_t b_obs_j_1_max__ = n_obs_covar; - for (size_t j_2__ = 0; j_2__ < b_obs_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < b_obs_j_1_max__; ++j_1__) { - b_obs(j_1__, j_2__) = vals_r__[pos__++]; - } - } - try { - writer__.matrix_unconstrain(b_obs); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable b_obs: ") + e.what()), current_statement_begin__, prog_reader__()); - } - current_statement_begin__ = 191; - if (!(context__.contains_r("b_pro"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable b_pro missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("b_pro"); - pos__ = 0U; - validate_non_negative_index("b_pro", "n_pro_covar", n_pro_covar); - validate_non_negative_index("b_pro", "K", K); - context__.validate_dims("parameter initialization", "b_pro", "matrix_d", context__.to_vec(n_pro_covar,K)); - Eigen::Matrix b_pro(n_pro_covar, K); - size_t b_pro_j_2_max__ = K; - size_t b_pro_j_1_max__ = n_pro_covar; - for (size_t j_2__ = 0; j_2__ < b_pro_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < b_pro_j_1_max__; ++j_1__) { - b_pro(j_1__, j_2__) = vals_r__[pos__++]; - } - } - try { - writer__.matrix_unconstrain(b_pro); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable b_pro: ") + e.what()), current_statement_begin__, prog_reader__()); - } - current_statement_begin__ = 192; - if (!(context__.contains_r("sigma"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable sigma missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("sigma"); - pos__ = 0U; - validate_non_negative_index("sigma", "(nVariances * est_sigma_params)", (nVariances * est_sigma_params)); - context__.validate_dims("parameter initialization", "sigma", "double", context__.to_vec((nVariances * est_sigma_params))); - std::vector sigma((nVariances * est_sigma_params), double(0)); - size_t sigma_k_0_max__ = (nVariances * est_sigma_params); - for (size_t k_0__ = 0; k_0__ < sigma_k_0_max__; ++k_0__) { - sigma[k_0__] = vals_r__[pos__++]; - } - size_t sigma_i_0_max__ = (nVariances * est_sigma_params); - for (size_t i_0__ = 0; i_0__ < sigma_i_0_max__; ++i_0__) { - try { - writer__.scalar_lb_unconstrain(0, sigma[i_0__]); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable sigma: ") + e.what()), current_statement_begin__, prog_reader__()); - } - } - current_statement_begin__ = 193; - if (!(context__.contains_r("gamma_a"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable gamma_a missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("gamma_a"); - pos__ = 0U; - validate_non_negative_index("gamma_a", "(nVariances * est_gamma_params)", (nVariances * est_gamma_params)); - context__.validate_dims("parameter initialization", "gamma_a", "double", context__.to_vec((nVariances * est_gamma_params))); - std::vector gamma_a((nVariances * est_gamma_params), double(0)); - size_t gamma_a_k_0_max__ = (nVariances * est_gamma_params); - for (size_t k_0__ = 0; k_0__ < gamma_a_k_0_max__; ++k_0__) { - gamma_a[k_0__] = vals_r__[pos__++]; - } - size_t gamma_a_i_0_max__ = (nVariances * est_gamma_params); - for (size_t i_0__ = 0; i_0__ < gamma_a_i_0_max__; ++i_0__) { - try { - writer__.scalar_lb_unconstrain(0, gamma_a[i_0__]); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable gamma_a: ") + e.what()), current_statement_begin__, prog_reader__()); - } - } - current_statement_begin__ = 194; - if (!(context__.contains_r("nb2_phi"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable nb2_phi missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("nb2_phi"); - pos__ = 0U; - validate_non_negative_index("nb2_phi", "(nVariances * est_nb2_params)", (nVariances * est_nb2_params)); - context__.validate_dims("parameter initialization", "nb2_phi", "double", context__.to_vec((nVariances * est_nb2_params))); - std::vector nb2_phi((nVariances * est_nb2_params), double(0)); - size_t nb2_phi_k_0_max__ = (nVariances * est_nb2_params); - for (size_t k_0__ = 0; k_0__ < nb2_phi_k_0_max__; ++k_0__) { - nb2_phi[k_0__] = vals_r__[pos__++]; - } - size_t nb2_phi_i_0_max__ = (nVariances * est_nb2_params); - for (size_t i_0__ = 0; i_0__ < nb2_phi_i_0_max__; ++i_0__) { - try { - writer__.scalar_lb_unconstrain(0, nb2_phi[i_0__]); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable nb2_phi: ") + e.what()), current_statement_begin__, prog_reader__()); - } - } - current_statement_begin__ = 195; - if (!(context__.contains_r("nu"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable nu missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("nu"); - pos__ = 0U; - validate_non_negative_index("nu", "estimate_nu", estimate_nu); - context__.validate_dims("parameter initialization", "nu", "double", context__.to_vec(estimate_nu)); - std::vector nu(estimate_nu, double(0)); - size_t nu_k_0_max__ = estimate_nu; - for (size_t k_0__ = 0; k_0__ < nu_k_0_max__; ++k_0__) { - nu[k_0__] = vals_r__[pos__++]; - } - size_t nu_i_0_max__ = estimate_nu; - for (size_t i_0__ = 0; i_0__ < nu_i_0_max__; ++i_0__) { - try { - writer__.scalar_lb_unconstrain(2, nu[i_0__]); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable nu: ") + e.what()), current_statement_begin__, prog_reader__()); - } - } - current_statement_begin__ = 196; - if (!(context__.contains_r("ymiss"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable ymiss missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("ymiss"); - pos__ = 0U; - validate_non_negative_index("ymiss", "n_na", n_na); - context__.validate_dims("parameter initialization", "ymiss", "double", context__.to_vec(n_na)); - std::vector ymiss(n_na, double(0)); - size_t ymiss_k_0_max__ = n_na; - for (size_t k_0__ = 0; k_0__ < ymiss_k_0_max__; ++k_0__) { - ymiss[k_0__] = vals_r__[pos__++]; - } - size_t ymiss_i_0_max__ = n_na; - for (size_t i_0__ = 0; i_0__ < ymiss_i_0_max__; ++i_0__) { - try { - writer__.scalar_unconstrain(ymiss[i_0__]); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable ymiss: ") + e.what()), current_statement_begin__, prog_reader__()); - } - } - current_statement_begin__ = 197; - if (!(context__.contains_r("phi"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable phi missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("phi"); - pos__ = 0U; - validate_non_negative_index("phi", "(est_phi * K)", (est_phi * K)); - context__.validate_dims("parameter initialization", "phi", "double", context__.to_vec((est_phi * K))); - std::vector phi((est_phi * K), double(0)); - size_t phi_k_0_max__ = (est_phi * K); - for (size_t k_0__ = 0; k_0__ < phi_k_0_max__; ++k_0__) { - phi[k_0__] = vals_r__[pos__++]; - } - size_t phi_i_0_max__ = (est_phi * K); - for (size_t i_0__ = 0; i_0__ < phi_i_0_max__; ++i_0__) { - try { - writer__.scalar_lub_unconstrain(-(1), 1, phi[i_0__]); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable phi: ") + e.what()), current_statement_begin__, prog_reader__()); - } - } - current_statement_begin__ = 198; - if (!(context__.contains_r("theta"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable theta missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("theta"); - pos__ = 0U; - validate_non_negative_index("theta", "(est_theta * K)", (est_theta * K)); - context__.validate_dims("parameter initialization", "theta", "double", context__.to_vec((est_theta * K))); - std::vector theta((est_theta * K), double(0)); - size_t theta_k_0_max__ = (est_theta * K); - for (size_t k_0__ = 0; k_0__ < theta_k_0_max__; ++k_0__) { - theta[k_0__] = vals_r__[pos__++]; - } - size_t theta_i_0_max__ = (est_theta * K); - for (size_t i_0__ = 0; i_0__ < theta_i_0_max__; ++i_0__) { - try { - writer__.scalar_lub_unconstrain(-(1), 1, theta[i_0__]); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable theta: ") + e.what()), current_statement_begin__, prog_reader__()); - } - } - current_statement_begin__ = 199; - if (!(context__.contains_r("gp_theta"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable gp_theta missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("gp_theta"); - pos__ = 0U; - validate_non_negative_index("gp_theta", "(est_gp * K)", (est_gp * K)); - context__.validate_dims("parameter initialization", "gp_theta", "double", context__.to_vec((est_gp * K))); - std::vector gp_theta((est_gp * K), double(0)); - size_t gp_theta_k_0_max__ = (est_gp * K); - for (size_t k_0__ = 0; k_0__ < gp_theta_k_0_max__; ++k_0__) { - gp_theta[k_0__] = vals_r__[pos__++]; - } - size_t gp_theta_i_0_max__ = (est_gp * K); - for (size_t i_0__ = 0; i_0__ < gp_theta_i_0_max__; ++i_0__) { - try { - writer__.scalar_lb_unconstrain(0, gp_theta[i_0__]); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable gp_theta: ") + e.what()), current_statement_begin__, prog_reader__()); - } - } - current_statement_begin__ = 200; - if (!(context__.contains_r("Lcorr"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable Lcorr missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("Lcorr"); - pos__ = 0U; - validate_non_negative_index("Lcorr", "n_pcor", n_pcor); - validate_non_negative_index("Lcorr", "n_pcor", n_pcor); - context__.validate_dims("parameter initialization", "Lcorr", "matrix_d", context__.to_vec(n_pcor,n_pcor)); - Eigen::Matrix Lcorr(n_pcor, n_pcor); - size_t Lcorr_j_2_max__ = n_pcor; - size_t Lcorr_j_1_max__ = n_pcor; - for (size_t j_2__ = 0; j_2__ < Lcorr_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Lcorr_j_1_max__; ++j_1__) { - Lcorr(j_1__, j_2__) = vals_r__[pos__++]; - } - } - try { - writer__.cholesky_factor_corr_unconstrain(Lcorr); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable Lcorr: ") + e.what()), current_statement_begin__, prog_reader__()); - } - current_statement_begin__ = 201; - if (!(context__.contains_r("sigma_process"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable sigma_process missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("sigma_process"); - pos__ = 0U; - validate_non_negative_index("sigma_process", "(est_sigma_process * n_sigma_process)", (est_sigma_process * n_sigma_process)); - context__.validate_dims("parameter initialization", "sigma_process", "double", context__.to_vec((est_sigma_process * n_sigma_process))); - std::vector sigma_process((est_sigma_process * n_sigma_process), double(0)); - size_t sigma_process_k_0_max__ = (est_sigma_process * n_sigma_process); - for (size_t k_0__ = 0; k_0__ < sigma_process_k_0_max__; ++k_0__) { - sigma_process[k_0__] = vals_r__[pos__++]; - } - size_t sigma_process_i_0_max__ = (est_sigma_process * n_sigma_process); - for (size_t i_0__ = 0; i_0__ < sigma_process_i_0_max__; ++i_0__) { - try { - writer__.scalar_lb_unconstrain(0, sigma_process[i_0__]); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable sigma_process: ") + e.what()), current_statement_begin__, prog_reader__()); - } - } - current_statement_begin__ = 202; - if (!(context__.contains_r("effectsKnots"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable effectsKnots missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("effectsKnots"); - pos__ = 0U; - validate_non_negative_index("effectsKnots", "(n_knots * est_gp)", (n_knots * est_gp)); - validate_non_negative_index("effectsKnots", "(K * est_gp)", (K * est_gp)); - context__.validate_dims("parameter initialization", "effectsKnots", "vector_d", context__.to_vec((K * est_gp),(n_knots * est_gp))); - std::vector > effectsKnots((K * est_gp), Eigen::Matrix((n_knots * est_gp))); - size_t effectsKnots_j_1_max__ = (n_knots * est_gp); - size_t effectsKnots_k_0_max__ = (K * est_gp); - for (size_t j_1__ = 0; j_1__ < effectsKnots_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < effectsKnots_k_0_max__; ++k_0__) { - effectsKnots[k_0__](j_1__) = vals_r__[pos__++]; - } - } - size_t effectsKnots_i_0_max__ = (K * est_gp); - for (size_t i_0__ = 0; i_0__ < effectsKnots_i_0_max__; ++i_0__) { - try { - writer__.vector_unconstrain(effectsKnots[i_0__]); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable effectsKnots: ") + e.what()), current_statement_begin__, prog_reader__()); - } - } - params_r__ = writer__.data_r(); - params_i__ = writer__.data_i(); - } - void transform_inits(const stan::io::var_context& context, - Eigen::Matrix& params_r, - std::ostream* pstream__) const { - std::vector params_r_vec; - std::vector params_i_vec; - transform_inits(context, params_i_vec, params_r_vec, pstream__); - params_r.resize(params_r_vec.size()); - for (int i = 0; i < params_r.size(); ++i) - params_r(i) = params_r_vec[i]; - } - template - T__ log_prob(std::vector& params_r__, - std::vector& params_i__, - std::ostream* pstream__ = 0) const { - typedef T__ local_scalar_t__; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - (void) DUMMY_VAR__; // dummy to suppress unused var warning - T__ lp__(0.0); - stan::math::accumulator lp_accum__; - try { - stan::io::reader in__(params_r__, params_i__); - // model parameters - current_statement_begin__ = 183; - Eigen::Matrix devs; - (void) devs; // dummy to suppress unused var warning - if (jacobian__) - devs = in__.matrix_constrain((K * est_rw), ((N - 1) * est_rw), lp__); - else - devs = in__.matrix_constrain((K * est_rw), ((N - 1) * est_rw)); - current_statement_begin__ = 184; - Eigen::Matrix x0; - (void) x0; // dummy to suppress unused var warning - if (jacobian__) - x0 = in__.vector_constrain(K, lp__); - else - x0 = in__.vector_constrain(K); - current_statement_begin__ = 185; - Eigen::Matrix psi; - (void) psi; // dummy to suppress unused var warning - if (jacobian__) - psi = in__.vector_lb_constrain(0, ((K * (1 - proportional_model)) * use_expansion_prior), lp__); - else - psi = in__.vector_lb_constrain(0, ((K * (1 - proportional_model)) * use_expansion_prior)); - current_statement_begin__ = 186; - Eigen::Matrix z; - (void) z; // dummy to suppress unused var warning - if (jacobian__) - z = in__.vector_lub_constrain(get_base1(z_bound, 1, "z_bound", 1), get_base1(z_bound, 2, "z_bound", 1), (nZ * (1 - proportional_model)), lp__); - else - z = in__.vector_lub_constrain(get_base1(z_bound, 1, "z_bound", 1), get_base1(z_bound, 2, "z_bound", 1), (nZ * (1 - proportional_model))); - current_statement_begin__ = 187; - Eigen::Matrix zpos; - (void) zpos; // dummy to suppress unused var warning - if (jacobian__) - zpos = in__.vector_lb_constrain(lower_bound_z, (K * (1 - proportional_model)), lp__); - else - zpos = in__.vector_lb_constrain(lower_bound_z, (K * (1 - proportional_model))); - current_statement_begin__ = 188; - std::vector > p_z; - size_t p_z_d_0_max__ = (P * proportional_model); - p_z.reserve(p_z_d_0_max__); - for (size_t d_0__ = 0; d_0__ < p_z_d_0_max__; ++d_0__) { - if (jacobian__) - p_z.push_back(in__.simplex_constrain(K, lp__)); - else - p_z.push_back(in__.simplex_constrain(K)); - } - current_statement_begin__ = 189; - Eigen::Matrix spline_a; - (void) spline_a; // dummy to suppress unused var warning - if (jacobian__) - spline_a = in__.matrix_constrain((K * est_spline), (n_knots * est_spline), lp__); - else - spline_a = in__.matrix_constrain((K * est_spline), (n_knots * est_spline)); - current_statement_begin__ = 190; - Eigen::Matrix b_obs; - (void) b_obs; // dummy to suppress unused var warning - if (jacobian__) - b_obs = in__.matrix_constrain(n_obs_covar, P, lp__); - else - b_obs = in__.matrix_constrain(n_obs_covar, P); - current_statement_begin__ = 191; - Eigen::Matrix b_pro; - (void) b_pro; // dummy to suppress unused var warning - if (jacobian__) - b_pro = in__.matrix_constrain(n_pro_covar, K, lp__); - else - b_pro = in__.matrix_constrain(n_pro_covar, K); - current_statement_begin__ = 192; - std::vector sigma; - size_t sigma_d_0_max__ = (nVariances * est_sigma_params); - sigma.reserve(sigma_d_0_max__); - for (size_t d_0__ = 0; d_0__ < sigma_d_0_max__; ++d_0__) { - if (jacobian__) - sigma.push_back(in__.scalar_lb_constrain(0, lp__)); - else - sigma.push_back(in__.scalar_lb_constrain(0)); - } - current_statement_begin__ = 193; - std::vector gamma_a; - size_t gamma_a_d_0_max__ = (nVariances * est_gamma_params); - gamma_a.reserve(gamma_a_d_0_max__); - for (size_t d_0__ = 0; d_0__ < gamma_a_d_0_max__; ++d_0__) { - if (jacobian__) - gamma_a.push_back(in__.scalar_lb_constrain(0, lp__)); - else - gamma_a.push_back(in__.scalar_lb_constrain(0)); - } - current_statement_begin__ = 194; - std::vector nb2_phi; - size_t nb2_phi_d_0_max__ = (nVariances * est_nb2_params); - nb2_phi.reserve(nb2_phi_d_0_max__); - for (size_t d_0__ = 0; d_0__ < nb2_phi_d_0_max__; ++d_0__) { - if (jacobian__) - nb2_phi.push_back(in__.scalar_lb_constrain(0, lp__)); - else - nb2_phi.push_back(in__.scalar_lb_constrain(0)); - } - current_statement_begin__ = 195; - std::vector nu; - size_t nu_d_0_max__ = estimate_nu; - nu.reserve(nu_d_0_max__); - for (size_t d_0__ = 0; d_0__ < nu_d_0_max__; ++d_0__) { - if (jacobian__) - nu.push_back(in__.scalar_lb_constrain(2, lp__)); - else - nu.push_back(in__.scalar_lb_constrain(2)); - } - current_statement_begin__ = 196; - std::vector ymiss; - size_t ymiss_d_0_max__ = n_na; - ymiss.reserve(ymiss_d_0_max__); - for (size_t d_0__ = 0; d_0__ < ymiss_d_0_max__; ++d_0__) { - if (jacobian__) - ymiss.push_back(in__.scalar_constrain(lp__)); - else - ymiss.push_back(in__.scalar_constrain()); - } - current_statement_begin__ = 197; - std::vector phi; - size_t phi_d_0_max__ = (est_phi * K); - phi.reserve(phi_d_0_max__); - for (size_t d_0__ = 0; d_0__ < phi_d_0_max__; ++d_0__) { - if (jacobian__) - phi.push_back(in__.scalar_lub_constrain(-(1), 1, lp__)); - else - phi.push_back(in__.scalar_lub_constrain(-(1), 1)); - } - current_statement_begin__ = 198; - std::vector theta; - size_t theta_d_0_max__ = (est_theta * K); - theta.reserve(theta_d_0_max__); - for (size_t d_0__ = 0; d_0__ < theta_d_0_max__; ++d_0__) { - if (jacobian__) - theta.push_back(in__.scalar_lub_constrain(-(1), 1, lp__)); - else - theta.push_back(in__.scalar_lub_constrain(-(1), 1)); - } - current_statement_begin__ = 199; - std::vector gp_theta; - size_t gp_theta_d_0_max__ = (est_gp * K); - gp_theta.reserve(gp_theta_d_0_max__); - for (size_t d_0__ = 0; d_0__ < gp_theta_d_0_max__; ++d_0__) { - if (jacobian__) - gp_theta.push_back(in__.scalar_lb_constrain(0, lp__)); - else - gp_theta.push_back(in__.scalar_lb_constrain(0)); - } - current_statement_begin__ = 200; - Eigen::Matrix Lcorr; - (void) Lcorr; // dummy to suppress unused var warning - if (jacobian__) - Lcorr = in__.cholesky_factor_corr_constrain(n_pcor, lp__); - else - Lcorr = in__.cholesky_factor_corr_constrain(n_pcor); - current_statement_begin__ = 201; - std::vector sigma_process; - size_t sigma_process_d_0_max__ = (est_sigma_process * n_sigma_process); - sigma_process.reserve(sigma_process_d_0_max__); - for (size_t d_0__ = 0; d_0__ < sigma_process_d_0_max__; ++d_0__) { - if (jacobian__) - sigma_process.push_back(in__.scalar_lb_constrain(0, lp__)); - else - sigma_process.push_back(in__.scalar_lb_constrain(0)); - } - current_statement_begin__ = 202; - std::vector > effectsKnots; - size_t effectsKnots_d_0_max__ = (K * est_gp); - effectsKnots.reserve(effectsKnots_d_0_max__); - for (size_t d_0__ = 0; d_0__ < effectsKnots_d_0_max__; ++d_0__) { - if (jacobian__) - effectsKnots.push_back(in__.vector_constrain((n_knots * est_gp), lp__)); - else - effectsKnots.push_back(in__.vector_constrain((n_knots * est_gp))); - } - // transformed parameters - current_statement_begin__ = 205; - validate_non_negative_index("pred", "P", P); - validate_non_negative_index("pred", "N", N); - Eigen::Matrix pred(P, N); - stan::math::initialize(pred, DUMMY_VAR__); - stan::math::fill(pred, DUMMY_VAR__); - current_statement_begin__ = 206; - validate_non_negative_index("Z", "P", P); - validate_non_negative_index("Z", "K", K); - Eigen::Matrix Z(P, K); - stan::math::initialize(Z, DUMMY_VAR__); - stan::math::fill(Z, DUMMY_VAR__); - current_statement_begin__ = 207; - validate_non_negative_index("yall", "P", P); - validate_non_negative_index("yall", "N", N); - Eigen::Matrix yall(P, N); - stan::math::initialize(yall, DUMMY_VAR__); - stan::math::fill(yall, DUMMY_VAR__); - current_statement_begin__ = 208; - validate_non_negative_index("sigma_vec", "(P * est_sigma_params)", (P * est_sigma_params)); - Eigen::Matrix sigma_vec((P * est_sigma_params)); - stan::math::initialize(sigma_vec, DUMMY_VAR__); - stan::math::fill(sigma_vec, DUMMY_VAR__); - current_statement_begin__ = 209; - validate_non_negative_index("gamma_a_vec", "(P * est_gamma_params)", (P * est_gamma_params)); - Eigen::Matrix gamma_a_vec((P * est_gamma_params)); - stan::math::initialize(gamma_a_vec, DUMMY_VAR__); - stan::math::fill(gamma_a_vec, DUMMY_VAR__); - current_statement_begin__ = 210; - validate_non_negative_index("nb_phi_vec", "(P * est_nb2_params)", (P * est_nb2_params)); - Eigen::Matrix nb_phi_vec((P * est_nb2_params)); - stan::math::initialize(nb_phi_vec, DUMMY_VAR__); - stan::math::fill(nb_phi_vec, DUMMY_VAR__); - current_statement_begin__ = 211; - validate_non_negative_index("phi_vec", "K", K); - Eigen::Matrix phi_vec(K); - stan::math::initialize(phi_vec, DUMMY_VAR__); - stan::math::fill(phi_vec, DUMMY_VAR__); - current_statement_begin__ = 212; - validate_non_negative_index("theta_vec", "K", K); - Eigen::Matrix theta_vec(K); - stan::math::initialize(theta_vec, DUMMY_VAR__); - stan::math::fill(theta_vec, DUMMY_VAR__); - current_statement_begin__ = 213; - validate_non_negative_index("x", "K", K); - validate_non_negative_index("x", "N", N); - Eigen::Matrix x(K, N); - stan::math::initialize(x, DUMMY_VAR__); - stan::math::fill(x, DUMMY_VAR__); - current_statement_begin__ = 214; - validate_non_negative_index("indicator", "K", K); - Eigen::Matrix indicator(K); - stan::math::initialize(indicator, DUMMY_VAR__); - stan::math::fill(indicator, DUMMY_VAR__); - current_statement_begin__ = 215; - validate_non_negative_index("psi_root", "(K * use_expansion_prior)", (K * use_expansion_prior)); - Eigen::Matrix psi_root((K * use_expansion_prior)); - stan::math::initialize(psi_root, DUMMY_VAR__); - stan::math::fill(psi_root, DUMMY_VAR__); - current_statement_begin__ = 216; - validate_non_negative_index("Sigma_derived", "((n_pcor * long_format) * est_cor)", ((n_pcor * long_format) * est_cor)); - validate_non_negative_index("Sigma_derived", "((n_pcor * long_format) * est_cor)", ((n_pcor * long_format) * est_cor)); - Eigen::Matrix Sigma_derived(((n_pcor * long_format) * est_cor), ((n_pcor * long_format) * est_cor)); - stan::math::initialize(Sigma_derived, DUMMY_VAR__); - stan::math::fill(Sigma_derived, DUMMY_VAR__); - current_statement_begin__ = 217; - validate_non_negative_index("Sigma_temp", "(((n_pcor - 1) * long_format) * est_cor)", (((n_pcor - 1) * long_format) * est_cor)); - validate_non_negative_index("Sigma_temp", "(((n_pcor - 1) * long_format) * est_cor)", (((n_pcor - 1) * long_format) * est_cor)); - Eigen::Matrix Sigma_temp((((n_pcor - 1) * long_format) * est_cor), (((n_pcor - 1) * long_format) * est_cor)); - stan::math::initialize(Sigma_temp, DUMMY_VAR__); - stan::math::fill(Sigma_temp, DUMMY_VAR__); - current_statement_begin__ = 218; - validate_non_negative_index("sigma12_vec", "(n_pcor - 1)", (n_pcor - 1)); - validate_non_negative_index("sigma12_vec", "1", 1); - Eigen::Matrix sigma12_vec((n_pcor - 1), 1); - stan::math::initialize(sigma12_vec, DUMMY_VAR__); - stan::math::fill(sigma12_vec, DUMMY_VAR__); - current_statement_begin__ = 219; - validate_non_negative_index("temp_sums", "((P * long_format) * est_cor)", ((P * long_format) * est_cor)); - validate_non_negative_index("temp_sums", "((N * long_format) * est_cor)", ((N * long_format) * est_cor)); - Eigen::Matrix temp_sums(((P * long_format) * est_cor), ((N * long_format) * est_cor)); - stan::math::initialize(temp_sums, DUMMY_VAR__); - stan::math::fill(temp_sums, DUMMY_VAR__); - current_statement_begin__ = 220; - validate_non_negative_index("temp_counts", "((P * long_format) * est_cor)", ((P * long_format) * est_cor)); - validate_non_negative_index("temp_counts", "((N * long_format) * est_cor)", ((N * long_format) * est_cor)); - Eigen::Matrix temp_counts(((P * long_format) * est_cor), ((N * long_format) * est_cor)); - stan::math::initialize(temp_counts, DUMMY_VAR__); - stan::math::fill(temp_counts, DUMMY_VAR__); - current_statement_begin__ = 221; - validate_non_negative_index("cond_sigma_vec", "((P * long_format) * est_cor)", ((P * long_format) * est_cor)); - Eigen::Matrix cond_sigma_vec(((P * long_format) * est_cor)); - stan::math::initialize(cond_sigma_vec, DUMMY_VAR__); - stan::math::fill(cond_sigma_vec, DUMMY_VAR__); - current_statement_begin__ = 222; - validate_non_negative_index("cond_mean_vec", "((P * long_format) * est_cor)", ((P * long_format) * est_cor)); - Eigen::Matrix cond_mean_vec(((P * long_format) * est_cor)); - stan::math::initialize(cond_mean_vec, DUMMY_VAR__); - stan::math::fill(cond_mean_vec, DUMMY_VAR__); - current_statement_begin__ = 223; - local_scalar_t__ sigma11; - (void) sigma11; // dummy to suppress unused var warning - stan::math::initialize(sigma11, DUMMY_VAR__); - stan::math::fill(sigma11, DUMMY_VAR__); - current_statement_begin__ = 224; - validate_non_negative_index("sigma_pro", "K", K); - Eigen::Matrix sigma_pro(K); - stan::math::initialize(sigma_pro, DUMMY_VAR__); - stan::math::fill(sigma_pro, DUMMY_VAR__); - current_statement_begin__ = 225; - validate_non_negative_index("spline_a_trans", "(K * est_spline)", (K * est_spline)); - validate_non_negative_index("spline_a_trans", "(n_knots * est_spline)", (n_knots * est_spline)); - Eigen::Matrix spline_a_trans((K * est_spline), (n_knots * est_spline)); - stan::math::initialize(spline_a_trans, DUMMY_VAR__); - stan::math::fill(spline_a_trans, DUMMY_VAR__); - current_statement_begin__ = 226; - validate_non_negative_index("SigmaKnots", "n_knots", n_knots); - validate_non_negative_index("SigmaKnots", "n_knots", n_knots); - validate_non_negative_index("SigmaKnots", "K", K); - std::vector > SigmaKnots(K, Eigen::Matrix(n_knots, n_knots)); - stan::math::initialize(SigmaKnots, DUMMY_VAR__); - stan::math::fill(SigmaKnots, DUMMY_VAR__); - current_statement_begin__ = 229; - validate_non_negative_index("obs_cov_offset", "n_pos", n_pos); - Eigen::Matrix obs_cov_offset(n_pos); - stan::math::initialize(obs_cov_offset, DUMMY_VAR__); - stan::math::fill(obs_cov_offset, DUMMY_VAR__); - // transformed parameters block statements - current_statement_begin__ = 232; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 233; - stan::model::assign(sigma_pro, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - 1, - "assigning variable sigma_pro"); - current_statement_begin__ = 234; - if (as_bool(logical_eq(est_sigma_process, 1))) { - current_statement_begin__ = 235; - if (as_bool(logical_eq(n_sigma_process, 1))) { - current_statement_begin__ = 236; - stan::model::assign(sigma_pro, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - get_base1(sigma_process, 1, "sigma_process", 1), - "assigning variable sigma_pro"); - } else { - current_statement_begin__ = 238; - stan::model::assign(sigma_pro, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - get_base1(sigma_process, k, "sigma_process", 1), - "assigning variable sigma_pro"); - } - } - } - current_statement_begin__ = 244; - if (as_bool(logical_eq(est_phi, 1))) { - current_statement_begin__ = 245; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 245; - stan::model::assign(phi_vec, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - get_base1(phi, k, "phi", 1), - "assigning variable phi_vec"); - } + current_statement__ = 108; + assign(indicator, cons_list(index_uni(k), nil_index_list()), 1, + "assigning variable indicator"); + } + current_statement__ = 113; + assign(psi_root, cons_list(index_uni(k), nil_index_list()), + stan::math::sqrt(psi[(k - 1)]), "assigning variable psi_root"); + current_statement__ = 116; + for (int p = 1; p <= P; ++p) { + current_statement__ = 114; + assign(Z, + cons_list(index_uni(p), + cons_list(index_uni(k), nil_index_list())), + ((rvalue(Z, + cons_list(index_uni(p), + cons_list(index_uni(k), nil_index_list())), "Z") * + indicator[(k - 1)]) * (1 / psi_root[(k - 1)])), + "assigning variable Z");}} + } + current_statement__ = 128; + if (logical_eq(est_rw, 1)) { + current_statement__ = 126; + for (int k = 1; k <= K; ++k) { + current_statement__ = 121; + assign(x, + cons_list(index_uni(k), + cons_list(index_uni(1), nil_index_list())), x0[(k - 1)], + "assigning variable x"); + current_statement__ = 124; + for (int t = 2; t <= N; ++t) { + current_statement__ = 122; + assign(x, + cons_list(index_uni(k), + cons_list(index_uni(t), nil_index_list())), + ((phi_vec[(k - 1)] * + rvalue(x, + cons_list(index_uni(k), + cons_list(index_uni((t - 1)), nil_index_list())), "x")) + + + rvalue(devs, + cons_list(index_uni(k), + cons_list(index_uni((t - 1)), nil_index_list())), + "devs")), "assigning variable x");}} + } + current_statement__ = 136; + if (logical_eq(est_spline, 1)) { + current_statement__ = 130; + for (int k = 1; k <= K; ++k) { + current_statement__ = 129; + assign(spline_a_trans, cons_list(index_uni(k), nil_index_list()), + multiply( + rvalue(spline_a, cons_list(index_uni(k), nil_index_list()), + "spline_a"), sigma_pro[(k - 1)]), + "assigning variable spline_a_trans");} + current_statement__ = 131; + assign(x, nil_index_list(), + multiply(spline_a_trans, transpose(X_spline)), + "assigning variable x"); + current_statement__ = 134; + for (int k = 1; k <= K; ++k) { + current_statement__ = 132; + assign(x, cons_list(index_uni(k), nil_index_list()), + add(x0[(k - 1)], + stan::model::deep_copy( + rvalue(x, cons_list(index_uni(k), nil_index_list()), "x"))), + "assigning variable x");} + } + current_statement__ = 149; + if (logical_eq(est_gp, 1)) { + current_statement__ = 147; + for (int k = 1; k <= K; ++k) { + current_statement__ = 137; + assign(SigmaKnots, cons_list(index_uni(k), nil_index_list()), + cov_exp_quad(knot_locs, sigma_pro[(k - 1)], gp_theta[(k - 1)]), + "assigning variable SigmaKnots"); + current_statement__ = 140; + for (int i = 1; i <= n_knots; ++i) { + current_statement__ = 138; + assign(SigmaKnots, + cons_list(index_uni(k), + cons_list(index_uni(i), + cons_list(index_uni(i), nil_index_list()))), + (rvalue(SigmaKnots, + cons_list(index_uni(k), + cons_list(index_uni(i), + cons_list(index_uni(i), nil_index_list()))), + "SigmaKnots") + gp_delta), "assigning variable SigmaKnots"); + } + current_statement__ = 145; + if (logical_eq(n_knots, N)) { + current_statement__ = 143; + assign(x, cons_list(index_uni(k), nil_index_list()), + to_row_vector( + multiply(cholesky_decompose(SigmaKnots[(k - 1)]), + effectsKnots[(k - 1)])), "assigning variable x"); } else { - current_statement_begin__ = 248; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 248; - stan::model::assign(phi_vec, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - 1, - "assigning variable phi_vec"); - } - } - current_statement_begin__ = 253; - if (as_bool(logical_eq(est_theta, 1))) { - current_statement_begin__ = 254; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 254; - stan::model::assign(theta_vec, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - get_base1(theta, k, "theta", 1), - "assigning variable theta_vec"); - } + current_statement__ = 141; + assign(x, cons_list(index_uni(k), nil_index_list()), + to_row_vector( + multiply( + multiply( + multiply( + cov_exp_quad(data_locs, knot_locs, + sigma_pro[(k - 1)], gp_theta[(k - 1)]), + inverse_spd(SigmaKnots[(k - 1)])), + cholesky_decompose(SigmaKnots[(k - 1)])), + effectsKnots[(k - 1)])), "assigning variable x"); + }} + } + current_statement__ = 154; + if (logical_eq(use_expansion_prior, 1)) { + current_statement__ = 152; + for (int k = 1; k <= K; ++k) { + current_statement__ = 150; + assign(x, cons_list(index_uni(k), nil_index_list()), + multiply( + multiply( + stan::model::deep_copy( + rvalue(x, cons_list(index_uni(k), nil_index_list()), "x")), + indicator[(k - 1)]), psi_root[(k - 1)]), + "assigning variable x");} + } + } + current_statement__ = 190; + if (logical_eq(proportional_model, 1)) { + current_statement__ = 164; + if (logical_eq(est_rw, 1)) { + current_statement__ = 162; + for (int k = 1; k <= K; ++k) { + current_statement__ = 157; + assign(x, + cons_list(index_uni(k), + cons_list(index_uni(1), nil_index_list())), x0[(k - 1)], + "assigning variable x"); + current_statement__ = 160; + for (int t = 2; t <= N; ++t) { + current_statement__ = 158; + assign(x, + cons_list(index_uni(k), + cons_list(index_uni(t), nil_index_list())), + ((phi_vec[(k - 1)] * + rvalue(x, + cons_list(index_uni(k), + cons_list(index_uni((t - 1)), nil_index_list())), "x")) + + + rvalue(devs, + cons_list(index_uni(k), + cons_list(index_uni((t - 1)), nil_index_list())), + "devs")), "assigning variable x");}} + } + current_statement__ = 172; + if (logical_eq(est_spline, 1)) { + current_statement__ = 166; + for (int k = 1; k <= K; ++k) { + current_statement__ = 165; + assign(spline_a_trans, cons_list(index_uni(k), nil_index_list()), + multiply( + rvalue(spline_a, cons_list(index_uni(k), nil_index_list()), + "spline_a"), sigma_pro[(k - 1)]), + "assigning variable spline_a_trans");} + current_statement__ = 167; + assign(x, nil_index_list(), + multiply(spline_a_trans, transpose(X_spline)), + "assigning variable x"); + current_statement__ = 170; + for (int k = 1; k <= K; ++k) { + current_statement__ = 168; + assign(x, cons_list(index_uni(k), nil_index_list()), + add(x0[(k - 1)], + stan::model::deep_copy( + rvalue(x, cons_list(index_uni(k), nil_index_list()), "x"))), + "assigning variable x");} + } + current_statement__ = 185; + if (logical_eq(est_gp, 1)) { + current_statement__ = 183; + for (int k = 1; k <= K; ++k) { + current_statement__ = 173; + assign(SigmaKnots, cons_list(index_uni(k), nil_index_list()), + cov_exp_quad(knot_locs, sigma_pro[(k - 1)], gp_theta[(k - 1)]), + "assigning variable SigmaKnots"); + current_statement__ = 176; + for (int i = 1; i <= n_knots; ++i) { + current_statement__ = 174; + assign(SigmaKnots, + cons_list(index_uni(k), + cons_list(index_uni(i), + cons_list(index_uni(i), nil_index_list()))), + (rvalue(SigmaKnots, + cons_list(index_uni(k), + cons_list(index_uni(i), + cons_list(index_uni(i), nil_index_list()))), + "SigmaKnots") + gp_delta), "assigning variable SigmaKnots"); + } + current_statement__ = 181; + if (logical_eq(n_knots, N)) { + current_statement__ = 179; + assign(x, cons_list(index_uni(k), nil_index_list()), + to_row_vector( + multiply(cholesky_decompose(SigmaKnots[(k - 1)]), + effectsKnots[(k - 1)])), "assigning variable x"); } else { - current_statement_begin__ = 257; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 257; - stan::model::assign(theta_vec, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - 0, - "assigning variable theta_vec"); - } - } - current_statement_begin__ = 261; - if (as_bool(logical_eq(est_sigma_params, 1))) { - current_statement_begin__ = 262; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 262; - stan::model::assign(sigma_vec, - stan::model::cons_list(stan::model::index_uni(p), stan::model::nil_index_list()), - get_base1(sigma, get_base1(varIndx, p, "varIndx", 1), "sigma", 1), - "assigning variable sigma_vec"); - } - } - current_statement_begin__ = 264; - if (as_bool(logical_eq(est_gamma_params, 1))) { - current_statement_begin__ = 265; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 265; - stan::model::assign(gamma_a_vec, - stan::model::cons_list(stan::model::index_uni(p), stan::model::nil_index_list()), - get_base1(gamma_a, get_base1(varIndx, p, "varIndx", 1), "gamma_a", 1), - "assigning variable gamma_a_vec"); - } - } - current_statement_begin__ = 267; - if (as_bool(logical_eq(est_nb2_params, 1))) { - current_statement_begin__ = 268; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 268; - stan::model::assign(nb_phi_vec, - stan::model::cons_list(stan::model::index_uni(p), stan::model::nil_index_list()), - get_base1(nb2_phi, get_base1(varIndx, p, "varIndx", 1), "nb2_phi", 1), - "assigning variable nb_phi_vec"); - } - } - current_statement_begin__ = 271; - if (as_bool(logical_eq(long_format, 0))) { - current_statement_begin__ = 273; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 274; - stan::model::assign(yall, - stan::model::cons_list(stan::model::index_uni(get_base1(row_indx_pos, i, "row_indx_pos", 1)), stan::model::cons_list(stan::model::index_uni(get_base1(col_indx_pos, i, "col_indx_pos", 1)), stan::model::nil_index_list())), - get_base1(y, i, "y", 1), - "assigning variable yall"); - } - current_statement_begin__ = 277; - if (as_bool(logical_gt(n_na, 0))) { - current_statement_begin__ = 278; - for (int i = 1; i <= n_na; ++i) { - current_statement_begin__ = 279; - stan::model::assign(yall, - stan::model::cons_list(stan::model::index_uni(get_base1(row_indx_na, i, "row_indx_na", 1)), stan::model::cons_list(stan::model::index_uni(get_base1(col_indx_na, i, "col_indx_na", 1)), stan::model::nil_index_list())), - get_base1(ymiss, i, "ymiss", 1), - "assigning variable yall"); - } - } - } - current_statement_begin__ = 284; - if (as_bool(logical_eq(proportional_model, 0))) { - current_statement_begin__ = 285; - for (int i = 1; i <= nZ; ++i) { - current_statement_begin__ = 286; - stan::model::assign(Z, - stan::model::cons_list(stan::model::index_uni(get_base1(row_indx, i, "row_indx", 1)), stan::model::cons_list(stan::model::index_uni(get_base1(col_indx, i, "col_indx", 1)), stan::model::nil_index_list())), - get_base1(z, i, "z", 1), - "assigning variable Z"); - } - current_statement_begin__ = 289; - if (as_bool(logical_gt(nZero, 2))) { - current_statement_begin__ = 290; - for (int i = 1; i <= (nZero - 2); ++i) { - current_statement_begin__ = 291; - stan::model::assign(Z, - stan::model::cons_list(stan::model::index_uni(get_base1(row_indx_z, i, "row_indx_z", 1)), stan::model::cons_list(stan::model::index_uni(get_base1(col_indx_z, i, "col_indx_z", 1)), stan::model::nil_index_list())), - 0, - "assigning variable Z"); - } - } - current_statement_begin__ = 294; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 295; - stan::model::assign(Z, - stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list())), - get_base1(zpos, k, "zpos", 1), - "assigning variable Z"); - } - current_statement_begin__ = 298; - if (as_bool(logical_eq(use_expansion_prior, 1))) { - current_statement_begin__ = 299; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 300; - if (as_bool(logical_lt(get_base1(zpos, k, "zpos", 1), 0))) { - current_statement_begin__ = 301; - stan::model::assign(indicator, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - -(1), - "assigning variable indicator"); - } else { - current_statement_begin__ = 303; - stan::model::assign(indicator, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - 1, - "assigning variable indicator"); - } - current_statement_begin__ = 306; - stan::model::assign(psi_root, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - stan::math::sqrt(get_base1(psi, k, "psi", 1)), - "assigning variable psi_root"); - current_statement_begin__ = 307; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 309; - stan::model::assign(Z, - stan::model::cons_list(stan::model::index_uni(p), stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list())), - ((get_base1(Z, p, k, "Z", 1) * get_base1(indicator, k, "indicator", 1)) * (1 / get_base1(psi_root, k, "psi_root", 1))), - "assigning variable Z"); - } - } - } - current_statement_begin__ = 315; - if (as_bool(logical_eq(est_rw, 1))) { - current_statement_begin__ = 316; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 317; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(1), stan::model::nil_index_list())), - get_base1(x0, k, "x0", 1), - "assigning variable x"); - current_statement_begin__ = 321; - for (int t = 2; t <= N; ++t) { - current_statement_begin__ = 322; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(t), stan::model::nil_index_list())), - ((get_base1(phi_vec, k, "phi_vec", 1) * get_base1(x, k, (t - 1), "x", 1)) + get_base1(devs, k, (t - 1), "devs", 1)), - "assigning variable x"); - } - } - } - current_statement_begin__ = 326; - if (as_bool(logical_eq(est_spline, 1))) { - current_statement_begin__ = 329; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 329; - stan::model::assign(spline_a_trans, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - multiply(get_base1(spline_a, k, "spline_a", 1), get_base1(sigma_pro, k, "sigma_pro", 1)), - "assigning variable spline_a_trans"); - } - current_statement_begin__ = 330; - stan::math::assign(x, multiply(spline_a_trans, transpose(X_spline))); - current_statement_begin__ = 331; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 331; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - add(get_base1(x0, k, "x0", 1), get_base1(x, k, "x", 1)), - "assigning variable x"); - } - } - current_statement_begin__ = 333; - if (as_bool(logical_eq(est_gp, 1))) { - current_statement_begin__ = 335; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 336; - stan::model::assign(SigmaKnots, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - cov_exp_quad(knot_locs, get_base1(sigma_pro, k, "sigma_pro", 1), get_base1(gp_theta, k, "gp_theta", 1)), - "assigning variable SigmaKnots"); - current_statement_begin__ = 339; - for (int i = 1; i <= n_knots; ++i) { - current_statement_begin__ = 340; - stan::model::assign(SigmaKnots, - stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(i), stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()))), - (stan::model::rvalue(SigmaKnots, stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(i), stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()))), "SigmaKnots") + gp_delta), - "assigning variable SigmaKnots"); - } - current_statement_begin__ = 349; - if (as_bool(logical_eq(n_knots, N))) { - current_statement_begin__ = 351; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - to_row_vector(multiply(cholesky_decompose(get_base1(SigmaKnots, k, "SigmaKnots", 1)), get_base1(effectsKnots, k, "effectsKnots", 1))), - "assigning variable x"); - } else { - current_statement_begin__ = 353; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - to_row_vector(multiply(multiply(multiply(cov_exp_quad(data_locs, knot_locs, get_base1(sigma_pro, k, "sigma_pro", 1), get_base1(gp_theta, k, "gp_theta", 1)), inverse_spd(get_base1(SigmaKnots, k, "SigmaKnots", 1))), cholesky_decompose(get_base1(SigmaKnots, k, "SigmaKnots", 1))), get_base1(effectsKnots, k, "effectsKnots", 1))), - "assigning variable x"); - } - } - } - current_statement_begin__ = 359; - if (as_bool(logical_eq(use_expansion_prior, 1))) { - current_statement_begin__ = 360; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 363; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - multiply(multiply(get_base1(x, k, "x", 1), get_base1(indicator, k, "indicator", 1)), get_base1(psi_root, k, "psi_root", 1)), - "assigning variable x"); - } - } - } - current_statement_begin__ = 368; - if (as_bool(logical_eq(proportional_model, 1))) { - current_statement_begin__ = 370; - if (as_bool(logical_eq(est_rw, 1))) { - current_statement_begin__ = 371; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 372; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(1), stan::model::nil_index_list())), - get_base1(x0, k, "x0", 1), - "assigning variable x"); - current_statement_begin__ = 376; - for (int t = 2; t <= N; ++t) { - current_statement_begin__ = 377; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(t), stan::model::nil_index_list())), - ((get_base1(phi_vec, k, "phi_vec", 1) * get_base1(x, k, (t - 1), "x", 1)) + get_base1(devs, k, (t - 1), "devs", 1)), - "assigning variable x"); - } - } - } - current_statement_begin__ = 381; - if (as_bool(logical_eq(est_spline, 1))) { - current_statement_begin__ = 382; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 382; - stan::model::assign(spline_a_trans, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - multiply(get_base1(spline_a, k, "spline_a", 1), get_base1(sigma_pro, k, "sigma_pro", 1)), - "assigning variable spline_a_trans"); - } - current_statement_begin__ = 383; - stan::math::assign(x, multiply(spline_a_trans, transpose(X_spline))); - current_statement_begin__ = 384; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 384; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - add(get_base1(x0, k, "x0", 1), get_base1(x, k, "x", 1)), - "assigning variable x"); - } - } - current_statement_begin__ = 386; - if (as_bool(logical_eq(est_gp, 1))) { - current_statement_begin__ = 387; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 388; - stan::model::assign(SigmaKnots, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - cov_exp_quad(knot_locs, get_base1(sigma_pro, k, "sigma_pro", 1), get_base1(gp_theta, k, "gp_theta", 1)), - "assigning variable SigmaKnots"); - current_statement_begin__ = 391; - for (int i = 1; i <= n_knots; ++i) { - current_statement_begin__ = 392; - stan::model::assign(SigmaKnots, - stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(i), stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()))), - (stan::model::rvalue(SigmaKnots, stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(i), stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()))), "SigmaKnots") + gp_delta), - "assigning variable SigmaKnots"); - } - current_statement_begin__ = 401; - if (as_bool(logical_eq(n_knots, N))) { - current_statement_begin__ = 403; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - to_row_vector(multiply(cholesky_decompose(get_base1(SigmaKnots, k, "SigmaKnots", 1)), get_base1(effectsKnots, k, "effectsKnots", 1))), - "assigning variable x"); - } else { - current_statement_begin__ = 405; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - to_row_vector(multiply(multiply(multiply(cov_exp_quad(data_locs, knot_locs, get_base1(sigma_pro, k, "sigma_pro", 1), get_base1(gp_theta, k, "gp_theta", 1)), inverse_spd(get_base1(SigmaKnots, k, "SigmaKnots", 1))), cholesky_decompose(get_base1(SigmaKnots, k, "SigmaKnots", 1))), get_base1(effectsKnots, k, "effectsKnots", 1))), - "assigning variable x"); - } - } - } - current_statement_begin__ = 411; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 415; - stan::model::assign(Z, - stan::model::cons_list(stan::model::index_uni(p), stan::model::nil_index_list()), - to_row_vector(get_base1(p_z, p, "p_z", 1)), - "assigning variable Z"); - } - } - current_statement_begin__ = 420; - if (as_bool(logical_gt(num_pro_covar, 0))) { - current_statement_begin__ = 421; - for (int i = 1; i <= num_pro_covar; ++i) { - current_statement_begin__ = 423; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(get_base1(get_base1(pro_covar_index, i, "pro_covar_index", 1), 2, "pro_covar_index", 2)), stan::model::cons_list(stan::model::index_uni(get_base1(get_base1(pro_covar_index, i, "pro_covar_index", 1), 1, "pro_covar_index", 2)), stan::model::nil_index_list())), - (stan::model::rvalue(x, stan::model::cons_list(stan::model::index_uni(get_base1(get_base1(pro_covar_index, i, "pro_covar_index", 1), 2, "pro_covar_index", 2)), stan::model::cons_list(stan::model::index_uni(get_base1(get_base1(pro_covar_index, i, "pro_covar_index", 1), 1, "pro_covar_index", 2)), stan::model::nil_index_list())), "x") + (get_base1(b_pro, get_base1(get_base1(pro_covar_index, i, "pro_covar_index", 1), 3, "pro_covar_index", 2), get_base1(get_base1(pro_covar_index, i, "pro_covar_index", 1), 2, "pro_covar_index", 2), "b_pro", 1) * get_base1(pro_covar_value, i, "pro_covar_value", 1))), - "assigning variable x"); - } - } - current_statement_begin__ = 429; - stan::math::assign(pred, multiply(Z, x)); - current_statement_begin__ = 432; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 433; - stan::model::assign(obs_cov_offset, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - 0, - "assigning variable obs_cov_offset"); - } - current_statement_begin__ = 436; - if (as_bool(logical_gt(num_obs_covar, 0))) { - current_statement_begin__ = 437; - if (as_bool(logical_eq(long_format, 0))) { - current_statement_begin__ = 438; - for (int i = 1; i <= num_obs_covar; ++i) { - current_statement_begin__ = 441; - stan::model::assign(pred, - stan::model::cons_list(stan::model::index_uni(get_base1(get_base1(obs_covar_index, i, "obs_covar_index", 1), 2, "obs_covar_index", 2)), stan::model::cons_list(stan::model::index_uni(get_base1(get_base1(obs_covar_index, i, "obs_covar_index", 1), 1, "obs_covar_index", 2)), stan::model::nil_index_list())), - (stan::model::rvalue(pred, stan::model::cons_list(stan::model::index_uni(get_base1(get_base1(obs_covar_index, i, "obs_covar_index", 1), 2, "obs_covar_index", 2)), stan::model::cons_list(stan::model::index_uni(get_base1(get_base1(obs_covar_index, i, "obs_covar_index", 1), 1, "obs_covar_index", 2)), stan::model::nil_index_list())), "pred") + (get_base1(b_obs, get_base1(get_base1(obs_covar_index, i, "obs_covar_index", 1), 3, "obs_covar_index", 2), get_base1(get_base1(obs_covar_index, i, "obs_covar_index", 1), 2, "obs_covar_index", 2), "b_obs", 1) * get_base1(obs_covar_value, i, "obs_covar_value", 1))), - "assigning variable pred"); - } + current_statement__ = 177; + assign(x, cons_list(index_uni(k), nil_index_list()), + to_row_vector( + multiply( + multiply( + multiply( + cov_exp_quad(data_locs, knot_locs, + sigma_pro[(k - 1)], gp_theta[(k - 1)]), + inverse_spd(SigmaKnots[(k - 1)])), + cholesky_decompose(SigmaKnots[(k - 1)])), + effectsKnots[(k - 1)])), "assigning variable x"); + }} + } + current_statement__ = 188; + for (int p = 1; p <= P; ++p) { + current_statement__ = 186; + assign(Z, cons_list(index_uni(p), nil_index_list()), + to_row_vector(p_z[(p - 1)]), "assigning variable Z");} + } + current_statement__ = 195; + if (logical_gt(num_pro_covar, 0)) { + current_statement__ = 193; + for (int i = 1; i <= num_pro_covar; ++i) { + current_statement__ = 191; + assign(x, + cons_list(index_uni(pro_covar_index[(i - 1)][(2 - 1)]), + cons_list(index_uni(pro_covar_index[(i - 1)][(1 - 1)]), + nil_index_list())), + (rvalue(x, + cons_list(index_uni(pro_covar_index[(i - 1)][(2 - 1)]), + cons_list(index_uni(pro_covar_index[(i - 1)][(1 - 1)]), + nil_index_list())), "x") + + (rvalue(b_pro, + cons_list(index_uni(pro_covar_index[(i - 1)][(3 - 1)]), + cons_list(index_uni(pro_covar_index[(i - 1)][(2 - 1)]), + nil_index_list())), "b_pro") * pro_covar_value[(i - 1)])), + "assigning variable x");} + } + current_statement__ = 196; + assign(pred, nil_index_list(), multiply(Z, x), + "assigning variable pred"); + current_statement__ = 199; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 197; + assign(obs_cov_offset, cons_list(index_uni(i), nil_index_list()), 0, + "assigning variable obs_cov_offset");} + current_statement__ = 210; + if (logical_gt(num_obs_covar, 0)) { + current_statement__ = 208; + if (logical_eq(long_format, 0)) { + current_statement__ = 206; + for (int i = 1; i <= num_obs_covar; ++i) { + current_statement__ = 204; + assign(pred, + cons_list(index_uni(obs_covar_index[(i - 1)][(2 - 1)]), + cons_list(index_uni(obs_covar_index[(i - 1)][(1 - 1)]), + nil_index_list())), + (rvalue(pred, + cons_list(index_uni(obs_covar_index[(i - 1)][(2 - 1)]), + cons_list(index_uni(obs_covar_index[(i - 1)][(1 - 1)]), + nil_index_list())), "pred") + + (rvalue(b_obs, + cons_list(index_uni(obs_covar_index[(i - 1)][(3 - 1)]), + cons_list(index_uni(obs_covar_index[(i - 1)][(2 - 1)]), + nil_index_list())), "b_obs") * + obs_covar_value[(i - 1)])), "assigning variable pred");} + } else { + current_statement__ = 202; + for (int i = 1; i <= num_obs_covar; ++i) { + current_statement__ = 200; + assign(obs_cov_offset, + cons_list(index_uni(match_obs_covar[(i - 1)]), + nil_index_list()), + (obs_cov_offset[(match_obs_covar[(i - 1)] - 1)] + + (rvalue(b_obs, + cons_list(index_uni(obs_covar_index[(i - 1)][(3 - 1)]), + cons_list(index_uni(obs_covar_index[(i - 1)][(2 - 1)]), + nil_index_list())), "b_obs") * + obs_covar_value[(i - 1)])), + "assigning variable obs_cov_offset");} + } + } + current_statement__ = 235; + if ((primitive_value(logical_eq(long_format, 1)) && primitive_value( + logical_eq(est_cor, 1)))) { + current_statement__ = 216; + for (int n = 1; n <= N; ++n) { + current_statement__ = 214; + for (int p = 1; p <= P; ++p) { + current_statement__ = 211; + assign(temp_sums, + cons_list(index_uni(p), + cons_list(index_uni(n), nil_index_list())), 0.0, + "assigning variable temp_sums"); + current_statement__ = 212; + assign(temp_counts, + cons_list(index_uni(p), + cons_list(index_uni(n), nil_index_list())), 0.0, + "assigning variable temp_counts");}} + current_statement__ = 220; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 217; + assign(temp_sums, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), nil_index_list())), + (rvalue(temp_sums, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "temp_sums") + + (y[(i - 1)] - + rvalue(pred, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "pred"))), + "assigning variable temp_sums"); + current_statement__ = 218; + assign(temp_counts, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), nil_index_list())), + (rvalue(temp_counts, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "temp_counts") + 1), + "assigning variable temp_counts");} + current_statement__ = 225; + for (int n = 1; n <= N; ++n) { + current_statement__ = 223; + for (int p = 1; p <= P; ++p) { + current_statement__ = 221; + assign(temp_sums, + cons_list(index_uni(p), + cons_list(index_uni(n), nil_index_list())), + (rvalue(temp_sums, + cons_list(index_uni(p), + cons_list(index_uni(n), nil_index_list())), "temp_sums") / + rvalue(temp_counts, + cons_list(index_uni(p), + cons_list(index_uni(n), nil_index_list())), + "temp_counts")), "assigning variable temp_sums");}} + current_statement__ = 226; + assign(Sigma_derived, nil_index_list(), + quad_form_diag(multiply_lower_tri_self_transpose(Lcorr), sigma_vec), + "assigning variable Sigma_derived"); + current_statement__ = 233; + for (int p = 1; p <= P; ++p) { + current_statement__ = 227; + sigma11 = rvalue(Sigma_derived, + cons_list(index_uni(p), + cons_list(index_uni(p), nil_index_list())), + "Sigma_derived"); + current_statement__ = 228; + assign(Sigma_temp, nil_index_list(), + inverse(subset(Sigma_derived, p, P, pstream__)), + "assigning variable Sigma_temp"); + current_statement__ = 229; + assign(sigma12_vec, nil_index_list(), + subsetvec(Sigma_derived, p, P, pstream__), + "assigning variable sigma12_vec"); + current_statement__ = 230; + assign(cond_mean_vec, cons_list(index_uni(p), nil_index_list()), + multiply(multiply(to_row_vector(sigma12_vec), Sigma_temp), + to_vector(subsetvec2(col(temp_sums, p), p, P, pstream__))), + "assigning variable cond_mean_vec"); + current_statement__ = 231; + assign(cond_sigma_vec, cons_list(index_uni(p), nil_index_list()), + stan::math::sqrt( + (sigma11 - + multiply(multiply(to_row_vector(sigma12_vec), Sigma_temp), + to_vector(sigma12_vec)))), + "assigning variable cond_sigma_vec");} + } + current_statement__ = 24; + for (int sym1__ = 1; sym1__ <= sigma_vec_1dim__; ++sym1__) { + current_statement__ = 24; + current_statement__ = 24; + check_greater_or_equal(function__, "sigma_vec[sym1__]", + sigma_vec[(sym1__ - 1)], 0);} + current_statement__ = 25; + for (int sym1__ = 1; sym1__ <= gamma_a_vec_1dim__; ++sym1__) { + current_statement__ = 25; + current_statement__ = 25; + check_greater_or_equal(function__, "gamma_a_vec[sym1__]", + gamma_a_vec[(sym1__ - 1)], 0);} + current_statement__ = 26; + for (int sym1__ = 1; sym1__ <= nb_phi_vec_1dim__; ++sym1__) { + current_statement__ = 26; + current_statement__ = 26; + check_greater_or_equal(function__, "nb_phi_vec[sym1__]", + nb_phi_vec[(sym1__ - 1)], 0);} + current_statement__ = 31; + for (int sym1__ = 1; sym1__ <= psi_root_1dim__; ++sym1__) { + current_statement__ = 31; + current_statement__ = 31; + check_greater_or_equal(function__, "psi_root[sym1__]", + psi_root[(sym1__ - 1)], 0);} + { + current_statement__ = 327; + lp_accum__.add(normal_lpdf(x0, 0, 1)); + current_statement__ = 330; + if (logical_eq(use_expansion_prior, 1)) { + current_statement__ = 328; + lp_accum__.add(gamma_lpdf(psi, 2, 1)); + } + current_statement__ = 333; + if (logical_eq(estimate_nu, 1)) { + current_statement__ = 331; + lp_accum__.add(gamma_lpdf(nu[(1 - 1)], 2, 0.1)); + } + current_statement__ = 336; + if (logical_eq(est_phi, 1)) { + current_statement__ = 334; + lp_accum__.add(normal_lpdf(phi, 0, 1)); + } + current_statement__ = 339; + if (logical_eq(est_theta, 1)) { + current_statement__ = 337; + lp_accum__.add(normal_lpdf(theta, 0, 1)); + } + current_statement__ = 342; + if (est_sigma_process) { + current_statement__ = 340; + lp_accum__.add(normal_lpdf(sigma_process, 0, 1)); + } + current_statement__ = 344; + if (logical_eq(est_sigma_params, 1)) { + current_statement__ = 343; + lp_accum__.add(student_t_lpdf(sigma, 3, 0, 1)); + } + current_statement__ = 346; + if (logical_eq(est_gamma_params, 1)) { + current_statement__ = 345; + lp_accum__.add(student_t_lpdf(gamma_a, 3, 0, 1)); + } + current_statement__ = 348; + if (logical_eq(est_nb2_params, 1)) { + current_statement__ = 347; + lp_accum__.add(student_t_lpdf(nb2_phi, 3, 0, 1)); + } + current_statement__ = 351; + if (logical_eq(est_cor, 1)) { + current_statement__ = 349; + lp_accum__.add(lkj_corr_cholesky_lpdf(Lcorr, 1)); + } + current_statement__ = 357; + if (logical_eq(est_gp, 1)) { + current_statement__ = 352; + lp_accum__.add( + inv_gamma_lpdf(gp_theta, gp_theta_prior[(1 - 1)], + gp_theta_prior[(2 - 1)])); + current_statement__ = 355; + for (int k = 1; k <= K; ++k) { + current_statement__ = 353; + lp_accum__.add(std_normal_lpdf(effectsKnots[(k - 1)])); + } + } + current_statement__ = 382; + if (logical_eq(est_rw, 1)) { + current_statement__ = 380; + for (int k = 1; k <= K; ++k) { + current_statement__ = 378; + if (logical_eq(use_normal, 0)) { + current_statement__ = 369; + for (int t = 1; t <= 1; ++t) { + current_statement__ = 367; + if (logical_eq(estimate_nu, 1)) { + current_statement__ = 365; + lp_accum__.add( + student_t_lpdf( + rvalue(devs, + cons_list(index_uni(k), + cons_list(index_uni(t), nil_index_list())), "devs"), + nu[(1 - 1)], 0, sigma_pro[(k - 1)])); } else { - current_statement_begin__ = 446; - for (int i = 1; i <= num_obs_covar; ++i) { - current_statement_begin__ = 447; - stan::model::assign(obs_cov_offset, - stan::model::cons_list(stan::model::index_uni(get_base1(match_obs_covar, i, "match_obs_covar", 1)), stan::model::nil_index_list()), - (stan::model::rvalue(obs_cov_offset, stan::model::cons_list(stan::model::index_uni(get_base1(match_obs_covar, i, "match_obs_covar", 1)), stan::model::nil_index_list()), "obs_cov_offset") + (get_base1(b_obs, get_base1(get_base1(obs_covar_index, i, "obs_covar_index", 1), 3, "obs_covar_index", 2), get_base1(get_base1(obs_covar_index, i, "obs_covar_index", 1), 2, "obs_covar_index", 2), "b_obs", 1) * get_base1(obs_covar_value, i, "obs_covar_value", 1))), - "assigning variable obs_cov_offset"); - } - } - } - current_statement_begin__ = 452; - if (as_bool((primitive_value(logical_eq(long_format, 1)) && primitive_value(logical_eq(est_cor, 1))))) { - current_statement_begin__ = 454; - for (int n = 1; n <= N; ++n) { - current_statement_begin__ = 455; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 456; - stan::model::assign(temp_sums, - stan::model::cons_list(stan::model::index_uni(p), stan::model::cons_list(stan::model::index_uni(n), stan::model::nil_index_list())), - 0.0, - "assigning variable temp_sums"); - current_statement_begin__ = 457; - stan::model::assign(temp_counts, - stan::model::cons_list(stan::model::index_uni(p), stan::model::cons_list(stan::model::index_uni(n), stan::model::nil_index_list())), - 0.0, - "assigning variable temp_counts"); - } - } - current_statement_begin__ = 460; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 461; - stan::model::assign(temp_sums, - stan::model::cons_list(stan::model::index_uni(get_base1(row_indx_pos, i, "row_indx_pos", 1)), stan::model::cons_list(stan::model::index_uni(get_base1(col_indx_pos, i, "col_indx_pos", 1)), stan::model::nil_index_list())), - (stan::model::rvalue(temp_sums, stan::model::cons_list(stan::model::index_uni(get_base1(row_indx_pos, i, "row_indx_pos", 1)), stan::model::cons_list(stan::model::index_uni(get_base1(col_indx_pos, i, "col_indx_pos", 1)), stan::model::nil_index_list())), "temp_sums") + (get_base1(y, i, "y", 1) - get_base1(pred, get_base1(row_indx_pos, i, "row_indx_pos", 1), get_base1(col_indx_pos, i, "col_indx_pos", 1), "pred", 1))), - "assigning variable temp_sums"); - current_statement_begin__ = 462; - stan::model::assign(temp_counts, - stan::model::cons_list(stan::model::index_uni(get_base1(row_indx_pos, i, "row_indx_pos", 1)), stan::model::cons_list(stan::model::index_uni(get_base1(col_indx_pos, i, "col_indx_pos", 1)), stan::model::nil_index_list())), - (stan::model::rvalue(temp_counts, stan::model::cons_list(stan::model::index_uni(get_base1(row_indx_pos, i, "row_indx_pos", 1)), stan::model::cons_list(stan::model::index_uni(get_base1(col_indx_pos, i, "col_indx_pos", 1)), stan::model::nil_index_list())), "temp_counts") + 1), - "assigning variable temp_counts"); - } - current_statement_begin__ = 464; - for (int n = 1; n <= N; ++n) { - current_statement_begin__ = 465; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 467; - stan::model::assign(temp_sums, - stan::model::cons_list(stan::model::index_uni(p), stan::model::cons_list(stan::model::index_uni(n), stan::model::nil_index_list())), - (get_base1(temp_sums, p, n, "temp_sums", 1) / get_base1(temp_counts, p, n, "temp_counts", 1)), - "assigning variable temp_sums"); - } - } - current_statement_begin__ = 471; - stan::math::assign(Sigma_derived, quad_form_diag(multiply_lower_tri_self_transpose(Lcorr), sigma_vec)); - current_statement_begin__ = 473; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 474; - stan::math::assign(sigma11, get_base1(Sigma_derived, p, p, "Sigma_derived", 1)); - current_statement_begin__ = 475; - stan::math::assign(Sigma_temp, inverse(subset(Sigma_derived, p, P, pstream__))); - current_statement_begin__ = 476; - stan::math::assign(sigma12_vec, subsetvec(Sigma_derived, p, P, pstream__)); - current_statement_begin__ = 478; - stan::model::assign(cond_mean_vec, - stan::model::cons_list(stan::model::index_uni(p), stan::model::nil_index_list()), - multiply(multiply(to_row_vector(sigma12_vec), Sigma_temp), to_vector(subsetvec2(col(temp_sums, p), p, P, pstream__))), - "assigning variable cond_mean_vec"); - current_statement_begin__ = 480; - stan::model::assign(cond_sigma_vec, - stan::model::cons_list(stan::model::index_uni(p), stan::model::nil_index_list()), - stan::math::sqrt((sigma11 - multiply(multiply(to_row_vector(sigma12_vec), Sigma_temp), to_vector(sigma12_vec)))), - "assigning variable cond_sigma_vec"); - } - } - // validate transformed parameters - const char* function__ = "validate transformed params"; - (void) function__; // dummy to suppress unused var warning - current_statement_begin__ = 205; - size_t pred_j_1_max__ = P; - size_t pred_j_2_max__ = N; - for (size_t j_1__ = 0; j_1__ < pred_j_1_max__; ++j_1__) { - for (size_t j_2__ = 0; j_2__ < pred_j_2_max__; ++j_2__) { - if (stan::math::is_uninitialized(pred(j_1__, j_2__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: pred" << "(" << j_1__ << ", " << j_2__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable pred: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - } - current_statement_begin__ = 206; - size_t Z_j_1_max__ = P; - size_t Z_j_2_max__ = K; - for (size_t j_1__ = 0; j_1__ < Z_j_1_max__; ++j_1__) { - for (size_t j_2__ = 0; j_2__ < Z_j_2_max__; ++j_2__) { - if (stan::math::is_uninitialized(Z(j_1__, j_2__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: Z" << "(" << j_1__ << ", " << j_2__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable Z: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - } - current_statement_begin__ = 207; - size_t yall_j_1_max__ = P; - size_t yall_j_2_max__ = N; - for (size_t j_1__ = 0; j_1__ < yall_j_1_max__; ++j_1__) { - for (size_t j_2__ = 0; j_2__ < yall_j_2_max__; ++j_2__) { - if (stan::math::is_uninitialized(yall(j_1__, j_2__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: yall" << "(" << j_1__ << ", " << j_2__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable yall: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - } - current_statement_begin__ = 208; - size_t sigma_vec_j_1_max__ = (P * est_sigma_params); - for (size_t j_1__ = 0; j_1__ < sigma_vec_j_1_max__; ++j_1__) { - if (stan::math::is_uninitialized(sigma_vec(j_1__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: sigma_vec" << "(" << j_1__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable sigma_vec: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - check_greater_or_equal(function__, "sigma_vec", sigma_vec, 0); - current_statement_begin__ = 209; - size_t gamma_a_vec_j_1_max__ = (P * est_gamma_params); - for (size_t j_1__ = 0; j_1__ < gamma_a_vec_j_1_max__; ++j_1__) { - if (stan::math::is_uninitialized(gamma_a_vec(j_1__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: gamma_a_vec" << "(" << j_1__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable gamma_a_vec: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - check_greater_or_equal(function__, "gamma_a_vec", gamma_a_vec, 0); - current_statement_begin__ = 210; - size_t nb_phi_vec_j_1_max__ = (P * est_nb2_params); - for (size_t j_1__ = 0; j_1__ < nb_phi_vec_j_1_max__; ++j_1__) { - if (stan::math::is_uninitialized(nb_phi_vec(j_1__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: nb_phi_vec" << "(" << j_1__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable nb_phi_vec: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - check_greater_or_equal(function__, "nb_phi_vec", nb_phi_vec, 0); - current_statement_begin__ = 211; - size_t phi_vec_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < phi_vec_j_1_max__; ++j_1__) { - if (stan::math::is_uninitialized(phi_vec(j_1__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: phi_vec" << "(" << j_1__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable phi_vec: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - current_statement_begin__ = 212; - size_t theta_vec_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < theta_vec_j_1_max__; ++j_1__) { - if (stan::math::is_uninitialized(theta_vec(j_1__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: theta_vec" << "(" << j_1__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable theta_vec: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - current_statement_begin__ = 213; - size_t x_j_1_max__ = K; - size_t x_j_2_max__ = N; - for (size_t j_1__ = 0; j_1__ < x_j_1_max__; ++j_1__) { - for (size_t j_2__ = 0; j_2__ < x_j_2_max__; ++j_2__) { - if (stan::math::is_uninitialized(x(j_1__, j_2__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: x" << "(" << j_1__ << ", " << j_2__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable x: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - } - current_statement_begin__ = 214; - size_t indicator_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < indicator_j_1_max__; ++j_1__) { - if (stan::math::is_uninitialized(indicator(j_1__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: indicator" << "(" << j_1__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable indicator: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - current_statement_begin__ = 215; - size_t psi_root_j_1_max__ = (K * use_expansion_prior); - for (size_t j_1__ = 0; j_1__ < psi_root_j_1_max__; ++j_1__) { - if (stan::math::is_uninitialized(psi_root(j_1__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: psi_root" << "(" << j_1__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable psi_root: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - check_greater_or_equal(function__, "psi_root", psi_root, 0); - current_statement_begin__ = 216; - size_t Sigma_derived_j_1_max__ = ((n_pcor * long_format) * est_cor); - size_t Sigma_derived_j_2_max__ = ((n_pcor * long_format) * est_cor); - for (size_t j_1__ = 0; j_1__ < Sigma_derived_j_1_max__; ++j_1__) { - for (size_t j_2__ = 0; j_2__ < Sigma_derived_j_2_max__; ++j_2__) { - if (stan::math::is_uninitialized(Sigma_derived(j_1__, j_2__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: Sigma_derived" << "(" << j_1__ << ", " << j_2__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable Sigma_derived: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - } - current_statement_begin__ = 217; - size_t Sigma_temp_j_1_max__ = (((n_pcor - 1) * long_format) * est_cor); - size_t Sigma_temp_j_2_max__ = (((n_pcor - 1) * long_format) * est_cor); - for (size_t j_1__ = 0; j_1__ < Sigma_temp_j_1_max__; ++j_1__) { - for (size_t j_2__ = 0; j_2__ < Sigma_temp_j_2_max__; ++j_2__) { - if (stan::math::is_uninitialized(Sigma_temp(j_1__, j_2__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: Sigma_temp" << "(" << j_1__ << ", " << j_2__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable Sigma_temp: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - } - current_statement_begin__ = 218; - size_t sigma12_vec_j_1_max__ = (n_pcor - 1); - size_t sigma12_vec_j_2_max__ = 1; - for (size_t j_1__ = 0; j_1__ < sigma12_vec_j_1_max__; ++j_1__) { - for (size_t j_2__ = 0; j_2__ < sigma12_vec_j_2_max__; ++j_2__) { - if (stan::math::is_uninitialized(sigma12_vec(j_1__, j_2__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: sigma12_vec" << "(" << j_1__ << ", " << j_2__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable sigma12_vec: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - } - current_statement_begin__ = 219; - size_t temp_sums_j_1_max__ = ((P * long_format) * est_cor); - size_t temp_sums_j_2_max__ = ((N * long_format) * est_cor); - for (size_t j_1__ = 0; j_1__ < temp_sums_j_1_max__; ++j_1__) { - for (size_t j_2__ = 0; j_2__ < temp_sums_j_2_max__; ++j_2__) { - if (stan::math::is_uninitialized(temp_sums(j_1__, j_2__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: temp_sums" << "(" << j_1__ << ", " << j_2__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable temp_sums: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - } - current_statement_begin__ = 220; - size_t temp_counts_j_1_max__ = ((P * long_format) * est_cor); - size_t temp_counts_j_2_max__ = ((N * long_format) * est_cor); - for (size_t j_1__ = 0; j_1__ < temp_counts_j_1_max__; ++j_1__) { - for (size_t j_2__ = 0; j_2__ < temp_counts_j_2_max__; ++j_2__) { - if (stan::math::is_uninitialized(temp_counts(j_1__, j_2__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: temp_counts" << "(" << j_1__ << ", " << j_2__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable temp_counts: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - } - current_statement_begin__ = 221; - size_t cond_sigma_vec_j_1_max__ = ((P * long_format) * est_cor); - for (size_t j_1__ = 0; j_1__ < cond_sigma_vec_j_1_max__; ++j_1__) { - if (stan::math::is_uninitialized(cond_sigma_vec(j_1__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: cond_sigma_vec" << "(" << j_1__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable cond_sigma_vec: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - current_statement_begin__ = 222; - size_t cond_mean_vec_j_1_max__ = ((P * long_format) * est_cor); - for (size_t j_1__ = 0; j_1__ < cond_mean_vec_j_1_max__; ++j_1__) { - if (stan::math::is_uninitialized(cond_mean_vec(j_1__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: cond_mean_vec" << "(" << j_1__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable cond_mean_vec: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - current_statement_begin__ = 223; - if (stan::math::is_uninitialized(sigma11)) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: sigma11"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable sigma11: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - current_statement_begin__ = 224; - size_t sigma_pro_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < sigma_pro_j_1_max__; ++j_1__) { - if (stan::math::is_uninitialized(sigma_pro(j_1__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: sigma_pro" << "(" << j_1__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable sigma_pro: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - current_statement_begin__ = 225; - size_t spline_a_trans_j_1_max__ = (K * est_spline); - size_t spline_a_trans_j_2_max__ = (n_knots * est_spline); - for (size_t j_1__ = 0; j_1__ < spline_a_trans_j_1_max__; ++j_1__) { - for (size_t j_2__ = 0; j_2__ < spline_a_trans_j_2_max__; ++j_2__) { - if (stan::math::is_uninitialized(spline_a_trans(j_1__, j_2__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: spline_a_trans" << "(" << j_1__ << ", " << j_2__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable spline_a_trans: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - } - current_statement_begin__ = 226; - size_t SigmaKnots_k_0_max__ = K; - size_t SigmaKnots_j_1_max__ = n_knots; - size_t SigmaKnots_j_2_max__ = n_knots; - for (size_t k_0__ = 0; k_0__ < SigmaKnots_k_0_max__; ++k_0__) { - for (size_t j_1__ = 0; j_1__ < SigmaKnots_j_1_max__; ++j_1__) { - for (size_t j_2__ = 0; j_2__ < SigmaKnots_j_2_max__; ++j_2__) { - if (stan::math::is_uninitialized(SigmaKnots[k_0__](j_1__, j_2__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: SigmaKnots" << "[" << k_0__ << "]" << "(" << j_1__ << ", " << j_2__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable SigmaKnots: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - } - } - current_statement_begin__ = 229; - size_t obs_cov_offset_j_1_max__ = n_pos; - for (size_t j_1__ = 0; j_1__ < obs_cov_offset_j_1_max__; ++j_1__) { - if (stan::math::is_uninitialized(obs_cov_offset(j_1__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: obs_cov_offset" << "(" << j_1__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable obs_cov_offset: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - // model body - current_statement_begin__ = 488; - lp_accum__.add(normal_log(x0, 0, 1)); - current_statement_begin__ = 489; - if (as_bool(logical_eq(use_expansion_prior, 1))) { - current_statement_begin__ = 490; - lp_accum__.add(gamma_log(psi, 2, 1)); - } - current_statement_begin__ = 494; - if (as_bool(logical_eq(estimate_nu, 1))) { - current_statement_begin__ = 495; - lp_accum__.add(gamma_log(get_base1(nu, 1, "nu", 1), 2, 0.1)); - } - current_statement_begin__ = 498; - if (as_bool(logical_eq(est_phi, 1))) { - current_statement_begin__ = 499; - lp_accum__.add(normal_log(phi, 0, 1)); - } - current_statement_begin__ = 502; - if (as_bool(logical_eq(est_theta, 1))) { - current_statement_begin__ = 503; - lp_accum__.add(normal_log(theta, 0, 1)); - } - current_statement_begin__ = 506; - if (as_bool(est_sigma_process)) { - current_statement_begin__ = 507; - lp_accum__.add(normal_log(sigma_process, 0, 1)); - } - current_statement_begin__ = 510; - if (as_bool(logical_eq(est_sigma_params, 1))) { - current_statement_begin__ = 510; - lp_accum__.add(student_t_log(sigma, 3, 0, 1)); - } - current_statement_begin__ = 511; - if (as_bool(logical_eq(est_gamma_params, 1))) { - current_statement_begin__ = 511; - lp_accum__.add(student_t_log(gamma_a, 3, 0, 1)); - } - current_statement_begin__ = 512; - if (as_bool(logical_eq(est_nb2_params, 1))) { - current_statement_begin__ = 512; - lp_accum__.add(student_t_log(nb2_phi, 3, 0, 1)); - } - current_statement_begin__ = 515; - if (as_bool(logical_eq(est_cor, 1))) { - current_statement_begin__ = 516; - lp_accum__.add(lkj_corr_cholesky_log(Lcorr, 1)); - } - current_statement_begin__ = 518; - if (as_bool(logical_eq(est_gp, 1))) { - current_statement_begin__ = 523; - lp_accum__.add(inv_gamma_log(gp_theta, get_base1(gp_theta_prior, 1, "gp_theta_prior", 1), get_base1(gp_theta_prior, 2, "gp_theta_prior", 1))); - current_statement_begin__ = 525; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 526; - lp_accum__.add(std_normal_log(get_base1(effectsKnots, k, "effectsKnots", 1))); - } - } - current_statement_begin__ = 532; - if (as_bool(logical_eq(est_rw, 1))) { - current_statement_begin__ = 533; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 534; - if (as_bool(logical_eq(use_normal, 0))) { - current_statement_begin__ = 535; - for (int t = 1; t <= 1; ++t) { - current_statement_begin__ = 536; - if (as_bool(logical_eq(estimate_nu, 1))) { - current_statement_begin__ = 537; - lp_accum__.add(student_t_log(get_base1(devs, k, t, "devs", 1), get_base1(nu, 1, "nu", 1), 0, get_base1(sigma_pro, k, "sigma_pro", 1))); - } else { - current_statement_begin__ = 539; - lp_accum__.add(student_t_log(get_base1(devs, k, t, "devs", 1), nu_fixed, 0, get_base1(sigma_pro, k, "sigma_pro", 1))); - } - } - current_statement_begin__ = 542; - for (int t = 2; t <= (N - 1); ++t) { - current_statement_begin__ = 544; - if (as_bool(logical_eq(estimate_nu, 1))) { - current_statement_begin__ = 545; - lp_accum__.add(student_t_log(get_base1(devs, k, t, "devs", 1), get_base1(nu, 1, "nu", 1), (get_base1(theta_vec, k, "theta_vec", 1) * get_base1(devs, k, (t - 1), "devs", 1)), get_base1(sigma_pro, k, "sigma_pro", 1))); - } else { - current_statement_begin__ = 547; - lp_accum__.add(student_t_log(get_base1(devs, k, t, "devs", 1), nu_fixed, (get_base1(theta_vec, k, "theta_vec", 1) * get_base1(devs, k, (t - 1), "devs", 1)), get_base1(sigma_pro, k, "sigma_pro", 1))); - } - } - } else { - current_statement_begin__ = 552; - lp_accum__.add(normal_log(get_base1(devs, k, 1, "devs", 1), 0, 1)); - current_statement_begin__ = 553; - for (int t = 2; t <= (N - 1); ++t) { - current_statement_begin__ = 555; - lp_accum__.add(normal_log(get_base1(devs, k, t, "devs", 1), (get_base1(theta_vec, k, "theta_vec", 1) * get_base1(devs, k, (t - 1), "devs", 1)), get_base1(sigma_pro, k, "sigma_pro", 1))); - } - } - } - } - current_statement_begin__ = 561; - if (as_bool(logical_eq(est_spline, 1))) { - current_statement_begin__ = 562; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 563; - lp_accum__.add(std_normal_log(get_base1(spline_a, k, "spline_a", 1))); - } - } - current_statement_begin__ = 567; - if (as_bool(logical_eq(proportional_model, 0))) { - current_statement_begin__ = 569; - lp_accum__.add(std_normal_log(z)); - current_statement_begin__ = 570; - lp_accum__.add(std_normal_log(zpos)); - } else { - current_statement_begin__ = 572; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 573; - lp_accum__.add(dirichlet_log(get_base1(p_z, p, "p_z", 1), alpha_vec)); - } - } - current_statement_begin__ = 578; - if (as_bool(logical_eq(est_cor, 0))) { - current_statement_begin__ = 579; - if (as_bool(logical_eq(long_format, 0))) { - current_statement_begin__ = 580; - if (as_bool(logical_eq(obs_model, 1))) { - current_statement_begin__ = 580; - for (int i = 1; i <= P; ++i) { - current_statement_begin__ = 580; - lp_accum__.add(normal_log(get_base1(yall, i, "yall", 1), get_base1(pred, i, "pred", 1), get_base1(sigma_vec, i, "sigma_vec", 1))); - } - } + current_statement__ = 363; + lp_accum__.add( + student_t_lpdf( + rvalue(devs, + cons_list(index_uni(k), + cons_list(index_uni(t), nil_index_list())), "devs"), + nu_fixed, 0, sigma_pro[(k - 1)])); + }} + current_statement__ = 376; + for (int t = 2; t <= (N - 1); ++t) { + current_statement__ = 374; + if (logical_eq(estimate_nu, 1)) { + current_statement__ = 372; + lp_accum__.add( + student_t_lpdf( + rvalue(devs, + cons_list(index_uni(k), + cons_list(index_uni(t), nil_index_list())), "devs"), + nu[(1 - 1)], + (theta_vec[(k - 1)] * + rvalue(devs, + cons_list(index_uni(k), + cons_list(index_uni((t - 1)), nil_index_list())), + "devs")), sigma_pro[(k - 1)])); } else { - current_statement_begin__ = 582; - if (as_bool(logical_eq(obs_model, 1))) { - current_statement_begin__ = 582; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 582; - lp_accum__.add(normal_log(get_base1(y, i, "y", 1), ((get_base1(offset, i, "offset", 1) + get_base1(pred, get_base1(row_indx_pos, i, "row_indx_pos", 1), get_base1(col_indx_pos, i, "col_indx_pos", 1), "pred", 1)) + get_base1(obs_cov_offset, i, "obs_cov_offset", 1)), stan::math::exp((stan::math::log(get_base1(sigma_vec, get_base1(row_indx_pos, i, "row_indx_pos", 1), "sigma_vec", 1)) - get_base1(log_weights_vec, i, "log_weights_vec", 1))))); - } - } - current_statement_begin__ = 583; - if (as_bool(logical_eq(obs_model, 2))) { - current_statement_begin__ = 583; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 583; - lp_accum__.add(gamma_log(get_base1(y, i, "y", 1), get_base1(gamma_a_vec, get_base1(row_indx_pos, i, "row_indx_pos", 1), "gamma_a_vec", 1), (get_base1(gamma_a_vec, get_base1(row_indx_pos, i, "row_indx_pos", 1), "gamma_a_vec", 1) / stan::math::exp(((get_base1(offset, i, "offset", 1) + get_base1(pred, get_base1(row_indx_pos, i, "row_indx_pos", 1), get_base1(col_indx_pos, i, "col_indx_pos", 1), "pred", 1)) + get_base1(obs_cov_offset, i, "obs_cov_offset", 1)))))); - } - } - current_statement_begin__ = 584; - if (as_bool(logical_eq(obs_model, 3))) { - current_statement_begin__ = 584; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 584; - lp_accum__.add(poisson_log_log(get_base1(y_int, i, "y_int", 1), ((get_base1(offset, i, "offset", 1) + get_base1(pred, get_base1(row_indx_pos, i, "row_indx_pos", 1), get_base1(col_indx_pos, i, "col_indx_pos", 1), "pred", 1)) + get_base1(obs_cov_offset, i, "obs_cov_offset", 1)))); - } - } - current_statement_begin__ = 585; - if (as_bool(logical_eq(obs_model, 4))) { - current_statement_begin__ = 585; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 585; - lp_accum__.add(neg_binomial_2_log_log(get_base1(y_int, i, "y_int", 1), ((get_base1(offset, i, "offset", 1) + get_base1(pred, get_base1(row_indx_pos, i, "row_indx_pos", 1), get_base1(col_indx_pos, i, "col_indx_pos", 1), "pred", 1)) + get_base1(obs_cov_offset, i, "obs_cov_offset", 1)), get_base1(nb_phi_vec, get_base1(row_indx_pos, i, "row_indx_pos", 1), "nb_phi_vec", 1))); - } - } - current_statement_begin__ = 586; - if (as_bool(logical_eq(obs_model, 5))) { - current_statement_begin__ = 586; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 586; - lp_accum__.add(bernoulli_logit_log(get_base1(y_int, i, "y_int", 1), ((get_base1(offset, i, "offset", 1) + get_base1(pred, get_base1(row_indx_pos, i, "row_indx_pos", 1), get_base1(col_indx_pos, i, "col_indx_pos", 1), "pred", 1)) + get_base1(obs_cov_offset, i, "obs_cov_offset", 1)))); - } - } - current_statement_begin__ = 587; - if (as_bool(logical_eq(obs_model, 6))) { - current_statement_begin__ = 587; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 587; - lp_accum__.add(lognormal_log(get_base1(y, i, "y", 1), ((get_base1(offset, i, "offset", 1) + get_base1(pred, get_base1(row_indx_pos, i, "row_indx_pos", 1), get_base1(col_indx_pos, i, "col_indx_pos", 1), "pred", 1)) + get_base1(obs_cov_offset, i, "obs_cov_offset", 1)), get_base1(sigma_vec, get_base1(row_indx_pos, i, "row_indx_pos", 1), "sigma_vec", 1))); - } - } - } + current_statement__ = 370; + lp_accum__.add( + student_t_lpdf( + rvalue(devs, + cons_list(index_uni(k), + cons_list(index_uni(t), nil_index_list())), "devs"), + nu_fixed, + (theta_vec[(k - 1)] * + rvalue(devs, + cons_list(index_uni(k), + cons_list(index_uni((t - 1)), nil_index_list())), + "devs")), sigma_pro[(k - 1)])); + }} } else { - current_statement_begin__ = 591; - if (as_bool(logical_eq(long_format, 0))) { - current_statement_begin__ = 592; - if (as_bool(logical_eq(obs_model, 1))) { - current_statement_begin__ = 592; - for (int i = 1; i <= N; ++i) { - current_statement_begin__ = 592; - lp_accum__.add(multi_normal_cholesky_log(col(yall, i), col(pred, i), diag_pre_multiply(sigma_vec, Lcorr))); - } - } - } else { - current_statement_begin__ = 594; - if (as_bool(logical_eq(obs_model, 1))) { - current_statement_begin__ = 594; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 594; - lp_accum__.add(normal_log(get_base1(y, i, "y", 1), (((get_base1(offset, i, "offset", 1) + get_base1(pred, get_base1(row_indx_pos, i, "row_indx_pos", 1), get_base1(col_indx_pos, i, "col_indx_pos", 1), "pred", 1)) + get_base1(obs_cov_offset, i, "obs_cov_offset", 1)) + get_base1(cond_mean_vec, get_base1(row_indx_pos, i, "row_indx_pos", 1), "cond_mean_vec", 1)), stan::math::exp((stan::math::log(get_base1(cond_sigma_vec, get_base1(row_indx_pos, i, "row_indx_pos", 1), "cond_sigma_vec", 1)) - get_base1(log_weights_vec, i, "log_weights_vec", 1))))); - } - } - } - } - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__()); - // Next line prevents compiler griping about no return - throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); - } - lp_accum__.add(lp__); - return lp_accum__.sum(); - } // log_prob() - template - T_ log_prob(Eigen::Matrix& params_r, - std::ostream* pstream = 0) const { - std::vector vec_params_r; - vec_params_r.reserve(params_r.size()); - for (int i = 0; i < params_r.size(); ++i) - vec_params_r.push_back(params_r(i)); - std::vector vec_params_i; - return log_prob(vec_params_r, vec_params_i, pstream); - } - void get_param_names(std::vector& names__) const { - names__.resize(0); - names__.push_back("devs"); - names__.push_back("x0"); - names__.push_back("psi"); - names__.push_back("z"); - names__.push_back("zpos"); - names__.push_back("p_z"); - names__.push_back("spline_a"); - names__.push_back("b_obs"); - names__.push_back("b_pro"); - names__.push_back("sigma"); - names__.push_back("gamma_a"); - names__.push_back("nb2_phi"); - names__.push_back("nu"); - names__.push_back("ymiss"); - names__.push_back("phi"); - names__.push_back("theta"); - names__.push_back("gp_theta"); - names__.push_back("Lcorr"); - names__.push_back("sigma_process"); - names__.push_back("effectsKnots"); - names__.push_back("pred"); - names__.push_back("Z"); - names__.push_back("yall"); - names__.push_back("sigma_vec"); - names__.push_back("gamma_a_vec"); - names__.push_back("nb_phi_vec"); - names__.push_back("phi_vec"); - names__.push_back("theta_vec"); - names__.push_back("x"); - names__.push_back("indicator"); - names__.push_back("psi_root"); - names__.push_back("Sigma_derived"); - names__.push_back("Sigma_temp"); - names__.push_back("sigma12_vec"); - names__.push_back("temp_sums"); - names__.push_back("temp_counts"); - names__.push_back("cond_sigma_vec"); - names__.push_back("cond_mean_vec"); - names__.push_back("sigma11"); - names__.push_back("sigma_pro"); - names__.push_back("spline_a_trans"); - names__.push_back("SigmaKnots"); - names__.push_back("obs_cov_offset"); - names__.push_back("log_lik"); - names__.push_back("Omega"); - names__.push_back("Sigma"); - names__.push_back("xstar"); - names__.push_back("future_devs"); - names__.push_back("SigmaKnots_pred"); - names__.push_back("SigmaOffDiag_pred"); - names__.push_back("j"); - } - void get_dims(std::vector >& dimss__) const { - dimss__.resize(0); - std::vector dims__; - dims__.resize(0); - dims__.push_back((K * est_rw)); - dims__.push_back(((N - 1) * est_rw)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(((K * (1 - proportional_model)) * use_expansion_prior)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((nZ * (1 - proportional_model))); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((K * (1 - proportional_model))); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((P * proportional_model)); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((K * est_spline)); - dims__.push_back((n_knots * est_spline)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(n_obs_covar); - dims__.push_back(P); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(n_pro_covar); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((nVariances * est_sigma_params)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((nVariances * est_gamma_params)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((nVariances * est_nb2_params)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(estimate_nu); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(n_na); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((est_phi * K)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((est_theta * K)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((est_gp * K)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(n_pcor); - dims__.push_back(n_pcor); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((est_sigma_process * n_sigma_process)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((K * est_gp)); - dims__.push_back((n_knots * est_gp)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(P); - dims__.push_back(N); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(P); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(P); - dims__.push_back(N); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((P * est_sigma_params)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((P * est_gamma_params)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((P * est_nb2_params)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(K); - dims__.push_back(N); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((K * use_expansion_prior)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(((n_pcor * long_format) * est_cor)); - dims__.push_back(((n_pcor * long_format) * est_cor)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((((n_pcor - 1) * long_format) * est_cor)); - dims__.push_back((((n_pcor - 1) * long_format) * est_cor)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((n_pcor - 1)); - dims__.push_back(1); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(((P * long_format) * est_cor)); - dims__.push_back(((N * long_format) * est_cor)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(((P * long_format) * est_cor)); - dims__.push_back(((N * long_format) * est_cor)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(((P * long_format) * est_cor)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(((P * long_format) * est_cor)); - dimss__.push_back(dims__); - dims__.resize(0); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back((K * est_spline)); - dims__.push_back((n_knots * est_spline)); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(K); - dims__.push_back(n_knots); - dims__.push_back(n_knots); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(n_pos); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(n_loglik); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(n_pcor); - dims__.push_back(n_pcor); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(n_pcor); - dims__.push_back(n_pcor); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(K); - dims__.push_back(1); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(n_knots); - dims__.push_back(n_knots); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(n_knots); - dimss__.push_back(dims__); - dims__.resize(0); - dimss__.push_back(dims__); + current_statement__ = 358; + lp_accum__.add( + normal_lpdf( + rvalue(devs, + cons_list(index_uni(k), + cons_list(index_uni(1), nil_index_list())), "devs"), 0, + 1)); + current_statement__ = 361; + for (int t = 2; t <= (N - 1); ++t) { + current_statement__ = 359; + lp_accum__.add( + normal_lpdf( + rvalue(devs, + cons_list(index_uni(k), + cons_list(index_uni(t), nil_index_list())), "devs"), + (theta_vec[(k - 1)] * + rvalue(devs, + cons_list(index_uni(k), + cons_list(index_uni((t - 1)), nil_index_list())), + "devs")), sigma_pro[(k - 1)]));} + }} + } + current_statement__ = 387; + if (logical_eq(est_spline, 1)) { + current_statement__ = 385; + for (int k = 1; k <= K; ++k) { + current_statement__ = 383; + lp_accum__.add( + std_normal_lpdf( + rvalue(spline_a, cons_list(index_uni(k), nil_index_list()), + "spline_a")));} + } + current_statement__ = 395; + if (logical_eq(proportional_model, 0)) { + current_statement__ = 392; + lp_accum__.add(std_normal_lpdf(z)); + current_statement__ = 393; + lp_accum__.add(std_normal_lpdf(zpos)); + } else { + current_statement__ = 390; + for (int p = 1; p <= P; ++p) { + current_statement__ = 388; + lp_accum__.add(dirichlet_lpdf(p_z[(p - 1)], alpha_vec)); + } + } + current_statement__ = 440; + if (logical_eq(est_cor, 0)) { + current_statement__ = 438; + if (logical_eq(long_format, 0)) { + current_statement__ = 436; + if (logical_eq(obs_model, 1)) { + current_statement__ = 434; + for (int i = 1; i <= P; ++i) { + current_statement__ = 433; + lp_accum__.add( + normal_lpdf( + rvalue(yall, cons_list(index_uni(i), nil_index_list()), + "yall"), + rvalue(pred, cons_list(index_uni(i), nil_index_list()), + "pred"), sigma_vec[(i - 1)]));} + } + } else { + current_statement__ = 411; + if (logical_eq(obs_model, 1)) { + current_statement__ = 409; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 408; + lp_accum__.add( + normal_lpdf(y[(i - 1)], + ((offset[(i - 1)] + + rvalue(pred, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "pred")) + + obs_cov_offset[(i - 1)]), + stan::math::exp( + (stan::math::log( + sigma_vec[(row_indx_pos[(i - 1)] - 1)]) - + log_weights_vec[(i - 1)]))));} + } + current_statement__ = 415; + if (logical_eq(obs_model, 2)) { + current_statement__ = 413; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 412; + lp_accum__.add( + gamma_lpdf(y[(i - 1)], + gamma_a_vec[(row_indx_pos[(i - 1)] - 1)], + (gamma_a_vec[(row_indx_pos[(i - 1)] - 1)] / + stan::math::exp( + ((offset[(i - 1)] + + rvalue(pred, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "pred")) + + obs_cov_offset[(i - 1)])))));} + } + current_statement__ = 419; + if (logical_eq(obs_model, 3)) { + current_statement__ = 417; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 416; + lp_accum__.add( + poisson_log_lpmf(y_int[(i - 1)], + ((offset[(i - 1)] + + rvalue(pred, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "pred")) + + obs_cov_offset[(i - 1)])));} + } + current_statement__ = 423; + if (logical_eq(obs_model, 4)) { + current_statement__ = 421; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 420; + lp_accum__.add( + neg_binomial_2_log_lpmf(y_int[(i - 1)], + ((offset[(i - 1)] + + rvalue(pred, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "pred")) + + obs_cov_offset[(i - 1)]), + nb_phi_vec[(row_indx_pos[(i - 1)] - 1)]));} + } + current_statement__ = 427; + if (logical_eq(obs_model, 5)) { + current_statement__ = 425; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 424; + lp_accum__.add( + bernoulli_logit_lpmf(y_int[(i - 1)], + ((offset[(i - 1)] + + rvalue(pred, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "pred")) + + obs_cov_offset[(i - 1)])));} + } + current_statement__ = 431; + if (logical_eq(obs_model, 6)) { + current_statement__ = 429; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 428; + lp_accum__.add( + lognormal_lpdf(y[(i - 1)], + ((offset[(i - 1)] + + rvalue(pred, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "pred")) + + obs_cov_offset[(i - 1)]), + sigma_vec[(row_indx_pos[(i - 1)] - 1)]));} + } + } + } else { + current_statement__ = 406; + if (logical_eq(long_format, 0)) { + current_statement__ = 404; + if (logical_eq(obs_model, 1)) { + current_statement__ = 402; + for (int i = 1; i <= N; ++i) { + current_statement__ = 401; + lp_accum__.add( + multi_normal_cholesky_lpdf(col(yall, i), + col(pred, i), diag_pre_multiply(sigma_vec, Lcorr)));} + } + } else { + current_statement__ = 399; + if (logical_eq(obs_model, 1)) { + current_statement__ = 397; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 396; + lp_accum__.add( + normal_lpdf(y[(i - 1)], + (((offset[(i - 1)] + + rvalue(pred, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "pred")) + + obs_cov_offset[(i - 1)]) + + cond_mean_vec[(row_indx_pos[(i - 1)] - 1)]), + stan::math::exp( + (stan::math::log( + cond_sigma_vec[(row_indx_pos[(i - 1)] - 1)]) - + log_weights_vec[(i - 1)]))));} + } + } + } + } + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); } - template - void write_array(RNG& base_rng__, - std::vector& params_r__, - std::vector& params_i__, - std::vector& vars__, - bool include_tparams__ = true, - bool include_gqs__ = true, - std::ostream* pstream__ = 0) const { - typedef double local_scalar_t__; - vars__.resize(0); - stan::io::reader in__(params_r__, params_i__); - static const char* function__ = "model_dfa_namespace::write_array"; - (void) function__; // dummy to suppress unused var warning - // read-transform, write parameters - Eigen::Matrix devs = in__.matrix_constrain((K * est_rw), ((N - 1) * est_rw)); - size_t devs_j_2_max__ = ((N - 1) * est_rw); - size_t devs_j_1_max__ = (K * est_rw); - for (size_t j_2__ = 0; j_2__ < devs_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < devs_j_1_max__; ++j_1__) { - vars__.push_back(devs(j_1__, j_2__)); - } - } - Eigen::Matrix x0 = in__.vector_constrain(K); - size_t x0_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < x0_j_1_max__; ++j_1__) { - vars__.push_back(x0(j_1__)); - } - Eigen::Matrix psi = in__.vector_lb_constrain(0, ((K * (1 - proportional_model)) * use_expansion_prior)); - size_t psi_j_1_max__ = ((K * (1 - proportional_model)) * use_expansion_prior); - for (size_t j_1__ = 0; j_1__ < psi_j_1_max__; ++j_1__) { - vars__.push_back(psi(j_1__)); - } - Eigen::Matrix z = in__.vector_lub_constrain(get_base1(z_bound, 1, "z_bound", 1), get_base1(z_bound, 2, "z_bound", 1), (nZ * (1 - proportional_model))); - size_t z_j_1_max__ = (nZ * (1 - proportional_model)); - for (size_t j_1__ = 0; j_1__ < z_j_1_max__; ++j_1__) { - vars__.push_back(z(j_1__)); - } - Eigen::Matrix zpos = in__.vector_lb_constrain(lower_bound_z, (K * (1 - proportional_model))); - size_t zpos_j_1_max__ = (K * (1 - proportional_model)); - for (size_t j_1__ = 0; j_1__ < zpos_j_1_max__; ++j_1__) { - vars__.push_back(zpos(j_1__)); - } - std::vector > p_z; - size_t p_z_d_0_max__ = (P * proportional_model); - p_z.reserve(p_z_d_0_max__); - for (size_t d_0__ = 0; d_0__ < p_z_d_0_max__; ++d_0__) { - p_z.push_back(in__.simplex_constrain(K)); - } - size_t p_z_j_1_max__ = K; - size_t p_z_k_0_max__ = (P * proportional_model); - for (size_t j_1__ = 0; j_1__ < p_z_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < p_z_k_0_max__; ++k_0__) { - vars__.push_back(p_z[k_0__](j_1__)); - } - } - Eigen::Matrix spline_a = in__.matrix_constrain((K * est_spline), (n_knots * est_spline)); - size_t spline_a_j_2_max__ = (n_knots * est_spline); - size_t spline_a_j_1_max__ = (K * est_spline); - for (size_t j_2__ = 0; j_2__ < spline_a_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < spline_a_j_1_max__; ++j_1__) { - vars__.push_back(spline_a(j_1__, j_2__)); - } - } - Eigen::Matrix b_obs = in__.matrix_constrain(n_obs_covar, P); - size_t b_obs_j_2_max__ = P; - size_t b_obs_j_1_max__ = n_obs_covar; - for (size_t j_2__ = 0; j_2__ < b_obs_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < b_obs_j_1_max__; ++j_1__) { - vars__.push_back(b_obs(j_1__, j_2__)); - } - } - Eigen::Matrix b_pro = in__.matrix_constrain(n_pro_covar, K); - size_t b_pro_j_2_max__ = K; - size_t b_pro_j_1_max__ = n_pro_covar; - for (size_t j_2__ = 0; j_2__ < b_pro_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < b_pro_j_1_max__; ++j_1__) { - vars__.push_back(b_pro(j_1__, j_2__)); - } - } - std::vector sigma; - size_t sigma_d_0_max__ = (nVariances * est_sigma_params); - sigma.reserve(sigma_d_0_max__); - for (size_t d_0__ = 0; d_0__ < sigma_d_0_max__; ++d_0__) { - sigma.push_back(in__.scalar_lb_constrain(0)); - } - size_t sigma_k_0_max__ = (nVariances * est_sigma_params); - for (size_t k_0__ = 0; k_0__ < sigma_k_0_max__; ++k_0__) { - vars__.push_back(sigma[k_0__]); - } - std::vector gamma_a; - size_t gamma_a_d_0_max__ = (nVariances * est_gamma_params); - gamma_a.reserve(gamma_a_d_0_max__); - for (size_t d_0__ = 0; d_0__ < gamma_a_d_0_max__; ++d_0__) { - gamma_a.push_back(in__.scalar_lb_constrain(0)); - } - size_t gamma_a_k_0_max__ = (nVariances * est_gamma_params); - for (size_t k_0__ = 0; k_0__ < gamma_a_k_0_max__; ++k_0__) { - vars__.push_back(gamma_a[k_0__]); - } - std::vector nb2_phi; - size_t nb2_phi_d_0_max__ = (nVariances * est_nb2_params); - nb2_phi.reserve(nb2_phi_d_0_max__); - for (size_t d_0__ = 0; d_0__ < nb2_phi_d_0_max__; ++d_0__) { - nb2_phi.push_back(in__.scalar_lb_constrain(0)); - } - size_t nb2_phi_k_0_max__ = (nVariances * est_nb2_params); - for (size_t k_0__ = 0; k_0__ < nb2_phi_k_0_max__; ++k_0__) { - vars__.push_back(nb2_phi[k_0__]); - } - std::vector nu; - size_t nu_d_0_max__ = estimate_nu; - nu.reserve(nu_d_0_max__); - for (size_t d_0__ = 0; d_0__ < nu_d_0_max__; ++d_0__) { - nu.push_back(in__.scalar_lb_constrain(2)); - } - size_t nu_k_0_max__ = estimate_nu; - for (size_t k_0__ = 0; k_0__ < nu_k_0_max__; ++k_0__) { - vars__.push_back(nu[k_0__]); - } - std::vector ymiss; - size_t ymiss_d_0_max__ = n_na; - ymiss.reserve(ymiss_d_0_max__); - for (size_t d_0__ = 0; d_0__ < ymiss_d_0_max__; ++d_0__) { - ymiss.push_back(in__.scalar_constrain()); - } - size_t ymiss_k_0_max__ = n_na; - for (size_t k_0__ = 0; k_0__ < ymiss_k_0_max__; ++k_0__) { - vars__.push_back(ymiss[k_0__]); - } - std::vector phi; - size_t phi_d_0_max__ = (est_phi * K); - phi.reserve(phi_d_0_max__); - for (size_t d_0__ = 0; d_0__ < phi_d_0_max__; ++d_0__) { - phi.push_back(in__.scalar_lub_constrain(-(1), 1)); - } - size_t phi_k_0_max__ = (est_phi * K); - for (size_t k_0__ = 0; k_0__ < phi_k_0_max__; ++k_0__) { - vars__.push_back(phi[k_0__]); - } - std::vector theta; - size_t theta_d_0_max__ = (est_theta * K); - theta.reserve(theta_d_0_max__); - for (size_t d_0__ = 0; d_0__ < theta_d_0_max__; ++d_0__) { - theta.push_back(in__.scalar_lub_constrain(-(1), 1)); - } - size_t theta_k_0_max__ = (est_theta * K); - for (size_t k_0__ = 0; k_0__ < theta_k_0_max__; ++k_0__) { - vars__.push_back(theta[k_0__]); - } - std::vector gp_theta; - size_t gp_theta_d_0_max__ = (est_gp * K); - gp_theta.reserve(gp_theta_d_0_max__); - for (size_t d_0__ = 0; d_0__ < gp_theta_d_0_max__; ++d_0__) { - gp_theta.push_back(in__.scalar_lb_constrain(0)); - } - size_t gp_theta_k_0_max__ = (est_gp * K); - for (size_t k_0__ = 0; k_0__ < gp_theta_k_0_max__; ++k_0__) { - vars__.push_back(gp_theta[k_0__]); - } - Eigen::Matrix Lcorr = in__.cholesky_factor_corr_constrain(n_pcor); - size_t Lcorr_j_2_max__ = n_pcor; - size_t Lcorr_j_1_max__ = n_pcor; - for (size_t j_2__ = 0; j_2__ < Lcorr_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Lcorr_j_1_max__; ++j_1__) { - vars__.push_back(Lcorr(j_1__, j_2__)); - } - } - std::vector sigma_process; - size_t sigma_process_d_0_max__ = (est_sigma_process * n_sigma_process); - sigma_process.reserve(sigma_process_d_0_max__); - for (size_t d_0__ = 0; d_0__ < sigma_process_d_0_max__; ++d_0__) { - sigma_process.push_back(in__.scalar_lb_constrain(0)); - } - size_t sigma_process_k_0_max__ = (est_sigma_process * n_sigma_process); - for (size_t k_0__ = 0; k_0__ < sigma_process_k_0_max__; ++k_0__) { - vars__.push_back(sigma_process[k_0__]); - } - std::vector > effectsKnots; - size_t effectsKnots_d_0_max__ = (K * est_gp); - effectsKnots.reserve(effectsKnots_d_0_max__); - for (size_t d_0__ = 0; d_0__ < effectsKnots_d_0_max__; ++d_0__) { - effectsKnots.push_back(in__.vector_constrain((n_knots * est_gp))); - } - size_t effectsKnots_j_1_max__ = (n_knots * est_gp); - size_t effectsKnots_k_0_max__ = (K * est_gp); - for (size_t j_1__ = 0; j_1__ < effectsKnots_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < effectsKnots_k_0_max__; ++k_0__) { - vars__.push_back(effectsKnots[k_0__](j_1__)); - } - } - double lp__ = 0.0; - (void) lp__; // dummy to suppress unused var warning - stan::math::accumulator lp_accum__; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - (void) DUMMY_VAR__; // suppress unused var warning - if (!include_tparams__ && !include_gqs__) return; - try { - // declare and define transformed parameters - current_statement_begin__ = 205; - validate_non_negative_index("pred", "P", P); - validate_non_negative_index("pred", "N", N); - Eigen::Matrix pred(P, N); - stan::math::initialize(pred, DUMMY_VAR__); - stan::math::fill(pred, DUMMY_VAR__); - current_statement_begin__ = 206; - validate_non_negative_index("Z", "P", P); - validate_non_negative_index("Z", "K", K); - Eigen::Matrix Z(P, K); - stan::math::initialize(Z, DUMMY_VAR__); - stan::math::fill(Z, DUMMY_VAR__); - current_statement_begin__ = 207; - validate_non_negative_index("yall", "P", P); - validate_non_negative_index("yall", "N", N); - Eigen::Matrix yall(P, N); - stan::math::initialize(yall, DUMMY_VAR__); - stan::math::fill(yall, DUMMY_VAR__); - current_statement_begin__ = 208; - validate_non_negative_index("sigma_vec", "(P * est_sigma_params)", (P * est_sigma_params)); - Eigen::Matrix sigma_vec((P * est_sigma_params)); - stan::math::initialize(sigma_vec, DUMMY_VAR__); - stan::math::fill(sigma_vec, DUMMY_VAR__); - current_statement_begin__ = 209; - validate_non_negative_index("gamma_a_vec", "(P * est_gamma_params)", (P * est_gamma_params)); - Eigen::Matrix gamma_a_vec((P * est_gamma_params)); - stan::math::initialize(gamma_a_vec, DUMMY_VAR__); - stan::math::fill(gamma_a_vec, DUMMY_VAR__); - current_statement_begin__ = 210; - validate_non_negative_index("nb_phi_vec", "(P * est_nb2_params)", (P * est_nb2_params)); - Eigen::Matrix nb_phi_vec((P * est_nb2_params)); - stan::math::initialize(nb_phi_vec, DUMMY_VAR__); - stan::math::fill(nb_phi_vec, DUMMY_VAR__); - current_statement_begin__ = 211; - validate_non_negative_index("phi_vec", "K", K); - Eigen::Matrix phi_vec(K); - stan::math::initialize(phi_vec, DUMMY_VAR__); - stan::math::fill(phi_vec, DUMMY_VAR__); - current_statement_begin__ = 212; - validate_non_negative_index("theta_vec", "K", K); - Eigen::Matrix theta_vec(K); - stan::math::initialize(theta_vec, DUMMY_VAR__); - stan::math::fill(theta_vec, DUMMY_VAR__); - current_statement_begin__ = 213; - validate_non_negative_index("x", "K", K); - validate_non_negative_index("x", "N", N); - Eigen::Matrix x(K, N); - stan::math::initialize(x, DUMMY_VAR__); - stan::math::fill(x, DUMMY_VAR__); - current_statement_begin__ = 214; - validate_non_negative_index("indicator", "K", K); - Eigen::Matrix indicator(K); - stan::math::initialize(indicator, DUMMY_VAR__); - stan::math::fill(indicator, DUMMY_VAR__); - current_statement_begin__ = 215; - validate_non_negative_index("psi_root", "(K * use_expansion_prior)", (K * use_expansion_prior)); - Eigen::Matrix psi_root((K * use_expansion_prior)); - stan::math::initialize(psi_root, DUMMY_VAR__); - stan::math::fill(psi_root, DUMMY_VAR__); - current_statement_begin__ = 216; - validate_non_negative_index("Sigma_derived", "((n_pcor * long_format) * est_cor)", ((n_pcor * long_format) * est_cor)); - validate_non_negative_index("Sigma_derived", "((n_pcor * long_format) * est_cor)", ((n_pcor * long_format) * est_cor)); - Eigen::Matrix Sigma_derived(((n_pcor * long_format) * est_cor), ((n_pcor * long_format) * est_cor)); - stan::math::initialize(Sigma_derived, DUMMY_VAR__); - stan::math::fill(Sigma_derived, DUMMY_VAR__); - current_statement_begin__ = 217; - validate_non_negative_index("Sigma_temp", "(((n_pcor - 1) * long_format) * est_cor)", (((n_pcor - 1) * long_format) * est_cor)); - validate_non_negative_index("Sigma_temp", "(((n_pcor - 1) * long_format) * est_cor)", (((n_pcor - 1) * long_format) * est_cor)); - Eigen::Matrix Sigma_temp((((n_pcor - 1) * long_format) * est_cor), (((n_pcor - 1) * long_format) * est_cor)); - stan::math::initialize(Sigma_temp, DUMMY_VAR__); - stan::math::fill(Sigma_temp, DUMMY_VAR__); - current_statement_begin__ = 218; - validate_non_negative_index("sigma12_vec", "(n_pcor - 1)", (n_pcor - 1)); - validate_non_negative_index("sigma12_vec", "1", 1); - Eigen::Matrix sigma12_vec((n_pcor - 1), 1); - stan::math::initialize(sigma12_vec, DUMMY_VAR__); - stan::math::fill(sigma12_vec, DUMMY_VAR__); - current_statement_begin__ = 219; - validate_non_negative_index("temp_sums", "((P * long_format) * est_cor)", ((P * long_format) * est_cor)); - validate_non_negative_index("temp_sums", "((N * long_format) * est_cor)", ((N * long_format) * est_cor)); - Eigen::Matrix temp_sums(((P * long_format) * est_cor), ((N * long_format) * est_cor)); - stan::math::initialize(temp_sums, DUMMY_VAR__); - stan::math::fill(temp_sums, DUMMY_VAR__); - current_statement_begin__ = 220; - validate_non_negative_index("temp_counts", "((P * long_format) * est_cor)", ((P * long_format) * est_cor)); - validate_non_negative_index("temp_counts", "((N * long_format) * est_cor)", ((N * long_format) * est_cor)); - Eigen::Matrix temp_counts(((P * long_format) * est_cor), ((N * long_format) * est_cor)); - stan::math::initialize(temp_counts, DUMMY_VAR__); - stan::math::fill(temp_counts, DUMMY_VAR__); - current_statement_begin__ = 221; - validate_non_negative_index("cond_sigma_vec", "((P * long_format) * est_cor)", ((P * long_format) * est_cor)); - Eigen::Matrix cond_sigma_vec(((P * long_format) * est_cor)); - stan::math::initialize(cond_sigma_vec, DUMMY_VAR__); - stan::math::fill(cond_sigma_vec, DUMMY_VAR__); - current_statement_begin__ = 222; - validate_non_negative_index("cond_mean_vec", "((P * long_format) * est_cor)", ((P * long_format) * est_cor)); - Eigen::Matrix cond_mean_vec(((P * long_format) * est_cor)); - stan::math::initialize(cond_mean_vec, DUMMY_VAR__); - stan::math::fill(cond_mean_vec, DUMMY_VAR__); - current_statement_begin__ = 223; - double sigma11; - (void) sigma11; // dummy to suppress unused var warning - stan::math::initialize(sigma11, DUMMY_VAR__); - stan::math::fill(sigma11, DUMMY_VAR__); - current_statement_begin__ = 224; - validate_non_negative_index("sigma_pro", "K", K); - Eigen::Matrix sigma_pro(K); - stan::math::initialize(sigma_pro, DUMMY_VAR__); - stan::math::fill(sigma_pro, DUMMY_VAR__); - current_statement_begin__ = 225; - validate_non_negative_index("spline_a_trans", "(K * est_spline)", (K * est_spline)); - validate_non_negative_index("spline_a_trans", "(n_knots * est_spline)", (n_knots * est_spline)); - Eigen::Matrix spline_a_trans((K * est_spline), (n_knots * est_spline)); - stan::math::initialize(spline_a_trans, DUMMY_VAR__); - stan::math::fill(spline_a_trans, DUMMY_VAR__); - current_statement_begin__ = 226; - validate_non_negative_index("SigmaKnots", "n_knots", n_knots); - validate_non_negative_index("SigmaKnots", "n_knots", n_knots); - validate_non_negative_index("SigmaKnots", "K", K); - std::vector > SigmaKnots(K, Eigen::Matrix(n_knots, n_knots)); - stan::math::initialize(SigmaKnots, DUMMY_VAR__); - stan::math::fill(SigmaKnots, DUMMY_VAR__); - current_statement_begin__ = 229; - validate_non_negative_index("obs_cov_offset", "n_pos", n_pos); - Eigen::Matrix obs_cov_offset(n_pos); - stan::math::initialize(obs_cov_offset, DUMMY_VAR__); - stan::math::fill(obs_cov_offset, DUMMY_VAR__); - // do transformed parameters statements - current_statement_begin__ = 232; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 233; - stan::model::assign(sigma_pro, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - 1, - "assigning variable sigma_pro"); - current_statement_begin__ = 234; - if (as_bool(logical_eq(est_sigma_process, 1))) { - current_statement_begin__ = 235; - if (as_bool(logical_eq(n_sigma_process, 1))) { - current_statement_begin__ = 236; - stan::model::assign(sigma_pro, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - get_base1(sigma_process, 1, "sigma_process", 1), - "assigning variable sigma_pro"); - } else { - current_statement_begin__ = 238; - stan::model::assign(sigma_pro, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - get_base1(sigma_process, k, "sigma_process", 1), - "assigning variable sigma_pro"); - } - } - } - current_statement_begin__ = 244; - if (as_bool(logical_eq(est_phi, 1))) { - current_statement_begin__ = 245; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 245; - stan::model::assign(phi_vec, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - get_base1(phi, k, "phi", 1), - "assigning variable phi_vec"); - } + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // 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; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "model_dfa_namespace::write_array"; +(void) function__; // suppress unused var warning + (void) function__; // suppress unused var warning + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + (void) DUMMY_VAR__; // suppress unused var warning + + try { + Eigen::Matrix devs; + devs = Eigen::Matrix(devs_1dim__, devs_2dim__); + stan::math::fill(devs, std::numeric_limits::quiet_NaN()); + + current_statement__ = 1; + devs = in__.matrix(devs_1dim__, devs_2dim__); + Eigen::Matrix x0; + x0 = Eigen::Matrix(K); + stan::math::fill(x0, std::numeric_limits::quiet_NaN()); + + current_statement__ = 2; + x0 = in__.vector(K); + Eigen::Matrix psi; + psi = Eigen::Matrix(psi_1dim__); + stan::math::fill(psi, std::numeric_limits::quiet_NaN()); + + current_statement__ = 3; + psi = in__.vector(psi_1dim__); + current_statement__ = 3; + for (int sym1__ = 1; sym1__ <= psi_1dim__; ++sym1__) { + current_statement__ = 3; + assign(psi, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(psi[(sym1__ - 1)], 0), + "assigning variable psi");} + Eigen::Matrix z; + z = Eigen::Matrix(z_1dim__); + stan::math::fill(z, std::numeric_limits::quiet_NaN()); + + current_statement__ = 4; + z = in__.vector(z_1dim__); + current_statement__ = 4; + for (int sym1__ = 1; sym1__ <= z_1dim__; ++sym1__) { + current_statement__ = 4; + assign(z, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(z[(sym1__ - 1)], z_bound[(1 - 1)], + z_bound[(2 - 1)]), "assigning variable z");} + Eigen::Matrix zpos; + zpos = Eigen::Matrix(zpos_1dim__); + stan::math::fill(zpos, std::numeric_limits::quiet_NaN()); + + current_statement__ = 5; + zpos = in__.vector(zpos_1dim__); + current_statement__ = 5; + for (int sym1__ = 1; sym1__ <= zpos_1dim__; ++sym1__) { + current_statement__ = 5; + assign(zpos, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(zpos[(sym1__ - 1)], lower_bound_z), + "assigning variable zpos");} + std::vector> p_z; + p_z = std::vector>(p_z_1dim__, Eigen::Matrix(K)); + stan::math::fill(p_z, std::numeric_limits::quiet_NaN()); + + std::vector> p_z_in__; + p_z_in__ = std::vector>(p_z_1dim__, Eigen::Matrix( + (K - 1))); + stan::math::fill(p_z_in__, DUMMY_VAR__); + + current_statement__ = 6; + for (int sym1__ = 1; sym1__ <= p_z_1dim__; ++sym1__) { + current_statement__ = 6; + assign(p_z_in__, cons_list(index_uni(sym1__), nil_index_list()), + in__.vector((K - 1)), "assigning variable p_z_in__");} + current_statement__ = 6; + for (int sym1__ = 1; sym1__ <= p_z_1dim__; ++sym1__) { + current_statement__ = 6; + assign(p_z, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::simplex_constrain(p_z_in__[(sym1__ - 1)]), + "assigning variable p_z");} + Eigen::Matrix spline_a; + spline_a = Eigen::Matrix(spline_a_1dim__, spline_a_2dim__); + stan::math::fill(spline_a, std::numeric_limits::quiet_NaN()); + + current_statement__ = 7; + spline_a = in__.matrix(spline_a_1dim__, spline_a_2dim__); + Eigen::Matrix b_obs; + b_obs = Eigen::Matrix(n_obs_covar, P); + stan::math::fill(b_obs, std::numeric_limits::quiet_NaN()); + + current_statement__ = 8; + b_obs = in__.matrix(n_obs_covar, P); + Eigen::Matrix b_pro; + b_pro = Eigen::Matrix(n_pro_covar, K); + stan::math::fill(b_pro, std::numeric_limits::quiet_NaN()); + + current_statement__ = 9; + b_pro = in__.matrix(n_pro_covar, K); + std::vector sigma; + sigma = std::vector(sigma_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 10; + for (int sym1__ = 1; sym1__ <= sigma_1dim__; ++sym1__) { + current_statement__ = 10; + assign(sigma, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable sigma");} + current_statement__ = 10; + for (int sym1__ = 1; sym1__ <= sigma_1dim__; ++sym1__) { + current_statement__ = 10; + assign(sigma, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(sigma[(sym1__ - 1)], 0), + "assigning variable sigma");} + std::vector gamma_a; + gamma_a = std::vector(gamma_a_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 11; + for (int sym1__ = 1; sym1__ <= gamma_a_1dim__; ++sym1__) { + current_statement__ = 11; + assign(gamma_a, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable gamma_a");} + current_statement__ = 11; + for (int sym1__ = 1; sym1__ <= gamma_a_1dim__; ++sym1__) { + current_statement__ = 11; + assign(gamma_a, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(gamma_a[(sym1__ - 1)], 0), + "assigning variable gamma_a");} + std::vector nb2_phi; + nb2_phi = std::vector(nb2_phi_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 12; + for (int sym1__ = 1; sym1__ <= nb2_phi_1dim__; ++sym1__) { + current_statement__ = 12; + assign(nb2_phi, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable nb2_phi");} + current_statement__ = 12; + for (int sym1__ = 1; sym1__ <= nb2_phi_1dim__; ++sym1__) { + current_statement__ = 12; + assign(nb2_phi, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(nb2_phi[(sym1__ - 1)], 0), + "assigning variable nb2_phi");} + std::vector nu; + nu = std::vector(estimate_nu, std::numeric_limits::quiet_NaN()); + + current_statement__ = 13; + for (int sym1__ = 1; sym1__ <= estimate_nu; ++sym1__) { + current_statement__ = 13; + assign(nu, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable nu");} + current_statement__ = 13; + for (int sym1__ = 1; sym1__ <= estimate_nu; ++sym1__) { + current_statement__ = 13; + assign(nu, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(nu[(sym1__ - 1)], 2), + "assigning variable nu");} + std::vector ymiss; + ymiss = std::vector(n_na, std::numeric_limits::quiet_NaN()); + + current_statement__ = 14; + for (int sym1__ = 1; sym1__ <= n_na; ++sym1__) { + current_statement__ = 14; + assign(ymiss, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable ymiss");} + std::vector phi; + phi = std::vector(phi_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 15; + for (int sym1__ = 1; sym1__ <= phi_1dim__; ++sym1__) { + current_statement__ = 15; + assign(phi, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable phi");} + current_statement__ = 15; + for (int sym1__ = 1; sym1__ <= phi_1dim__; ++sym1__) { + current_statement__ = 15; + assign(phi, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(phi[(sym1__ - 1)], -1, 1), + "assigning variable phi");} + std::vector theta; + theta = std::vector(theta_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 16; + for (int sym1__ = 1; sym1__ <= theta_1dim__; ++sym1__) { + current_statement__ = 16; + assign(theta, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable theta");} + current_statement__ = 16; + for (int sym1__ = 1; sym1__ <= theta_1dim__; ++sym1__) { + current_statement__ = 16; + assign(theta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_constrain(theta[(sym1__ - 1)], -1, 1), + "assigning variable theta");} + std::vector gp_theta; + gp_theta = std::vector(gp_theta_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 17; + for (int sym1__ = 1; sym1__ <= gp_theta_1dim__; ++sym1__) { + current_statement__ = 17; + assign(gp_theta, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable gp_theta");} + current_statement__ = 17; + for (int sym1__ = 1; sym1__ <= gp_theta_1dim__; ++sym1__) { + current_statement__ = 17; + assign(gp_theta, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(gp_theta[(sym1__ - 1)], 0), + "assigning variable gp_theta");} + Eigen::Matrix Lcorr; + Lcorr = Eigen::Matrix(n_pcor, n_pcor); + stan::math::fill(Lcorr, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix Lcorr_in__; + Lcorr_in__ = Eigen::Matrix(((n_pcor * + (n_pcor - 1)) / + 2)); + stan::math::fill(Lcorr_in__, DUMMY_VAR__); + + current_statement__ = 18; + Lcorr_in__ = in__.vector(((n_pcor * (n_pcor - 1)) / 2)); + current_statement__ = 18; + assign(Lcorr, nil_index_list(), + stan::math::cholesky_corr_constrain(Lcorr_in__, n_pcor), + "assigning variable Lcorr"); + std::vector sigma_process; + sigma_process = std::vector(sigma_process_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 19; + for (int sym1__ = 1; sym1__ <= sigma_process_1dim__; ++sym1__) { + current_statement__ = 19; + assign(sigma_process, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable sigma_process");} + current_statement__ = 19; + for (int sym1__ = 1; sym1__ <= sigma_process_1dim__; ++sym1__) { + current_statement__ = 19; + assign(sigma_process, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(sigma_process[(sym1__ - 1)], 0), + "assigning variable sigma_process");} + std::vector> effectsKnots; + effectsKnots = std::vector>(effectsKnots_1dim__, Eigen::Matrix(effectsKnots_2dim__)); + stan::math::fill(effectsKnots, std::numeric_limits::quiet_NaN()); + + current_statement__ = 20; + for (int sym1__ = 1; sym1__ <= effectsKnots_1dim__; ++sym1__) { + current_statement__ = 20; + assign(effectsKnots, cons_list(index_uni(sym1__), nil_index_list()), + in__.vector(effectsKnots_2dim__), "assigning variable effectsKnots"); + } + Eigen::Matrix pred; + pred = Eigen::Matrix(P, N); + stan::math::fill(pred, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix Z; + Z = Eigen::Matrix(P, K); + stan::math::fill(Z, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix yall; + yall = Eigen::Matrix(P, N); + stan::math::fill(yall, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix sigma_vec; + sigma_vec = Eigen::Matrix(sigma_vec_1dim__); + stan::math::fill(sigma_vec, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix gamma_a_vec; + gamma_a_vec = Eigen::Matrix(gamma_a_vec_1dim__); + stan::math::fill(gamma_a_vec, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix nb_phi_vec; + nb_phi_vec = Eigen::Matrix(nb_phi_vec_1dim__); + stan::math::fill(nb_phi_vec, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix phi_vec; + phi_vec = Eigen::Matrix(K); + stan::math::fill(phi_vec, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix theta_vec; + theta_vec = Eigen::Matrix(K); + stan::math::fill(theta_vec, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix x; + x = Eigen::Matrix(K, N); + stan::math::fill(x, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix indicator; + indicator = Eigen::Matrix(K); + stan::math::fill(indicator, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix psi_root; + psi_root = Eigen::Matrix(psi_root_1dim__); + stan::math::fill(psi_root, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix Sigma_derived; + Sigma_derived = Eigen::Matrix(Sigma_derived_1dim__, Sigma_derived_2dim__); + stan::math::fill(Sigma_derived, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix Sigma_temp; + Sigma_temp = Eigen::Matrix(Sigma_temp_1dim__, Sigma_temp_2dim__); + stan::math::fill(Sigma_temp, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix sigma12_vec; + sigma12_vec = Eigen::Matrix(sigma12_vec_1dim__, 1); + stan::math::fill(sigma12_vec, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix temp_sums; + temp_sums = Eigen::Matrix(temp_sums_1dim__, temp_sums_2dim__); + stan::math::fill(temp_sums, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix temp_counts; + temp_counts = Eigen::Matrix(temp_counts_1dim__, temp_counts_2dim__); + stan::math::fill(temp_counts, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix cond_sigma_vec; + cond_sigma_vec = Eigen::Matrix(cond_sigma_vec_1dim__); + stan::math::fill(cond_sigma_vec, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix cond_mean_vec; + cond_mean_vec = Eigen::Matrix(cond_mean_vec_1dim__); + stan::math::fill(cond_mean_vec, std::numeric_limits::quiet_NaN()); + + double sigma11; + sigma11 = std::numeric_limits::quiet_NaN(); + + Eigen::Matrix sigma_pro; + sigma_pro = Eigen::Matrix(K); + stan::math::fill(sigma_pro, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix spline_a_trans; + spline_a_trans = Eigen::Matrix(spline_a_trans_1dim__, spline_a_trans_2dim__); + stan::math::fill(spline_a_trans, std::numeric_limits::quiet_NaN()); + + std::vector> SigmaKnots; + SigmaKnots = std::vector>(K, Eigen::Matrix(n_knots, n_knots)); + stan::math::fill(SigmaKnots, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix obs_cov_offset; + obs_cov_offset = Eigen::Matrix(n_pos); + stan::math::fill(obs_cov_offset, std::numeric_limits::quiet_NaN()); + + for (int sym1__ = 1; sym1__ <= devs_2dim__; ++sym1__) { + for (int sym2__ = 1; sym2__ <= devs_1dim__; ++sym2__) { + vars__.emplace_back( + rvalue(devs, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "devs"));}} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + vars__.emplace_back(x0[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= psi_1dim__; ++sym1__) { + vars__.emplace_back(psi[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= z_1dim__; ++sym1__) { + vars__.emplace_back(z[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= zpos_1dim__; ++sym1__) { + vars__.emplace_back(zpos[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + for (int sym2__ = 1; sym2__ <= p_z_1dim__; ++sym2__) { + vars__.emplace_back(p_z[(sym2__ - 1)][(sym1__ - 1)]);}} + for (int sym1__ = 1; sym1__ <= spline_a_2dim__; ++sym1__) { + for (int sym2__ = 1; sym2__ <= spline_a_1dim__; ++sym2__) { + vars__.emplace_back( + rvalue(spline_a, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "spline_a")); + }} + for (int sym1__ = 1; sym1__ <= P; ++sym1__) { + for (int sym2__ = 1; sym2__ <= n_obs_covar; ++sym2__) { + vars__.emplace_back( + rvalue(b_obs, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "b_obs"));}} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + for (int sym2__ = 1; sym2__ <= n_pro_covar; ++sym2__) { + vars__.emplace_back( + rvalue(b_pro, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "b_pro"));}} + for (int sym1__ = 1; sym1__ <= sigma_1dim__; ++sym1__) { + vars__.emplace_back(sigma[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= gamma_a_1dim__; ++sym1__) { + vars__.emplace_back(gamma_a[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= nb2_phi_1dim__; ++sym1__) { + vars__.emplace_back(nb2_phi[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= estimate_nu; ++sym1__) { + vars__.emplace_back(nu[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= n_na; ++sym1__) { + vars__.emplace_back(ymiss[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= phi_1dim__; ++sym1__) { + vars__.emplace_back(phi[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= theta_1dim__; ++sym1__) { + vars__.emplace_back(theta[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= gp_theta_1dim__; ++sym1__) { + vars__.emplace_back(gp_theta[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= n_pcor; ++sym1__) { + for (int sym2__ = 1; sym2__ <= n_pcor; ++sym2__) { + vars__.emplace_back( + rvalue(Lcorr, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "Lcorr"));}} + for (int sym1__ = 1; sym1__ <= sigma_process_1dim__; ++sym1__) { + vars__.emplace_back(sigma_process[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= effectsKnots_2dim__; ++sym1__) { + for (int sym2__ = 1; sym2__ <= effectsKnots_1dim__; ++sym2__) { + vars__.emplace_back(effectsKnots[(sym2__ - 1)][(sym1__ - 1)]);}} + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + current_statement__ = 53; + for (int k = 1; k <= K; ++k) { + current_statement__ = 44; + assign(sigma_pro, cons_list(index_uni(k), nil_index_list()), 1, + "assigning variable sigma_pro"); + current_statement__ = 51; + if (logical_eq(est_sigma_process, 1)) { + current_statement__ = 49; + if (logical_eq(n_sigma_process, 1)) { + current_statement__ = 47; + assign(sigma_pro, cons_list(index_uni(k), nil_index_list()), + sigma_process[(1 - 1)], "assigning variable sigma_pro"); + } else { + current_statement__ = 45; + assign(sigma_pro, cons_list(index_uni(k), nil_index_list()), + sigma_process[(k - 1)], "assigning variable sigma_pro"); + } + } } + current_statement__ = 62; + if (logical_eq(est_phi, 1)) { + current_statement__ = 60; + for (int k = 1; k <= K; ++k) { + current_statement__ = 58; + assign(phi_vec, cons_list(index_uni(k), nil_index_list()), + phi[(k - 1)], "assigning variable phi_vec");} + } else { + current_statement__ = 56; + for (int k = 1; k <= K; ++k) { + current_statement__ = 54; + assign(phi_vec, cons_list(index_uni(k), nil_index_list()), 1, + "assigning variable phi_vec");} + } + current_statement__ = 71; + if (logical_eq(est_theta, 1)) { + current_statement__ = 69; + for (int k = 1; k <= K; ++k) { + current_statement__ = 67; + assign(theta_vec, cons_list(index_uni(k), nil_index_list()), + theta[(k - 1)], "assigning variable theta_vec");} + } else { + current_statement__ = 65; + for (int k = 1; k <= K; ++k) { + current_statement__ = 63; + assign(theta_vec, cons_list(index_uni(k), nil_index_list()), 0, + "assigning variable theta_vec");} + } + current_statement__ = 76; + if (logical_eq(est_sigma_params, 1)) { + current_statement__ = 74; + for (int p = 1; p <= P; ++p) { + current_statement__ = 72; + assign(sigma_vec, cons_list(index_uni(p), nil_index_list()), + sigma[(varIndx[(p - 1)] - 1)], "assigning variable sigma_vec");} + } + current_statement__ = 81; + if (logical_eq(est_gamma_params, 1)) { + current_statement__ = 79; + for (int p = 1; p <= P; ++p) { + current_statement__ = 77; + assign(gamma_a_vec, cons_list(index_uni(p), nil_index_list()), + gamma_a[(varIndx[(p - 1)] - 1)], "assigning variable gamma_a_vec"); + } + } + current_statement__ = 86; + if (logical_eq(est_nb2_params, 1)) { + current_statement__ = 84; + for (int p = 1; p <= P; ++p) { + current_statement__ = 82; + assign(nb_phi_vec, cons_list(index_uni(p), nil_index_list()), + nb2_phi[(varIndx[(p - 1)] - 1)], "assigning variable nb_phi_vec"); + } + } + current_statement__ = 96; + if (logical_eq(long_format, 0)) { + current_statement__ = 89; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 87; + assign(yall, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), nil_index_list())), + y[(i - 1)], "assigning variable yall");} + current_statement__ = 94; + if (logical_gt(n_na, 0)) { + current_statement__ = 92; + for (int i = 1; i <= n_na; ++i) { + current_statement__ = 90; + assign(yall, + cons_list(index_uni(row_indx_na[(i - 1)]), + cons_list(index_uni(col_indx_na[(i - 1)]), nil_index_list())), + ymiss[(i - 1)], "assigning variable yall");} + } + } + current_statement__ = 156; + if (logical_eq(proportional_model, 0)) { + current_statement__ = 99; + for (int i = 1; i <= nZ; ++i) { + current_statement__ = 97; + assign(Z, + cons_list(index_uni(row_indx[(i - 1)]), + cons_list(index_uni(col_indx[(i - 1)]), nil_index_list())), + z[(i - 1)], "assigning variable Z");} + current_statement__ = 104; + if (logical_gt(nZero, 2)) { + current_statement__ = 102; + for (int i = 1; i <= (nZero - 2); ++i) { + current_statement__ = 100; + assign(Z, + cons_list(index_uni(row_indx_z[(i - 1)]), + cons_list(index_uni(col_indx_z[(i - 1)]), nil_index_list())), + 0, "assigning variable Z");} + } + current_statement__ = 107; + for (int k = 1; k <= K; ++k) { + current_statement__ = 105; + assign(Z, + cons_list(index_uni(k), + cons_list(index_uni(k), nil_index_list())), zpos[(k - 1)], + "assigning variable Z");} + current_statement__ = 120; + if (logical_eq(use_expansion_prior, 1)) { + current_statement__ = 118; + for (int k = 1; k <= K; ++k) { + current_statement__ = 112; + if (logical_lt(zpos[(k - 1)], 0)) { + current_statement__ = 110; + assign(indicator, cons_list(index_uni(k), nil_index_list()), + -1, "assigning variable indicator"); } else { - current_statement_begin__ = 248; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 248; - stan::model::assign(phi_vec, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - 1, - "assigning variable phi_vec"); - } - } - current_statement_begin__ = 253; - if (as_bool(logical_eq(est_theta, 1))) { - current_statement_begin__ = 254; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 254; - stan::model::assign(theta_vec, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - get_base1(theta, k, "theta", 1), - "assigning variable theta_vec"); - } + current_statement__ = 108; + assign(indicator, cons_list(index_uni(k), nil_index_list()), 1, + "assigning variable indicator"); + } + current_statement__ = 113; + assign(psi_root, cons_list(index_uni(k), nil_index_list()), + stan::math::sqrt(psi[(k - 1)]), "assigning variable psi_root"); + current_statement__ = 116; + for (int p = 1; p <= P; ++p) { + current_statement__ = 114; + assign(Z, + cons_list(index_uni(p), + cons_list(index_uni(k), nil_index_list())), + ((rvalue(Z, + cons_list(index_uni(p), + cons_list(index_uni(k), nil_index_list())), "Z") * + indicator[(k - 1)]) * (1 / psi_root[(k - 1)])), + "assigning variable Z");}} + } + current_statement__ = 128; + if (logical_eq(est_rw, 1)) { + current_statement__ = 126; + for (int k = 1; k <= K; ++k) { + current_statement__ = 121; + assign(x, + cons_list(index_uni(k), + cons_list(index_uni(1), nil_index_list())), x0[(k - 1)], + "assigning variable x"); + current_statement__ = 124; + for (int t = 2; t <= N; ++t) { + current_statement__ = 122; + assign(x, + cons_list(index_uni(k), + cons_list(index_uni(t), nil_index_list())), + ((phi_vec[(k - 1)] * + rvalue(x, + cons_list(index_uni(k), + cons_list(index_uni((t - 1)), nil_index_list())), "x")) + + + rvalue(devs, + cons_list(index_uni(k), + cons_list(index_uni((t - 1)), nil_index_list())), + "devs")), "assigning variable x");}} + } + current_statement__ = 136; + if (logical_eq(est_spline, 1)) { + current_statement__ = 130; + for (int k = 1; k <= K; ++k) { + current_statement__ = 129; + assign(spline_a_trans, cons_list(index_uni(k), nil_index_list()), + multiply( + rvalue(spline_a, cons_list(index_uni(k), nil_index_list()), + "spline_a"), sigma_pro[(k - 1)]), + "assigning variable spline_a_trans");} + current_statement__ = 131; + assign(x, nil_index_list(), + multiply(spline_a_trans, transpose(X_spline)), + "assigning variable x"); + current_statement__ = 134; + for (int k = 1; k <= K; ++k) { + current_statement__ = 132; + assign(x, cons_list(index_uni(k), nil_index_list()), + add(x0[(k - 1)], + stan::model::deep_copy( + rvalue(x, cons_list(index_uni(k), nil_index_list()), "x"))), + "assigning variable x");} + } + current_statement__ = 149; + if (logical_eq(est_gp, 1)) { + current_statement__ = 147; + for (int k = 1; k <= K; ++k) { + current_statement__ = 137; + assign(SigmaKnots, cons_list(index_uni(k), nil_index_list()), + cov_exp_quad(knot_locs, sigma_pro[(k - 1)], gp_theta[(k - 1)]), + "assigning variable SigmaKnots"); + current_statement__ = 140; + for (int i = 1; i <= n_knots; ++i) { + current_statement__ = 138; + assign(SigmaKnots, + cons_list(index_uni(k), + cons_list(index_uni(i), + cons_list(index_uni(i), nil_index_list()))), + (rvalue(SigmaKnots, + cons_list(index_uni(k), + cons_list(index_uni(i), + cons_list(index_uni(i), nil_index_list()))), + "SigmaKnots") + gp_delta), "assigning variable SigmaKnots"); + } + current_statement__ = 145; + if (logical_eq(n_knots, N)) { + current_statement__ = 143; + assign(x, cons_list(index_uni(k), nil_index_list()), + to_row_vector( + multiply(cholesky_decompose(SigmaKnots[(k - 1)]), + effectsKnots[(k - 1)])), "assigning variable x"); } else { - current_statement_begin__ = 257; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 257; - stan::model::assign(theta_vec, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - 0, - "assigning variable theta_vec"); - } - } - current_statement_begin__ = 261; - if (as_bool(logical_eq(est_sigma_params, 1))) { - current_statement_begin__ = 262; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 262; - stan::model::assign(sigma_vec, - stan::model::cons_list(stan::model::index_uni(p), stan::model::nil_index_list()), - get_base1(sigma, get_base1(varIndx, p, "varIndx", 1), "sigma", 1), - "assigning variable sigma_vec"); - } - } - current_statement_begin__ = 264; - if (as_bool(logical_eq(est_gamma_params, 1))) { - current_statement_begin__ = 265; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 265; - stan::model::assign(gamma_a_vec, - stan::model::cons_list(stan::model::index_uni(p), stan::model::nil_index_list()), - get_base1(gamma_a, get_base1(varIndx, p, "varIndx", 1), "gamma_a", 1), - "assigning variable gamma_a_vec"); - } - } - current_statement_begin__ = 267; - if (as_bool(logical_eq(est_nb2_params, 1))) { - current_statement_begin__ = 268; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 268; - stan::model::assign(nb_phi_vec, - stan::model::cons_list(stan::model::index_uni(p), stan::model::nil_index_list()), - get_base1(nb2_phi, get_base1(varIndx, p, "varIndx", 1), "nb2_phi", 1), - "assigning variable nb_phi_vec"); - } - } - current_statement_begin__ = 271; - if (as_bool(logical_eq(long_format, 0))) { - current_statement_begin__ = 273; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 274; - stan::model::assign(yall, - stan::model::cons_list(stan::model::index_uni(get_base1(row_indx_pos, i, "row_indx_pos", 1)), stan::model::cons_list(stan::model::index_uni(get_base1(col_indx_pos, i, "col_indx_pos", 1)), stan::model::nil_index_list())), - get_base1(y, i, "y", 1), - "assigning variable yall"); - } - current_statement_begin__ = 277; - if (as_bool(logical_gt(n_na, 0))) { - current_statement_begin__ = 278; - for (int i = 1; i <= n_na; ++i) { - current_statement_begin__ = 279; - stan::model::assign(yall, - stan::model::cons_list(stan::model::index_uni(get_base1(row_indx_na, i, "row_indx_na", 1)), stan::model::cons_list(stan::model::index_uni(get_base1(col_indx_na, i, "col_indx_na", 1)), stan::model::nil_index_list())), - get_base1(ymiss, i, "ymiss", 1), - "assigning variable yall"); - } - } - } - current_statement_begin__ = 284; - if (as_bool(logical_eq(proportional_model, 0))) { - current_statement_begin__ = 285; - for (int i = 1; i <= nZ; ++i) { - current_statement_begin__ = 286; - stan::model::assign(Z, - stan::model::cons_list(stan::model::index_uni(get_base1(row_indx, i, "row_indx", 1)), stan::model::cons_list(stan::model::index_uni(get_base1(col_indx, i, "col_indx", 1)), stan::model::nil_index_list())), - get_base1(z, i, "z", 1), - "assigning variable Z"); - } - current_statement_begin__ = 289; - if (as_bool(logical_gt(nZero, 2))) { - current_statement_begin__ = 290; - for (int i = 1; i <= (nZero - 2); ++i) { - current_statement_begin__ = 291; - stan::model::assign(Z, - stan::model::cons_list(stan::model::index_uni(get_base1(row_indx_z, i, "row_indx_z", 1)), stan::model::cons_list(stan::model::index_uni(get_base1(col_indx_z, i, "col_indx_z", 1)), stan::model::nil_index_list())), - 0, - "assigning variable Z"); - } - } - current_statement_begin__ = 294; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 295; - stan::model::assign(Z, - stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list())), - get_base1(zpos, k, "zpos", 1), - "assigning variable Z"); - } - current_statement_begin__ = 298; - if (as_bool(logical_eq(use_expansion_prior, 1))) { - current_statement_begin__ = 299; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 300; - if (as_bool(logical_lt(get_base1(zpos, k, "zpos", 1), 0))) { - current_statement_begin__ = 301; - stan::model::assign(indicator, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - -(1), - "assigning variable indicator"); - } else { - current_statement_begin__ = 303; - stan::model::assign(indicator, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - 1, - "assigning variable indicator"); - } - current_statement_begin__ = 306; - stan::model::assign(psi_root, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - stan::math::sqrt(get_base1(psi, k, "psi", 1)), - "assigning variable psi_root"); - current_statement_begin__ = 307; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 309; - stan::model::assign(Z, - stan::model::cons_list(stan::model::index_uni(p), stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list())), - ((get_base1(Z, p, k, "Z", 1) * get_base1(indicator, k, "indicator", 1)) * (1 / get_base1(psi_root, k, "psi_root", 1))), - "assigning variable Z"); - } - } - } - current_statement_begin__ = 315; - if (as_bool(logical_eq(est_rw, 1))) { - current_statement_begin__ = 316; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 317; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(1), stan::model::nil_index_list())), - get_base1(x0, k, "x0", 1), - "assigning variable x"); - current_statement_begin__ = 321; - for (int t = 2; t <= N; ++t) { - current_statement_begin__ = 322; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(t), stan::model::nil_index_list())), - ((get_base1(phi_vec, k, "phi_vec", 1) * get_base1(x, k, (t - 1), "x", 1)) + get_base1(devs, k, (t - 1), "devs", 1)), - "assigning variable x"); - } - } - } - current_statement_begin__ = 326; - if (as_bool(logical_eq(est_spline, 1))) { - current_statement_begin__ = 329; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 329; - stan::model::assign(spline_a_trans, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - multiply(get_base1(spline_a, k, "spline_a", 1), get_base1(sigma_pro, k, "sigma_pro", 1)), - "assigning variable spline_a_trans"); - } - current_statement_begin__ = 330; - stan::math::assign(x, multiply(spline_a_trans, transpose(X_spline))); - current_statement_begin__ = 331; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 331; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - add(get_base1(x0, k, "x0", 1), get_base1(x, k, "x", 1)), - "assigning variable x"); - } - } - current_statement_begin__ = 333; - if (as_bool(logical_eq(est_gp, 1))) { - current_statement_begin__ = 335; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 336; - stan::model::assign(SigmaKnots, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - cov_exp_quad(knot_locs, get_base1(sigma_pro, k, "sigma_pro", 1), get_base1(gp_theta, k, "gp_theta", 1)), - "assigning variable SigmaKnots"); - current_statement_begin__ = 339; - for (int i = 1; i <= n_knots; ++i) { - current_statement_begin__ = 340; - stan::model::assign(SigmaKnots, - stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(i), stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()))), - (stan::model::rvalue(SigmaKnots, stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(i), stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()))), "SigmaKnots") + gp_delta), - "assigning variable SigmaKnots"); - } - current_statement_begin__ = 349; - if (as_bool(logical_eq(n_knots, N))) { - current_statement_begin__ = 351; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - to_row_vector(multiply(cholesky_decompose(get_base1(SigmaKnots, k, "SigmaKnots", 1)), get_base1(effectsKnots, k, "effectsKnots", 1))), - "assigning variable x"); - } else { - current_statement_begin__ = 353; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - to_row_vector(multiply(multiply(multiply(cov_exp_quad(data_locs, knot_locs, get_base1(sigma_pro, k, "sigma_pro", 1), get_base1(gp_theta, k, "gp_theta", 1)), inverse_spd(get_base1(SigmaKnots, k, "SigmaKnots", 1))), cholesky_decompose(get_base1(SigmaKnots, k, "SigmaKnots", 1))), get_base1(effectsKnots, k, "effectsKnots", 1))), - "assigning variable x"); - } - } - } - current_statement_begin__ = 359; - if (as_bool(logical_eq(use_expansion_prior, 1))) { - current_statement_begin__ = 360; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 363; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - multiply(multiply(get_base1(x, k, "x", 1), get_base1(indicator, k, "indicator", 1)), get_base1(psi_root, k, "psi_root", 1)), - "assigning variable x"); - } - } - } - current_statement_begin__ = 368; - if (as_bool(logical_eq(proportional_model, 1))) { - current_statement_begin__ = 370; - if (as_bool(logical_eq(est_rw, 1))) { - current_statement_begin__ = 371; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 372; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(1), stan::model::nil_index_list())), - get_base1(x0, k, "x0", 1), - "assigning variable x"); - current_statement_begin__ = 376; - for (int t = 2; t <= N; ++t) { - current_statement_begin__ = 377; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(t), stan::model::nil_index_list())), - ((get_base1(phi_vec, k, "phi_vec", 1) * get_base1(x, k, (t - 1), "x", 1)) + get_base1(devs, k, (t - 1), "devs", 1)), - "assigning variable x"); - } - } - } - current_statement_begin__ = 381; - if (as_bool(logical_eq(est_spline, 1))) { - current_statement_begin__ = 382; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 382; - stan::model::assign(spline_a_trans, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - multiply(get_base1(spline_a, k, "spline_a", 1), get_base1(sigma_pro, k, "sigma_pro", 1)), - "assigning variable spline_a_trans"); - } - current_statement_begin__ = 383; - stan::math::assign(x, multiply(spline_a_trans, transpose(X_spline))); - current_statement_begin__ = 384; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 384; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - add(get_base1(x0, k, "x0", 1), get_base1(x, k, "x", 1)), - "assigning variable x"); - } - } - current_statement_begin__ = 386; - if (as_bool(logical_eq(est_gp, 1))) { - current_statement_begin__ = 387; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 388; - stan::model::assign(SigmaKnots, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - cov_exp_quad(knot_locs, get_base1(sigma_pro, k, "sigma_pro", 1), get_base1(gp_theta, k, "gp_theta", 1)), - "assigning variable SigmaKnots"); - current_statement_begin__ = 391; - for (int i = 1; i <= n_knots; ++i) { - current_statement_begin__ = 392; - stan::model::assign(SigmaKnots, - stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(i), stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()))), - (stan::model::rvalue(SigmaKnots, stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(i), stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()))), "SigmaKnots") + gp_delta), - "assigning variable SigmaKnots"); - } - current_statement_begin__ = 401; - if (as_bool(logical_eq(n_knots, N))) { - current_statement_begin__ = 403; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - to_row_vector(multiply(cholesky_decompose(get_base1(SigmaKnots, k, "SigmaKnots", 1)), get_base1(effectsKnots, k, "effectsKnots", 1))), - "assigning variable x"); - } else { - current_statement_begin__ = 405; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - to_row_vector(multiply(multiply(multiply(cov_exp_quad(data_locs, knot_locs, get_base1(sigma_pro, k, "sigma_pro", 1), get_base1(gp_theta, k, "gp_theta", 1)), inverse_spd(get_base1(SigmaKnots, k, "SigmaKnots", 1))), cholesky_decompose(get_base1(SigmaKnots, k, "SigmaKnots", 1))), get_base1(effectsKnots, k, "effectsKnots", 1))), - "assigning variable x"); - } - } - } - current_statement_begin__ = 411; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 415; - stan::model::assign(Z, - stan::model::cons_list(stan::model::index_uni(p), stan::model::nil_index_list()), - to_row_vector(get_base1(p_z, p, "p_z", 1)), - "assigning variable Z"); - } - } - current_statement_begin__ = 420; - if (as_bool(logical_gt(num_pro_covar, 0))) { - current_statement_begin__ = 421; - for (int i = 1; i <= num_pro_covar; ++i) { - current_statement_begin__ = 423; - stan::model::assign(x, - stan::model::cons_list(stan::model::index_uni(get_base1(get_base1(pro_covar_index, i, "pro_covar_index", 1), 2, "pro_covar_index", 2)), stan::model::cons_list(stan::model::index_uni(get_base1(get_base1(pro_covar_index, i, "pro_covar_index", 1), 1, "pro_covar_index", 2)), stan::model::nil_index_list())), - (stan::model::rvalue(x, stan::model::cons_list(stan::model::index_uni(get_base1(get_base1(pro_covar_index, i, "pro_covar_index", 1), 2, "pro_covar_index", 2)), stan::model::cons_list(stan::model::index_uni(get_base1(get_base1(pro_covar_index, i, "pro_covar_index", 1), 1, "pro_covar_index", 2)), stan::model::nil_index_list())), "x") + (get_base1(b_pro, get_base1(get_base1(pro_covar_index, i, "pro_covar_index", 1), 3, "pro_covar_index", 2), get_base1(get_base1(pro_covar_index, i, "pro_covar_index", 1), 2, "pro_covar_index", 2), "b_pro", 1) * get_base1(pro_covar_value, i, "pro_covar_value", 1))), - "assigning variable x"); - } - } - current_statement_begin__ = 429; - stan::math::assign(pred, multiply(Z, x)); - current_statement_begin__ = 432; + current_statement__ = 141; + assign(x, cons_list(index_uni(k), nil_index_list()), + to_row_vector( + multiply( + multiply( + multiply( + cov_exp_quad(data_locs, knot_locs, + sigma_pro[(k - 1)], gp_theta[(k - 1)]), + inverse_spd(SigmaKnots[(k - 1)])), + cholesky_decompose(SigmaKnots[(k - 1)])), + effectsKnots[(k - 1)])), "assigning variable x"); + }} + } + current_statement__ = 154; + if (logical_eq(use_expansion_prior, 1)) { + current_statement__ = 152; + for (int k = 1; k <= K; ++k) { + current_statement__ = 150; + assign(x, cons_list(index_uni(k), nil_index_list()), + multiply( + multiply( + stan::model::deep_copy( + rvalue(x, cons_list(index_uni(k), nil_index_list()), "x")), + indicator[(k - 1)]), psi_root[(k - 1)]), + "assigning variable x");} + } + } + current_statement__ = 190; + if (logical_eq(proportional_model, 1)) { + current_statement__ = 164; + if (logical_eq(est_rw, 1)) { + current_statement__ = 162; + for (int k = 1; k <= K; ++k) { + current_statement__ = 157; + assign(x, + cons_list(index_uni(k), + cons_list(index_uni(1), nil_index_list())), x0[(k - 1)], + "assigning variable x"); + current_statement__ = 160; + for (int t = 2; t <= N; ++t) { + current_statement__ = 158; + assign(x, + cons_list(index_uni(k), + cons_list(index_uni(t), nil_index_list())), + ((phi_vec[(k - 1)] * + rvalue(x, + cons_list(index_uni(k), + cons_list(index_uni((t - 1)), nil_index_list())), "x")) + + + rvalue(devs, + cons_list(index_uni(k), + cons_list(index_uni((t - 1)), nil_index_list())), + "devs")), "assigning variable x");}} + } + current_statement__ = 172; + if (logical_eq(est_spline, 1)) { + current_statement__ = 166; + for (int k = 1; k <= K; ++k) { + current_statement__ = 165; + assign(spline_a_trans, cons_list(index_uni(k), nil_index_list()), + multiply( + rvalue(spline_a, cons_list(index_uni(k), nil_index_list()), + "spline_a"), sigma_pro[(k - 1)]), + "assigning variable spline_a_trans");} + current_statement__ = 167; + assign(x, nil_index_list(), + multiply(spline_a_trans, transpose(X_spline)), + "assigning variable x"); + current_statement__ = 170; + for (int k = 1; k <= K; ++k) { + current_statement__ = 168; + assign(x, cons_list(index_uni(k), nil_index_list()), + add(x0[(k - 1)], + stan::model::deep_copy( + rvalue(x, cons_list(index_uni(k), nil_index_list()), "x"))), + "assigning variable x");} + } + current_statement__ = 185; + if (logical_eq(est_gp, 1)) { + current_statement__ = 183; + for (int k = 1; k <= K; ++k) { + current_statement__ = 173; + assign(SigmaKnots, cons_list(index_uni(k), nil_index_list()), + cov_exp_quad(knot_locs, sigma_pro[(k - 1)], gp_theta[(k - 1)]), + "assigning variable SigmaKnots"); + current_statement__ = 176; + for (int i = 1; i <= n_knots; ++i) { + current_statement__ = 174; + assign(SigmaKnots, + cons_list(index_uni(k), + cons_list(index_uni(i), + cons_list(index_uni(i), nil_index_list()))), + (rvalue(SigmaKnots, + cons_list(index_uni(k), + cons_list(index_uni(i), + cons_list(index_uni(i), nil_index_list()))), + "SigmaKnots") + gp_delta), "assigning variable SigmaKnots"); + } + current_statement__ = 181; + if (logical_eq(n_knots, N)) { + current_statement__ = 179; + assign(x, cons_list(index_uni(k), nil_index_list()), + to_row_vector( + multiply(cholesky_decompose(SigmaKnots[(k - 1)]), + effectsKnots[(k - 1)])), "assigning variable x"); + } else { + current_statement__ = 177; + assign(x, cons_list(index_uni(k), nil_index_list()), + to_row_vector( + multiply( + multiply( + multiply( + cov_exp_quad(data_locs, knot_locs, + sigma_pro[(k - 1)], gp_theta[(k - 1)]), + inverse_spd(SigmaKnots[(k - 1)])), + cholesky_decompose(SigmaKnots[(k - 1)])), + effectsKnots[(k - 1)])), "assigning variable x"); + }} + } + current_statement__ = 188; + for (int p = 1; p <= P; ++p) { + current_statement__ = 186; + assign(Z, cons_list(index_uni(p), nil_index_list()), + to_row_vector(p_z[(p - 1)]), "assigning variable Z");} + } + current_statement__ = 195; + if (logical_gt(num_pro_covar, 0)) { + current_statement__ = 193; + for (int i = 1; i <= num_pro_covar; ++i) { + current_statement__ = 191; + assign(x, + cons_list(index_uni(pro_covar_index[(i - 1)][(2 - 1)]), + cons_list(index_uni(pro_covar_index[(i - 1)][(1 - 1)]), + nil_index_list())), + (rvalue(x, + cons_list(index_uni(pro_covar_index[(i - 1)][(2 - 1)]), + cons_list(index_uni(pro_covar_index[(i - 1)][(1 - 1)]), + nil_index_list())), "x") + + (rvalue(b_pro, + cons_list(index_uni(pro_covar_index[(i - 1)][(3 - 1)]), + cons_list(index_uni(pro_covar_index[(i - 1)][(2 - 1)]), + nil_index_list())), "b_pro") * pro_covar_value[(i - 1)])), + "assigning variable x");} + } + current_statement__ = 196; + assign(pred, nil_index_list(), multiply(Z, x), + "assigning variable pred"); + current_statement__ = 199; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 197; + assign(obs_cov_offset, cons_list(index_uni(i), nil_index_list()), 0, + "assigning variable obs_cov_offset");} + current_statement__ = 210; + if (logical_gt(num_obs_covar, 0)) { + current_statement__ = 208; + if (logical_eq(long_format, 0)) { + current_statement__ = 206; + for (int i = 1; i <= num_obs_covar; ++i) { + current_statement__ = 204; + assign(pred, + cons_list(index_uni(obs_covar_index[(i - 1)][(2 - 1)]), + cons_list(index_uni(obs_covar_index[(i - 1)][(1 - 1)]), + nil_index_list())), + (rvalue(pred, + cons_list(index_uni(obs_covar_index[(i - 1)][(2 - 1)]), + cons_list(index_uni(obs_covar_index[(i - 1)][(1 - 1)]), + nil_index_list())), "pred") + + (rvalue(b_obs, + cons_list(index_uni(obs_covar_index[(i - 1)][(3 - 1)]), + cons_list(index_uni(obs_covar_index[(i - 1)][(2 - 1)]), + nil_index_list())), "b_obs") * + obs_covar_value[(i - 1)])), "assigning variable pred");} + } else { + current_statement__ = 202; + for (int i = 1; i <= num_obs_covar; ++i) { + current_statement__ = 200; + assign(obs_cov_offset, + cons_list(index_uni(match_obs_covar[(i - 1)]), + nil_index_list()), + (obs_cov_offset[(match_obs_covar[(i - 1)] - 1)] + + (rvalue(b_obs, + cons_list(index_uni(obs_covar_index[(i - 1)][(3 - 1)]), + cons_list(index_uni(obs_covar_index[(i - 1)][(2 - 1)]), + nil_index_list())), "b_obs") * + obs_covar_value[(i - 1)])), + "assigning variable obs_cov_offset");} + } + } + current_statement__ = 235; + if ((primitive_value(logical_eq(long_format, 1)) && primitive_value( + logical_eq(est_cor, 1)))) { + current_statement__ = 216; + for (int n = 1; n <= N; ++n) { + current_statement__ = 214; + for (int p = 1; p <= P; ++p) { + current_statement__ = 211; + assign(temp_sums, + cons_list(index_uni(p), + cons_list(index_uni(n), nil_index_list())), 0.0, + "assigning variable temp_sums"); + current_statement__ = 212; + assign(temp_counts, + cons_list(index_uni(p), + cons_list(index_uni(n), nil_index_list())), 0.0, + "assigning variable temp_counts");}} + current_statement__ = 220; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 217; + assign(temp_sums, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), nil_index_list())), + (rvalue(temp_sums, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "temp_sums") + + (y[(i - 1)] - + rvalue(pred, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "pred"))), + "assigning variable temp_sums"); + current_statement__ = 218; + assign(temp_counts, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), nil_index_list())), + (rvalue(temp_counts, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "temp_counts") + 1), + "assigning variable temp_counts");} + current_statement__ = 225; + for (int n = 1; n <= N; ++n) { + current_statement__ = 223; + for (int p = 1; p <= P; ++p) { + current_statement__ = 221; + assign(temp_sums, + cons_list(index_uni(p), + cons_list(index_uni(n), nil_index_list())), + (rvalue(temp_sums, + cons_list(index_uni(p), + cons_list(index_uni(n), nil_index_list())), "temp_sums") / + rvalue(temp_counts, + cons_list(index_uni(p), + cons_list(index_uni(n), nil_index_list())), + "temp_counts")), "assigning variable temp_sums");}} + current_statement__ = 226; + assign(Sigma_derived, nil_index_list(), + quad_form_diag(multiply_lower_tri_self_transpose(Lcorr), sigma_vec), + "assigning variable Sigma_derived"); + current_statement__ = 233; + for (int p = 1; p <= P; ++p) { + current_statement__ = 227; + sigma11 = rvalue(Sigma_derived, + cons_list(index_uni(p), + cons_list(index_uni(p), nil_index_list())), + "Sigma_derived"); + current_statement__ = 228; + assign(Sigma_temp, nil_index_list(), + inverse(subset(Sigma_derived, p, P, pstream__)), + "assigning variable Sigma_temp"); + current_statement__ = 229; + assign(sigma12_vec, nil_index_list(), + subsetvec(Sigma_derived, p, P, pstream__), + "assigning variable sigma12_vec"); + current_statement__ = 230; + assign(cond_mean_vec, cons_list(index_uni(p), nil_index_list()), + multiply(multiply(to_row_vector(sigma12_vec), Sigma_temp), + to_vector(subsetvec2(col(temp_sums, p), p, P, pstream__))), + "assigning variable cond_mean_vec"); + current_statement__ = 231; + assign(cond_sigma_vec, cons_list(index_uni(p), nil_index_list()), + stan::math::sqrt( + (sigma11 - + multiply(multiply(to_row_vector(sigma12_vec), Sigma_temp), + to_vector(sigma12_vec)))), + "assigning variable cond_sigma_vec");} + } + current_statement__ = 24; + for (int sym1__ = 1; sym1__ <= sigma_vec_1dim__; ++sym1__) { + current_statement__ = 24; + current_statement__ = 24; + check_greater_or_equal(function__, "sigma_vec[sym1__]", + sigma_vec[(sym1__ - 1)], 0);} + current_statement__ = 25; + for (int sym1__ = 1; sym1__ <= gamma_a_vec_1dim__; ++sym1__) { + current_statement__ = 25; + current_statement__ = 25; + check_greater_or_equal(function__, "gamma_a_vec[sym1__]", + gamma_a_vec[(sym1__ - 1)], 0);} + current_statement__ = 26; + for (int sym1__ = 1; sym1__ <= nb_phi_vec_1dim__; ++sym1__) { + current_statement__ = 26; + current_statement__ = 26; + check_greater_or_equal(function__, "nb_phi_vec[sym1__]", + nb_phi_vec[(sym1__ - 1)], 0);} + current_statement__ = 31; + for (int sym1__ = 1; sym1__ <= psi_root_1dim__; ++sym1__) { + current_statement__ = 31; + current_statement__ = 31; + check_greater_or_equal(function__, "psi_root[sym1__]", + psi_root[(sym1__ - 1)], 0);} + if (emit_transformed_parameters__) { + for (int sym1__ = 1; sym1__ <= N; ++sym1__) { + for (int sym2__ = 1; sym2__ <= P; ++sym2__) { + vars__.emplace_back( + rvalue(pred, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "pred"));} + } + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + for (int sym2__ = 1; sym2__ <= P; ++sym2__) { + vars__.emplace_back( + rvalue(Z, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "Z"));}} + for (int sym1__ = 1; sym1__ <= N; ++sym1__) { + for (int sym2__ = 1; sym2__ <= P; ++sym2__) { + vars__.emplace_back( + rvalue(yall, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "yall"));} + } + for (int sym1__ = 1; sym1__ <= sigma_vec_1dim__; ++sym1__) { + vars__.emplace_back(sigma_vec[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= gamma_a_vec_1dim__; ++sym1__) { + vars__.emplace_back(gamma_a_vec[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= nb_phi_vec_1dim__; ++sym1__) { + vars__.emplace_back(nb_phi_vec[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + vars__.emplace_back(phi_vec[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + vars__.emplace_back(theta_vec[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= N; ++sym1__) { + for (int sym2__ = 1; sym2__ <= K; ++sym2__) { + vars__.emplace_back( + rvalue(x, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "x"));}} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + vars__.emplace_back(indicator[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= psi_root_1dim__; ++sym1__) { + vars__.emplace_back(psi_root[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= Sigma_derived_2dim__; ++sym1__) { + for (int sym2__ = 1; sym2__ <= Sigma_derived_1dim__; ++sym2__) { + vars__.emplace_back( + rvalue(Sigma_derived, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "Sigma_derived"));}} + for (int sym1__ = 1; sym1__ <= Sigma_temp_2dim__; ++sym1__) { + for (int sym2__ = 1; sym2__ <= Sigma_temp_1dim__; ++sym2__) { + vars__.emplace_back( + rvalue(Sigma_temp, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "Sigma_temp"));}} + for (int sym1__ = 1; sym1__ <= 1; ++sym1__) { + for (int sym2__ = 1; sym2__ <= sigma12_vec_1dim__; ++sym2__) { + vars__.emplace_back( + rvalue(sigma12_vec, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "sigma12_vec"));}} + for (int sym1__ = 1; sym1__ <= temp_sums_2dim__; ++sym1__) { + for (int sym2__ = 1; sym2__ <= temp_sums_1dim__; ++sym2__) { + vars__.emplace_back( + rvalue(temp_sums, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "temp_sums"));}} + for (int sym1__ = 1; sym1__ <= temp_counts_2dim__; ++sym1__) { + for (int sym2__ = 1; sym2__ <= temp_counts_1dim__; ++sym2__) { + vars__.emplace_back( + rvalue(temp_counts, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "temp_counts"));}} + for (int sym1__ = 1; sym1__ <= cond_sigma_vec_1dim__; ++sym1__) { + vars__.emplace_back(cond_sigma_vec[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= cond_mean_vec_1dim__; ++sym1__) { + vars__.emplace_back(cond_mean_vec[(sym1__ - 1)]);} + vars__.emplace_back(sigma11); + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + vars__.emplace_back(sigma_pro[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= spline_a_trans_2dim__; ++sym1__) { + for (int sym2__ = 1; sym2__ <= spline_a_trans_1dim__; ++sym2__) { + vars__.emplace_back( + rvalue(spline_a_trans, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "spline_a_trans"));}} + for (int sym1__ = 1; sym1__ <= n_knots; ++sym1__) { + for (int sym2__ = 1; sym2__ <= n_knots; ++sym2__) { + for (int sym3__ = 1; sym3__ <= K; ++sym3__) { + vars__.emplace_back( + rvalue(SigmaKnots, + cons_list(index_uni(sym3__), + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list()))), + "SigmaKnots"));}}} + for (int sym1__ = 1; sym1__ <= n_pos; ++sym1__) { + vars__.emplace_back(obs_cov_offset[(sym1__ - 1)]);} + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + Eigen::Matrix log_lik; + log_lik = Eigen::Matrix(n_loglik); + stan::math::fill(log_lik, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix Omega; + Omega = Eigen::Matrix(n_pcor, n_pcor); + stan::math::fill(Omega, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix Sigma; + Sigma = Eigen::Matrix(n_pcor, n_pcor); + stan::math::fill(Sigma, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix xstar; + xstar = Eigen::Matrix(K, 1); + stan::math::fill(xstar, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix future_devs; + future_devs = Eigen::Matrix(K); + stan::math::fill(future_devs, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix SigmaKnots_pred; + SigmaKnots_pred = Eigen::Matrix(n_knots, n_knots); + stan::math::fill(SigmaKnots_pred, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix SigmaOffDiag_pred; + SigmaOffDiag_pred = Eigen::Matrix(n_knots); + stan::math::fill(SigmaOffDiag_pred, std::numeric_limits::quiet_NaN()); + + int j; + j = std::numeric_limits::min(); + + current_statement__ = 244; + j = 0; + current_statement__ = 248; + if (logical_eq(est_cor, 1)) { + current_statement__ = 245; + assign(Omega, nil_index_list(), + multiply_lower_tri_self_transpose(Lcorr), + "assigning variable Omega"); + current_statement__ = 246; + assign(Sigma, nil_index_list(), quad_form_diag(Omega, sigma_vec), + "assigning variable Sigma"); + } + current_statement__ = 294; + if (logical_eq(est_cor, 0)) { + current_statement__ = 292; + if (logical_eq(long_format, 0)) { + current_statement__ = 284; + j = 0; + current_statement__ = 290; + for (int n = 1; n <= N; ++n) { + current_statement__ = 288; + for (int p = 1; p <= P; ++p) { + current_statement__ = 285; + j = (j + 1); + current_statement__ = 286; + assign(log_lik, cons_list(index_uni(j), nil_index_list()), + normal_lpdf( + rvalue(yall, + cons_list(index_uni(p), + cons_list(index_uni(n), nil_index_list())), "yall"), + rvalue(pred, + cons_list(index_uni(p), + cons_list(index_uni(n), nil_index_list())), "pred"), + sigma_vec[(p - 1)]), "assigning variable log_lik");}} + } else { + current_statement__ = 262; + if (logical_eq(obs_model, 1)) { + current_statement__ = 260; for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 433; - stan::model::assign(obs_cov_offset, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - 0, - "assigning variable obs_cov_offset"); - } - current_statement_begin__ = 436; - if (as_bool(logical_gt(num_obs_covar, 0))) { - current_statement_begin__ = 437; - if (as_bool(logical_eq(long_format, 0))) { - current_statement_begin__ = 438; - for (int i = 1; i <= num_obs_covar; ++i) { - current_statement_begin__ = 441; - stan::model::assign(pred, - stan::model::cons_list(stan::model::index_uni(get_base1(get_base1(obs_covar_index, i, "obs_covar_index", 1), 2, "obs_covar_index", 2)), stan::model::cons_list(stan::model::index_uni(get_base1(get_base1(obs_covar_index, i, "obs_covar_index", 1), 1, "obs_covar_index", 2)), stan::model::nil_index_list())), - (stan::model::rvalue(pred, stan::model::cons_list(stan::model::index_uni(get_base1(get_base1(obs_covar_index, i, "obs_covar_index", 1), 2, "obs_covar_index", 2)), stan::model::cons_list(stan::model::index_uni(get_base1(get_base1(obs_covar_index, i, "obs_covar_index", 1), 1, "obs_covar_index", 2)), stan::model::nil_index_list())), "pred") + (get_base1(b_obs, get_base1(get_base1(obs_covar_index, i, "obs_covar_index", 1), 3, "obs_covar_index", 2), get_base1(get_base1(obs_covar_index, i, "obs_covar_index", 1), 2, "obs_covar_index", 2), "b_obs", 1) * get_base1(obs_covar_value, i, "obs_covar_value", 1))), - "assigning variable pred"); - } - } else { - current_statement_begin__ = 446; - for (int i = 1; i <= num_obs_covar; ++i) { - current_statement_begin__ = 447; - stan::model::assign(obs_cov_offset, - stan::model::cons_list(stan::model::index_uni(get_base1(match_obs_covar, i, "match_obs_covar", 1)), stan::model::nil_index_list()), - (stan::model::rvalue(obs_cov_offset, stan::model::cons_list(stan::model::index_uni(get_base1(match_obs_covar, i, "match_obs_covar", 1)), stan::model::nil_index_list()), "obs_cov_offset") + (get_base1(b_obs, get_base1(get_base1(obs_covar_index, i, "obs_covar_index", 1), 3, "obs_covar_index", 2), get_base1(get_base1(obs_covar_index, i, "obs_covar_index", 1), 2, "obs_covar_index", 2), "b_obs", 1) * get_base1(obs_covar_value, i, "obs_covar_value", 1))), - "assigning variable obs_cov_offset"); - } - } - } - current_statement_begin__ = 452; - if (as_bool((primitive_value(logical_eq(long_format, 1)) && primitive_value(logical_eq(est_cor, 1))))) { - current_statement_begin__ = 454; - for (int n = 1; n <= N; ++n) { - current_statement_begin__ = 455; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 456; - stan::model::assign(temp_sums, - stan::model::cons_list(stan::model::index_uni(p), stan::model::cons_list(stan::model::index_uni(n), stan::model::nil_index_list())), - 0.0, - "assigning variable temp_sums"); - current_statement_begin__ = 457; - stan::model::assign(temp_counts, - stan::model::cons_list(stan::model::index_uni(p), stan::model::cons_list(stan::model::index_uni(n), stan::model::nil_index_list())), - 0.0, - "assigning variable temp_counts"); - } - } - current_statement_begin__ = 460; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 461; - stan::model::assign(temp_sums, - stan::model::cons_list(stan::model::index_uni(get_base1(row_indx_pos, i, "row_indx_pos", 1)), stan::model::cons_list(stan::model::index_uni(get_base1(col_indx_pos, i, "col_indx_pos", 1)), stan::model::nil_index_list())), - (stan::model::rvalue(temp_sums, stan::model::cons_list(stan::model::index_uni(get_base1(row_indx_pos, i, "row_indx_pos", 1)), stan::model::cons_list(stan::model::index_uni(get_base1(col_indx_pos, i, "col_indx_pos", 1)), stan::model::nil_index_list())), "temp_sums") + (get_base1(y, i, "y", 1) - get_base1(pred, get_base1(row_indx_pos, i, "row_indx_pos", 1), get_base1(col_indx_pos, i, "col_indx_pos", 1), "pred", 1))), - "assigning variable temp_sums"); - current_statement_begin__ = 462; - stan::model::assign(temp_counts, - stan::model::cons_list(stan::model::index_uni(get_base1(row_indx_pos, i, "row_indx_pos", 1)), stan::model::cons_list(stan::model::index_uni(get_base1(col_indx_pos, i, "col_indx_pos", 1)), stan::model::nil_index_list())), - (stan::model::rvalue(temp_counts, stan::model::cons_list(stan::model::index_uni(get_base1(row_indx_pos, i, "row_indx_pos", 1)), stan::model::cons_list(stan::model::index_uni(get_base1(col_indx_pos, i, "col_indx_pos", 1)), stan::model::nil_index_list())), "temp_counts") + 1), - "assigning variable temp_counts"); - } - current_statement_begin__ = 464; - for (int n = 1; n <= N; ++n) { - current_statement_begin__ = 465; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 467; - stan::model::assign(temp_sums, - stan::model::cons_list(stan::model::index_uni(p), stan::model::cons_list(stan::model::index_uni(n), stan::model::nil_index_list())), - (get_base1(temp_sums, p, n, "temp_sums", 1) / get_base1(temp_counts, p, n, "temp_counts", 1)), - "assigning variable temp_sums"); - } - } - current_statement_begin__ = 471; - stan::math::assign(Sigma_derived, quad_form_diag(multiply_lower_tri_self_transpose(Lcorr), sigma_vec)); - current_statement_begin__ = 473; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 474; - stan::math::assign(sigma11, get_base1(Sigma_derived, p, p, "Sigma_derived", 1)); - current_statement_begin__ = 475; - stan::math::assign(Sigma_temp, inverse(subset(Sigma_derived, p, P, pstream__))); - current_statement_begin__ = 476; - stan::math::assign(sigma12_vec, subsetvec(Sigma_derived, p, P, pstream__)); - current_statement_begin__ = 478; - stan::model::assign(cond_mean_vec, - stan::model::cons_list(stan::model::index_uni(p), stan::model::nil_index_list()), - multiply(multiply(to_row_vector(sigma12_vec), Sigma_temp), to_vector(subsetvec2(col(temp_sums, p), p, P, pstream__))), - "assigning variable cond_mean_vec"); - current_statement_begin__ = 480; - stan::model::assign(cond_sigma_vec, - stan::model::cons_list(stan::model::index_uni(p), stan::model::nil_index_list()), - stan::math::sqrt((sigma11 - multiply(multiply(to_row_vector(sigma12_vec), Sigma_temp), to_vector(sigma12_vec)))), - "assigning variable cond_sigma_vec"); - } - } - if (!include_gqs__ && !include_tparams__) return; - // validate transformed parameters - const char* function__ = "validate transformed params"; - (void) function__; // dummy to suppress unused var warning - current_statement_begin__ = 208; - check_greater_or_equal(function__, "sigma_vec", sigma_vec, 0); - current_statement_begin__ = 209; - check_greater_or_equal(function__, "gamma_a_vec", gamma_a_vec, 0); - current_statement_begin__ = 210; - check_greater_or_equal(function__, "nb_phi_vec", nb_phi_vec, 0); - current_statement_begin__ = 215; - check_greater_or_equal(function__, "psi_root", psi_root, 0); - // write transformed parameters - if (include_tparams__) { - size_t pred_j_2_max__ = N; - size_t pred_j_1_max__ = P; - for (size_t j_2__ = 0; j_2__ < pred_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < pred_j_1_max__; ++j_1__) { - vars__.push_back(pred(j_1__, j_2__)); - } - } - size_t Z_j_2_max__ = K; - size_t Z_j_1_max__ = P; - for (size_t j_2__ = 0; j_2__ < Z_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Z_j_1_max__; ++j_1__) { - vars__.push_back(Z(j_1__, j_2__)); - } - } - size_t yall_j_2_max__ = N; - size_t yall_j_1_max__ = P; - for (size_t j_2__ = 0; j_2__ < yall_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < yall_j_1_max__; ++j_1__) { - vars__.push_back(yall(j_1__, j_2__)); - } - } - size_t sigma_vec_j_1_max__ = (P * est_sigma_params); - for (size_t j_1__ = 0; j_1__ < sigma_vec_j_1_max__; ++j_1__) { - vars__.push_back(sigma_vec(j_1__)); - } - size_t gamma_a_vec_j_1_max__ = (P * est_gamma_params); - for (size_t j_1__ = 0; j_1__ < gamma_a_vec_j_1_max__; ++j_1__) { - vars__.push_back(gamma_a_vec(j_1__)); - } - size_t nb_phi_vec_j_1_max__ = (P * est_nb2_params); - for (size_t j_1__ = 0; j_1__ < nb_phi_vec_j_1_max__; ++j_1__) { - vars__.push_back(nb_phi_vec(j_1__)); - } - size_t phi_vec_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < phi_vec_j_1_max__; ++j_1__) { - vars__.push_back(phi_vec(j_1__)); - } - size_t theta_vec_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < theta_vec_j_1_max__; ++j_1__) { - vars__.push_back(theta_vec(j_1__)); - } - size_t x_j_2_max__ = N; - size_t x_j_1_max__ = K; - for (size_t j_2__ = 0; j_2__ < x_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < x_j_1_max__; ++j_1__) { - vars__.push_back(x(j_1__, j_2__)); - } - } - size_t indicator_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < indicator_j_1_max__; ++j_1__) { - vars__.push_back(indicator(j_1__)); - } - size_t psi_root_j_1_max__ = (K * use_expansion_prior); - for (size_t j_1__ = 0; j_1__ < psi_root_j_1_max__; ++j_1__) { - vars__.push_back(psi_root(j_1__)); - } - size_t Sigma_derived_j_2_max__ = ((n_pcor * long_format) * est_cor); - size_t Sigma_derived_j_1_max__ = ((n_pcor * long_format) * est_cor); - for (size_t j_2__ = 0; j_2__ < Sigma_derived_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Sigma_derived_j_1_max__; ++j_1__) { - vars__.push_back(Sigma_derived(j_1__, j_2__)); - } - } - size_t Sigma_temp_j_2_max__ = (((n_pcor - 1) * long_format) * est_cor); - size_t Sigma_temp_j_1_max__ = (((n_pcor - 1) * long_format) * est_cor); - for (size_t j_2__ = 0; j_2__ < Sigma_temp_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Sigma_temp_j_1_max__; ++j_1__) { - vars__.push_back(Sigma_temp(j_1__, j_2__)); - } - } - size_t sigma12_vec_j_2_max__ = 1; - size_t sigma12_vec_j_1_max__ = (n_pcor - 1); - for (size_t j_2__ = 0; j_2__ < sigma12_vec_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < sigma12_vec_j_1_max__; ++j_1__) { - vars__.push_back(sigma12_vec(j_1__, j_2__)); - } - } - size_t temp_sums_j_2_max__ = ((N * long_format) * est_cor); - size_t temp_sums_j_1_max__ = ((P * long_format) * est_cor); - for (size_t j_2__ = 0; j_2__ < temp_sums_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < temp_sums_j_1_max__; ++j_1__) { - vars__.push_back(temp_sums(j_1__, j_2__)); - } - } - size_t temp_counts_j_2_max__ = ((N * long_format) * est_cor); - size_t temp_counts_j_1_max__ = ((P * long_format) * est_cor); - for (size_t j_2__ = 0; j_2__ < temp_counts_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < temp_counts_j_1_max__; ++j_1__) { - vars__.push_back(temp_counts(j_1__, j_2__)); - } - } - size_t cond_sigma_vec_j_1_max__ = ((P * long_format) * est_cor); - for (size_t j_1__ = 0; j_1__ < cond_sigma_vec_j_1_max__; ++j_1__) { - vars__.push_back(cond_sigma_vec(j_1__)); - } - size_t cond_mean_vec_j_1_max__ = ((P * long_format) * est_cor); - for (size_t j_1__ = 0; j_1__ < cond_mean_vec_j_1_max__; ++j_1__) { - vars__.push_back(cond_mean_vec(j_1__)); - } - vars__.push_back(sigma11); - size_t sigma_pro_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < sigma_pro_j_1_max__; ++j_1__) { - vars__.push_back(sigma_pro(j_1__)); - } - size_t spline_a_trans_j_2_max__ = (n_knots * est_spline); - size_t spline_a_trans_j_1_max__ = (K * est_spline); - for (size_t j_2__ = 0; j_2__ < spline_a_trans_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < spline_a_trans_j_1_max__; ++j_1__) { - vars__.push_back(spline_a_trans(j_1__, j_2__)); - } - } - size_t SigmaKnots_j_2_max__ = n_knots; - size_t SigmaKnots_j_1_max__ = n_knots; - size_t SigmaKnots_k_0_max__ = K; - for (size_t j_2__ = 0; j_2__ < SigmaKnots_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < SigmaKnots_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < SigmaKnots_k_0_max__; ++k_0__) { - vars__.push_back(SigmaKnots[k_0__](j_1__, j_2__)); - } - } - } - size_t obs_cov_offset_j_1_max__ = n_pos; - for (size_t j_1__ = 0; j_1__ < obs_cov_offset_j_1_max__; ++j_1__) { - vars__.push_back(obs_cov_offset(j_1__)); - } - } - if (!include_gqs__) return; - // declare and define generated quantities - current_statement_begin__ = 599; - validate_non_negative_index("log_lik", "n_loglik", n_loglik); - Eigen::Matrix log_lik(n_loglik); - stan::math::initialize(log_lik, DUMMY_VAR__); - stan::math::fill(log_lik, DUMMY_VAR__); - current_statement_begin__ = 600; - validate_non_negative_index("Omega", "n_pcor", n_pcor); - validate_non_negative_index("Omega", "n_pcor", n_pcor); - Eigen::Matrix Omega(n_pcor, n_pcor); - stan::math::initialize(Omega, DUMMY_VAR__); - stan::math::fill(Omega, DUMMY_VAR__); - current_statement_begin__ = 601; - validate_non_negative_index("Sigma", "n_pcor", n_pcor); - validate_non_negative_index("Sigma", "n_pcor", n_pcor); - Eigen::Matrix Sigma(n_pcor, n_pcor); - stan::math::initialize(Sigma, DUMMY_VAR__); - stan::math::fill(Sigma, DUMMY_VAR__); - current_statement_begin__ = 602; - validate_non_negative_index("xstar", "K", K); - validate_non_negative_index("xstar", "1", 1); - Eigen::Matrix xstar(K, 1); - stan::math::initialize(xstar, DUMMY_VAR__); - stan::math::fill(xstar, DUMMY_VAR__); - current_statement_begin__ = 603; - validate_non_negative_index("future_devs", "K", K); - Eigen::Matrix future_devs(K); - stan::math::initialize(future_devs, DUMMY_VAR__); - stan::math::fill(future_devs, DUMMY_VAR__); - current_statement_begin__ = 604; - validate_non_negative_index("SigmaKnots_pred", "n_knots", n_knots); - validate_non_negative_index("SigmaKnots_pred", "n_knots", n_knots); - Eigen::Matrix SigmaKnots_pred(n_knots, n_knots); - stan::math::initialize(SigmaKnots_pred, DUMMY_VAR__); - stan::math::fill(SigmaKnots_pred, DUMMY_VAR__); - current_statement_begin__ = 605; - validate_non_negative_index("SigmaOffDiag_pred", "n_knots", n_knots); - Eigen::Matrix SigmaOffDiag_pred(n_knots); - stan::math::initialize(SigmaOffDiag_pred, DUMMY_VAR__); - stan::math::fill(SigmaOffDiag_pred, DUMMY_VAR__); - current_statement_begin__ = 606; - int j; - (void) j; // dummy to suppress unused var warning - stan::math::fill(j, std::numeric_limits::min()); - // generated quantities statements - current_statement_begin__ = 607; - stan::math::assign(j, 0); - current_statement_begin__ = 609; - if (as_bool(logical_eq(est_cor, 1))) { - current_statement_begin__ = 610; - stan::math::assign(Omega, multiply_lower_tri_self_transpose(Lcorr)); - current_statement_begin__ = 611; - stan::math::assign(Sigma, quad_form_diag(Omega, sigma_vec)); - } - current_statement_begin__ = 615; - if (as_bool(logical_eq(est_cor, 0))) { - current_statement_begin__ = 616; - if (as_bool(logical_eq(long_format, 0))) { - current_statement_begin__ = 617; - stan::math::assign(j, 0); - current_statement_begin__ = 618; - for (int n = 1; n <= N; ++n) { - current_statement_begin__ = 619; - for (int p = 1; p <= P; ++p) { - current_statement_begin__ = 620; - stan::math::assign(j, (j + 1)); - current_statement_begin__ = 621; - stan::model::assign(log_lik, - stan::model::cons_list(stan::model::index_uni(j), stan::model::nil_index_list()), - normal_log(get_base1(yall, p, n, "yall", 1), get_base1(pred, p, n, "pred", 1), get_base1(sigma_vec, p, "sigma_vec", 1)), - "assigning variable log_lik"); - } - } - } else { - current_statement_begin__ = 625; - if (as_bool(logical_eq(obs_model, 1))) { - current_statement_begin__ = 625; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 625; - stan::model::assign(log_lik, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - normal_log(get_base1(y, i, "y", 1), ((get_base1(offset, i, "offset", 1) + get_base1(pred, get_base1(row_indx_pos, i, "row_indx_pos", 1), get_base1(col_indx_pos, i, "col_indx_pos", 1), "pred", 1)) + get_base1(obs_cov_offset, i, "obs_cov_offset", 1)), stan::math::exp((stan::math::log(get_base1(sigma_vec, get_base1(row_indx_pos, i, "row_indx_pos", 1), "sigma_vec", 1)) - get_base1(log_weights_vec, i, "log_weights_vec", 1)))), - "assigning variable log_lik"); - } - } - current_statement_begin__ = 626; - if (as_bool(logical_eq(obs_model, 2))) { - current_statement_begin__ = 626; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 626; - stan::model::assign(log_lik, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - gamma_log(get_base1(y, i, "y", 1), get_base1(gamma_a_vec, get_base1(row_indx_pos, i, "row_indx_pos", 1), "gamma_a_vec", 1), (get_base1(gamma_a_vec, get_base1(row_indx_pos, i, "row_indx_pos", 1), "gamma_a_vec", 1) / stan::math::exp(((get_base1(offset, i, "offset", 1) + get_base1(pred, get_base1(row_indx_pos, i, "row_indx_pos", 1), get_base1(col_indx_pos, i, "col_indx_pos", 1), "pred", 1)) + get_base1(obs_cov_offset, i, "obs_cov_offset", 1))))), - "assigning variable log_lik"); - } - } - current_statement_begin__ = 627; - if (as_bool(logical_eq(obs_model, 3))) { - current_statement_begin__ = 627; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 627; - stan::model::assign(log_lik, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - poisson_log_log(get_base1(y_int, i, "y_int", 1), ((get_base1(offset, i, "offset", 1) + get_base1(pred, get_base1(row_indx_pos, i, "row_indx_pos", 1), get_base1(col_indx_pos, i, "col_indx_pos", 1), "pred", 1)) + get_base1(obs_cov_offset, i, "obs_cov_offset", 1))), - "assigning variable log_lik"); - } - } - current_statement_begin__ = 628; - if (as_bool(logical_eq(obs_model, 4))) { - current_statement_begin__ = 628; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 628; - stan::model::assign(log_lik, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - neg_binomial_2_log_log(get_base1(y_int, i, "y_int", 1), ((get_base1(offset, i, "offset", 1) + get_base1(pred, get_base1(row_indx_pos, i, "row_indx_pos", 1), get_base1(col_indx_pos, i, "col_indx_pos", 1), "pred", 1)) + get_base1(obs_cov_offset, i, "obs_cov_offset", 1)), get_base1(nb_phi_vec, get_base1(row_indx_pos, i, "row_indx_pos", 1), "nb_phi_vec", 1)), - "assigning variable log_lik"); - } - } - current_statement_begin__ = 629; - if (as_bool(logical_eq(obs_model, 5))) { - current_statement_begin__ = 629; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 629; - stan::model::assign(log_lik, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - bernoulli_logit_log(get_base1(y_int, i, "y_int", 1), ((get_base1(offset, i, "offset", 1) + get_base1(pred, get_base1(row_indx_pos, i, "row_indx_pos", 1), get_base1(col_indx_pos, i, "col_indx_pos", 1), "pred", 1)) + get_base1(obs_cov_offset, i, "obs_cov_offset", 1))), - "assigning variable log_lik"); - } - } - current_statement_begin__ = 630; - if (as_bool(logical_eq(obs_model, 6))) { - current_statement_begin__ = 630; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 630; - stan::model::assign(log_lik, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - lognormal_log(get_base1(y, i, "y", 1), (get_base1(offset, i, "offset", 1) + get_base1(pred, get_base1(row_indx_pos, i, "row_indx_pos", 1), get_base1(col_indx_pos, i, "col_indx_pos", 1), "pred", 1)), (get_base1(sigma_vec, get_base1(row_indx_pos, i, "row_indx_pos", 1), "sigma_vec", 1) + get_base1(obs_cov_offset, i, "obs_cov_offset", 1))), - "assigning variable log_lik"); - } - } - } + current_statement__ = 259; + assign(log_lik, cons_list(index_uni(i), nil_index_list()), + normal_lpdf(y[(i - 1)], + ((offset[(i - 1)] + + rvalue(pred, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "pred")) + + obs_cov_offset[(i - 1)]), + stan::math::exp( + (stan::math::log(sigma_vec[(row_indx_pos[(i - 1)] - 1)]) + - log_weights_vec[(i - 1)]))), + "assigning variable log_lik");} + } + current_statement__ = 266; + if (logical_eq(obs_model, 2)) { + current_statement__ = 264; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 263; + assign(log_lik, cons_list(index_uni(i), nil_index_list()), + gamma_lpdf(y[(i - 1)], + gamma_a_vec[(row_indx_pos[(i - 1)] - 1)], + (gamma_a_vec[(row_indx_pos[(i - 1)] - 1)] / + stan::math::exp( + ((offset[(i - 1)] + + rvalue(pred, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "pred")) + + obs_cov_offset[(i - 1)])))), + "assigning variable log_lik");} + } + current_statement__ = 270; + if (logical_eq(obs_model, 3)) { + current_statement__ = 268; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 267; + assign(log_lik, cons_list(index_uni(i), nil_index_list()), + poisson_log_lpmf(y_int[(i - 1)], + ((offset[(i - 1)] + + rvalue(pred, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "pred")) + + obs_cov_offset[(i - 1)])), "assigning variable log_lik"); + } + } + current_statement__ = 274; + if (logical_eq(obs_model, 4)) { + current_statement__ = 272; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 271; + assign(log_lik, cons_list(index_uni(i), nil_index_list()), + neg_binomial_2_log_lpmf(y_int[(i - 1)], + ((offset[(i - 1)] + + rvalue(pred, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "pred")) + + obs_cov_offset[(i - 1)]), + nb_phi_vec[(row_indx_pos[(i - 1)] - 1)]), + "assigning variable log_lik");} + } + current_statement__ = 278; + if (logical_eq(obs_model, 5)) { + current_statement__ = 276; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 275; + assign(log_lik, cons_list(index_uni(i), nil_index_list()), + bernoulli_logit_lpmf(y_int[(i - 1)], + ((offset[(i - 1)] + + rvalue(pred, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "pred")) + + obs_cov_offset[(i - 1)])), "assigning variable log_lik"); + } + } + current_statement__ = 282; + if (logical_eq(obs_model, 6)) { + current_statement__ = 280; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 279; + assign(log_lik, cons_list(index_uni(i), nil_index_list()), + lognormal_lpdf(y[(i - 1)], + (offset[(i - 1)] + + rvalue(pred, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "pred")), + (sigma_vec[(row_indx_pos[(i - 1)] - 1)] + + obs_cov_offset[(i - 1)])), "assigning variable log_lik"); + } + } + } + } else { + current_statement__ = 257; + if (logical_eq(long_format, 0)) { + current_statement__ = 255; + for (int i = 1; i <= N; ++i) { + current_statement__ = 253; + assign(log_lik, cons_list(index_uni(i), nil_index_list()), + multi_normal_cholesky_lpdf(col(yall, i), col(pred, i), + diag_pre_multiply(sigma_vec, Lcorr)), + "assigning variable log_lik");} + } else { + current_statement__ = 251; + for (int i = 1; i <= n_pos; ++i) { + current_statement__ = 249; + assign(log_lik, cons_list(index_uni(i), nil_index_list()), + normal_lpdf(y[(i - 1)], + (((offset[(i - 1)] + + rvalue(pred, + cons_list(index_uni(row_indx_pos[(i - 1)]), + cons_list(index_uni(col_indx_pos[(i - 1)]), + nil_index_list())), "pred")) + + obs_cov_offset[(i - 1)]) + + cond_mean_vec[(row_indx_pos[(i - 1)] - 1)]), + stan::math::exp( + (stan::math::log( + cond_sigma_vec[(row_indx_pos[(i - 1)] - 1)]) - + log_weights_vec[(i - 1)]))), "assigning variable log_lik"); + } + } + } + current_statement__ = 297; + for (int k = 1; k <= K; ++k) { + current_statement__ = 295; + assign(future_devs, cons_list(index_uni(k), nil_index_list()), 0, + "assigning variable future_devs");} + current_statement__ = 311; + if (logical_eq(est_rw, 1)) { + current_statement__ = 309; + for (int k = 1; k <= K; ++k) { + current_statement__ = 306; + if (logical_eq(use_normal, 0)) { + current_statement__ = 304; + if (logical_eq(estimate_nu, 1)) { + current_statement__ = 302; + assign(future_devs, cons_list(index_uni(k), nil_index_list()), + student_t_rng(nu[(1 - 1)], + (theta_vec[(k - 1)] * + rvalue(devs, + cons_list(index_uni(k), + cons_list(index_uni((N - 1)), nil_index_list())), + "devs")), sigma_pro[(k - 1)], base_rng__), + "assigning variable future_devs"); } else { - current_statement_begin__ = 635; - if (as_bool(logical_eq(long_format, 0))) { - current_statement_begin__ = 636; - for (int i = 1; i <= N; ++i) { - current_statement_begin__ = 637; - stan::model::assign(log_lik, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - multi_normal_cholesky_log(col(yall, i), col(pred, i), diag_pre_multiply(sigma_vec, Lcorr)), - "assigning variable log_lik"); - } - } else { - current_statement_begin__ = 640; - for (int i = 1; i <= n_pos; ++i) { - current_statement_begin__ = 642; - stan::model::assign(log_lik, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - normal_log(get_base1(y, i, "y", 1), (((get_base1(offset, i, "offset", 1) + get_base1(pred, get_base1(row_indx_pos, i, "row_indx_pos", 1), get_base1(col_indx_pos, i, "col_indx_pos", 1), "pred", 1)) + get_base1(obs_cov_offset, i, "obs_cov_offset", 1)) + get_base1(cond_mean_vec, get_base1(row_indx_pos, i, "row_indx_pos", 1), "cond_mean_vec", 1)), stan::math::exp((stan::math::log(get_base1(cond_sigma_vec, get_base1(row_indx_pos, i, "row_indx_pos", 1), "cond_sigma_vec", 1)) - get_base1(log_weights_vec, i, "log_weights_vec", 1)))), - "assigning variable log_lik"); - } - } - } - current_statement_begin__ = 647; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 648; - stan::model::assign(future_devs, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - 0, - "assigning variable future_devs"); - } - current_statement_begin__ = 651; - if (as_bool(logical_eq(est_rw, 1))) { - current_statement_begin__ = 652; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 653; - if (as_bool(logical_eq(use_normal, 0))) { - current_statement_begin__ = 655; - if (as_bool(logical_eq(estimate_nu, 1))) { - current_statement_begin__ = 656; - stan::model::assign(future_devs, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - student_t_rng(get_base1(nu, 1, "nu", 1), (get_base1(theta_vec, k, "theta_vec", 1) * get_base1(devs, k, (N - 1), "devs", 1)), get_base1(sigma_pro, k, "sigma_pro", 1), base_rng__), - "assigning variable future_devs"); - } else { - current_statement_begin__ = 658; - stan::model::assign(future_devs, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - student_t_rng(nu_fixed, (get_base1(theta_vec, k, "theta_vec", 1) * get_base1(devs, k, (N - 1), "devs", 1)), get_base1(sigma_pro, k, "sigma_pro", 1), base_rng__), - "assigning variable future_devs"); - } - } else { - current_statement_begin__ = 662; - stan::model::assign(future_devs, - stan::model::cons_list(stan::model::index_uni(k), stan::model::nil_index_list()), - normal_rng((get_base1(theta_vec, k, "theta_vec", 1) * get_base1(devs, k, (N - 1), "devs", 1)), get_base1(sigma_pro, k, "sigma_pro", 1), base_rng__), - "assigning variable future_devs"); - } - current_statement_begin__ = 664; - stan::model::assign(xstar, - stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(1), stan::model::nil_index_list())), - (get_base1(x, k, N, "x", 1) + get_base1(future_devs, k, "future_devs", 1)), - "assigning variable xstar"); - } - } - current_statement_begin__ = 667; - if (as_bool(logical_eq(est_spline, 1))) { - current_statement_begin__ = 669; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 670; - stan::model::assign(xstar, - stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(1), stan::model::nil_index_list())), - (get_base1(spline_a_trans, k, n_knots, "spline_a_trans", 1) * get_base1(X_spline, N, n_knots, "X_spline", 1)), - "assigning variable xstar"); - } - } - current_statement_begin__ = 673; - if (as_bool(logical_eq(est_gp, 1))) { - current_statement_begin__ = 674; - for (int k = 1; k <= K; ++k) { - current_statement_begin__ = 675; - stan::math::assign(SigmaKnots_pred, cov_exp_quad(knot_locs, get_base1(sigma_pro, k, "sigma_pro", 1), get_base1(gp_theta, k, "gp_theta", 1))); - current_statement_begin__ = 676; - for (int i = 1; i <= n_knots; ++i) { - current_statement_begin__ = 677; - stan::model::assign(SigmaKnots_pred, - stan::model::cons_list(stan::model::index_uni(i), stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list())), - (stan::model::rvalue(SigmaKnots_pred, stan::model::cons_list(stan::model::index_uni(i), stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list())), "SigmaKnots_pred") + gp_delta), - "assigning variable SigmaKnots_pred"); - } - current_statement_begin__ = 680; - stan::math::assign(SigmaOffDiag_pred, multiply(to_row_vector(multiply(square(get_base1(sigma_pro, k, "sigma_pro", 1)), stan::math::exp(divide(minus(distKnots21_pred), (2.0 * pow(get_base1(gp_theta, k, "gp_theta", 1), 2.0)))))), inverse_spd(SigmaKnots_pred))); - current_statement_begin__ = 681; - stan::model::assign(xstar, - stan::model::cons_list(stan::model::index_uni(k), stan::model::cons_list(stan::model::index_uni(1), stan::model::nil_index_list())), - multiply(multiply(SigmaOffDiag_pred, cholesky_decompose(get_base1(SigmaKnots, k, "SigmaKnots", 1))), get_base1(effectsKnots, k, "effectsKnots", 1)), - "assigning variable xstar"); - } - } - // validate, write generated quantities - current_statement_begin__ = 599; - size_t log_lik_j_1_max__ = n_loglik; - for (size_t j_1__ = 0; j_1__ < log_lik_j_1_max__; ++j_1__) { - vars__.push_back(log_lik(j_1__)); - } - current_statement_begin__ = 600; - size_t Omega_j_2_max__ = n_pcor; - size_t Omega_j_1_max__ = n_pcor; - for (size_t j_2__ = 0; j_2__ < Omega_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Omega_j_1_max__; ++j_1__) { - vars__.push_back(Omega(j_1__, j_2__)); - } - } - current_statement_begin__ = 601; - size_t Sigma_j_2_max__ = n_pcor; - size_t Sigma_j_1_max__ = n_pcor; - for (size_t j_2__ = 0; j_2__ < Sigma_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Sigma_j_1_max__; ++j_1__) { - vars__.push_back(Sigma(j_1__, j_2__)); - } - } - current_statement_begin__ = 602; - size_t xstar_j_2_max__ = 1; - size_t xstar_j_1_max__ = K; - for (size_t j_2__ = 0; j_2__ < xstar_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < xstar_j_1_max__; ++j_1__) { - vars__.push_back(xstar(j_1__, j_2__)); - } - } - current_statement_begin__ = 603; - size_t future_devs_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < future_devs_j_1_max__; ++j_1__) { - vars__.push_back(future_devs(j_1__)); - } - current_statement_begin__ = 604; - size_t SigmaKnots_pred_j_2_max__ = n_knots; - size_t SigmaKnots_pred_j_1_max__ = n_knots; - for (size_t j_2__ = 0; j_2__ < SigmaKnots_pred_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < SigmaKnots_pred_j_1_max__; ++j_1__) { - vars__.push_back(SigmaKnots_pred(j_1__, j_2__)); - } - } - current_statement_begin__ = 605; - size_t SigmaOffDiag_pred_j_1_max__ = n_knots; - for (size_t j_1__ = 0; j_1__ < SigmaOffDiag_pred_j_1_max__; ++j_1__) { - vars__.push_back(SigmaOffDiag_pred(j_1__)); - } - current_statement_begin__ = 606; - check_greater_or_equal(function__, "j", j, 0); - vars__.push_back(j); - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__()); - // Next line prevents compiler griping about no return - throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); - } + current_statement__ = 300; + assign(future_devs, cons_list(index_uni(k), nil_index_list()), + student_t_rng(nu_fixed, + (theta_vec[(k - 1)] * + rvalue(devs, + cons_list(index_uni(k), + cons_list(index_uni((N - 1)), nil_index_list())), + "devs")), sigma_pro[(k - 1)], base_rng__), + "assigning variable future_devs"); + } + } else { + current_statement__ = 298; + assign(future_devs, cons_list(index_uni(k), nil_index_list()), + normal_rng( + (theta_vec[(k - 1)] * + rvalue(devs, + cons_list(index_uni(k), + cons_list(index_uni((N - 1)), nil_index_list())), + "devs")), sigma_pro[(k - 1)], base_rng__), + "assigning variable future_devs"); + } + current_statement__ = 307; + assign(xstar, + cons_list(index_uni(k), + cons_list(index_uni(1), nil_index_list())), + (rvalue(x, + cons_list(index_uni(k), + cons_list(index_uni(N), nil_index_list())), "x") + + future_devs[(k - 1)]), "assigning variable xstar");} + } + current_statement__ = 316; + if (logical_eq(est_spline, 1)) { + current_statement__ = 314; + for (int k = 1; k <= K; ++k) { + current_statement__ = 312; + assign(xstar, + cons_list(index_uni(k), + cons_list(index_uni(1), nil_index_list())), + (rvalue(spline_a_trans, + cons_list(index_uni(k), + cons_list(index_uni(n_knots), nil_index_list())), + "spline_a_trans") * + rvalue(X_spline, + cons_list(index_uni(N), + cons_list(index_uni(n_knots), nil_index_list())), + "X_spline")), "assigning variable xstar");} + } + current_statement__ = 326; + if (logical_eq(est_gp, 1)) { + current_statement__ = 324; + for (int k = 1; k <= K; ++k) { + current_statement__ = 317; + assign(SigmaKnots_pred, nil_index_list(), + cov_exp_quad(knot_locs, sigma_pro[(k - 1)], gp_theta[(k - 1)]), + "assigning variable SigmaKnots_pred"); + current_statement__ = 320; + for (int i = 1; i <= n_knots; ++i) { + current_statement__ = 318; + assign(SigmaKnots_pred, + cons_list(index_uni(i), + cons_list(index_uni(i), nil_index_list())), + (rvalue(SigmaKnots_pred, + cons_list(index_uni(i), + cons_list(index_uni(i), nil_index_list())), + "SigmaKnots_pred") + gp_delta), + "assigning variable SigmaKnots_pred");} + current_statement__ = 321; + assign(SigmaOffDiag_pred, nil_index_list(), + multiply( + to_row_vector( + multiply(square(sigma_pro[(k - 1)]), + stan::math::exp( + divide(minus(distKnots21_pred), + (2.0 * pow(gp_theta[(k - 1)], 2.0)))))), + inverse_spd(SigmaKnots_pred)), + "assigning variable SigmaOffDiag_pred"); + current_statement__ = 322; + assign(xstar, + cons_list(index_uni(k), + cons_list(index_uni(1), nil_index_list())), + multiply( + multiply(SigmaOffDiag_pred, + cholesky_decompose(SigmaKnots[(k - 1)])), + effectsKnots[(k - 1)]), "assigning variable xstar");} + } + current_statement__ = 243; + current_statement__ = 243; + check_greater_or_equal(function__, "j", j, 0); + for (int sym1__ = 1; sym1__ <= n_loglik; ++sym1__) { + vars__.emplace_back(log_lik[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= n_pcor; ++sym1__) { + for (int sym2__ = 1; sym2__ <= n_pcor; ++sym2__) { + vars__.emplace_back( + rvalue(Omega, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "Omega"));}} + for (int sym1__ = 1; sym1__ <= n_pcor; ++sym1__) { + for (int sym2__ = 1; sym2__ <= n_pcor; ++sym2__) { + vars__.emplace_back( + rvalue(Sigma, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "Sigma"));}} + for (int sym1__ = 1; sym1__ <= 1; ++sym1__) { + for (int sym2__ = 1; sym2__ <= K; ++sym2__) { + vars__.emplace_back( + rvalue(xstar, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "xstar"));}} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + vars__.emplace_back(future_devs[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= n_knots; ++sym1__) { + for (int sym2__ = 1; sym2__ <= n_knots; ++sym2__) { + vars__.emplace_back( + rvalue(SigmaKnots_pred, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + "SigmaKnots_pred"));}} + for (int sym1__ = 1; sym1__ <= n_knots; ++sym1__) { + vars__.emplace_back(SigmaOffDiag_pred[(sym1__ - 1)]);} + vars__.emplace_back(j); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // 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; + vars__.clear(); + vars__.reserve(num_params_r__); + + try { + int pos__; + pos__ = std::numeric_limits::min(); + + pos__ = 1; + Eigen::Matrix devs; + devs = Eigen::Matrix(devs_1dim__, devs_2dim__); + stan::math::fill(devs, std::numeric_limits::quiet_NaN()); + + { + std::vector devs_flat__; + current_statement__ = 1; + assign(devs_flat__, nil_index_list(), context__.vals_r("devs"), + "assigning variable devs_flat__"); + current_statement__ = 1; + pos__ = 1; + current_statement__ = 1; + for (int sym1__ = 1; sym1__ <= devs_2dim__; ++sym1__) { + current_statement__ = 1; + for (int sym2__ = 1; sym2__ <= devs_1dim__; ++sym2__) { + current_statement__ = 1; + assign(devs, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + devs_flat__[(pos__ - 1)], "assigning variable devs"); + current_statement__ = 1; + pos__ = (pos__ + 1);}} + } + Eigen::Matrix x0; + x0 = Eigen::Matrix(K); + stan::math::fill(x0, std::numeric_limits::quiet_NaN()); + + { + std::vector x0_flat__; + current_statement__ = 2; + assign(x0_flat__, nil_index_list(), context__.vals_r("x0"), + "assigning variable x0_flat__"); + current_statement__ = 2; + pos__ = 1; + current_statement__ = 2; + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + current_statement__ = 2; + assign(x0, cons_list(index_uni(sym1__), nil_index_list()), + x0_flat__[(pos__ - 1)], "assigning variable x0"); + current_statement__ = 2; + pos__ = (pos__ + 1);} + } + Eigen::Matrix psi; + psi = Eigen::Matrix(psi_1dim__); + stan::math::fill(psi, std::numeric_limits::quiet_NaN()); + + { + std::vector psi_flat__; + current_statement__ = 3; + assign(psi_flat__, nil_index_list(), context__.vals_r("psi"), + "assigning variable psi_flat__"); + current_statement__ = 3; + pos__ = 1; + current_statement__ = 3; + for (int sym1__ = 1; sym1__ <= psi_1dim__; ++sym1__) { + current_statement__ = 3; + assign(psi, cons_list(index_uni(sym1__), nil_index_list()), + psi_flat__[(pos__ - 1)], "assigning variable psi"); + current_statement__ = 3; + pos__ = (pos__ + 1);} + } + Eigen::Matrix psi_free__; + psi_free__ = Eigen::Matrix(psi_1dim__); + stan::math::fill(psi_free__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 3; + for (int sym1__ = 1; sym1__ <= psi_1dim__; ++sym1__) { + current_statement__ = 3; + assign(psi_free__, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_free(psi[(sym1__ - 1)], 0), + "assigning variable psi_free__");} + Eigen::Matrix z; + z = Eigen::Matrix(z_1dim__); + stan::math::fill(z, std::numeric_limits::quiet_NaN()); + + { + std::vector z_flat__; + current_statement__ = 4; + assign(z_flat__, nil_index_list(), context__.vals_r("z"), + "assigning variable z_flat__"); + current_statement__ = 4; + pos__ = 1; + current_statement__ = 4; + for (int sym1__ = 1; sym1__ <= z_1dim__; ++sym1__) { + current_statement__ = 4; + assign(z, cons_list(index_uni(sym1__), nil_index_list()), + z_flat__[(pos__ - 1)], "assigning variable z"); + current_statement__ = 4; + pos__ = (pos__ + 1);} + } + Eigen::Matrix z_free__; + z_free__ = Eigen::Matrix(z_1dim__); + stan::math::fill(z_free__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 4; + for (int sym1__ = 1; sym1__ <= z_1dim__; ++sym1__) { + current_statement__ = 4; + assign(z_free__, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_free(z[(sym1__ - 1)], z_bound[(1 - 1)], + z_bound[(2 - 1)]), "assigning variable z_free__");} + Eigen::Matrix zpos; + zpos = Eigen::Matrix(zpos_1dim__); + stan::math::fill(zpos, std::numeric_limits::quiet_NaN()); + + { + std::vector zpos_flat__; + current_statement__ = 5; + assign(zpos_flat__, nil_index_list(), context__.vals_r("zpos"), + "assigning variable zpos_flat__"); + current_statement__ = 5; + pos__ = 1; + current_statement__ = 5; + for (int sym1__ = 1; sym1__ <= zpos_1dim__; ++sym1__) { + current_statement__ = 5; + assign(zpos, cons_list(index_uni(sym1__), nil_index_list()), + zpos_flat__[(pos__ - 1)], "assigning variable zpos"); + current_statement__ = 5; + pos__ = (pos__ + 1);} + } + Eigen::Matrix zpos_free__; + zpos_free__ = Eigen::Matrix(zpos_1dim__); + stan::math::fill(zpos_free__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 5; + for (int sym1__ = 1; sym1__ <= zpos_1dim__; ++sym1__) { + current_statement__ = 5; + assign(zpos_free__, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_free(zpos[(sym1__ - 1)], lower_bound_z), + "assigning variable zpos_free__");} + std::vector> p_z; + p_z = std::vector>(p_z_1dim__, Eigen::Matrix(K)); + stan::math::fill(p_z, std::numeric_limits::quiet_NaN()); + + { + std::vector p_z_flat__; + current_statement__ = 6; + assign(p_z_flat__, nil_index_list(), context__.vals_r("p_z"), + "assigning variable p_z_flat__"); + current_statement__ = 6; + pos__ = 1; + current_statement__ = 6; + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + current_statement__ = 6; + for (int sym2__ = 1; sym2__ <= p_z_1dim__; ++sym2__) { + current_statement__ = 6; + assign(p_z, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + p_z_flat__[(pos__ - 1)], "assigning variable p_z"); + current_statement__ = 6; + pos__ = (pos__ + 1);}} + } + std::vector> p_z_free__; + p_z_free__ = std::vector>(p_z_1dim__, Eigen::Matrix( + (K - 1))); + stan::math::fill(p_z_free__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 6; + for (int sym1__ = 1; sym1__ <= p_z_1dim__; ++sym1__) { + current_statement__ = 6; + assign(p_z_free__, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::simplex_free(p_z[(sym1__ - 1)]), + "assigning variable p_z_free__");} + Eigen::Matrix spline_a; + spline_a = Eigen::Matrix(spline_a_1dim__, spline_a_2dim__); + stan::math::fill(spline_a, std::numeric_limits::quiet_NaN()); + + { + std::vector spline_a_flat__; + current_statement__ = 7; + assign(spline_a_flat__, nil_index_list(), + context__.vals_r("spline_a"), "assigning variable spline_a_flat__"); + current_statement__ = 7; + pos__ = 1; + current_statement__ = 7; + for (int sym1__ = 1; sym1__ <= spline_a_2dim__; ++sym1__) { + current_statement__ = 7; + for (int sym2__ = 1; sym2__ <= spline_a_1dim__; ++sym2__) { + current_statement__ = 7; + assign(spline_a, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + spline_a_flat__[(pos__ - 1)], "assigning variable spline_a"); + current_statement__ = 7; + pos__ = (pos__ + 1);}} + } + Eigen::Matrix b_obs; + b_obs = Eigen::Matrix(n_obs_covar, P); + stan::math::fill(b_obs, std::numeric_limits::quiet_NaN()); + + { + std::vector b_obs_flat__; + current_statement__ = 8; + assign(b_obs_flat__, nil_index_list(), context__.vals_r("b_obs"), + "assigning variable b_obs_flat__"); + current_statement__ = 8; + pos__ = 1; + current_statement__ = 8; + for (int sym1__ = 1; sym1__ <= P; ++sym1__) { + current_statement__ = 8; + for (int sym2__ = 1; sym2__ <= n_obs_covar; ++sym2__) { + current_statement__ = 8; + assign(b_obs, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + b_obs_flat__[(pos__ - 1)], "assigning variable b_obs"); + current_statement__ = 8; + pos__ = (pos__ + 1);}} + } + Eigen::Matrix b_pro; + b_pro = Eigen::Matrix(n_pro_covar, K); + stan::math::fill(b_pro, std::numeric_limits::quiet_NaN()); + + { + std::vector b_pro_flat__; + current_statement__ = 9; + assign(b_pro_flat__, nil_index_list(), context__.vals_r("b_pro"), + "assigning variable b_pro_flat__"); + current_statement__ = 9; + pos__ = 1; + current_statement__ = 9; + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + current_statement__ = 9; + for (int sym2__ = 1; sym2__ <= n_pro_covar; ++sym2__) { + current_statement__ = 9; + assign(b_pro, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + b_pro_flat__[(pos__ - 1)], "assigning variable b_pro"); + current_statement__ = 9; + pos__ = (pos__ + 1);}} + } + std::vector sigma; + sigma = std::vector(sigma_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 10; + assign(sigma, nil_index_list(), context__.vals_r("sigma"), + "assigning variable sigma"); + std::vector sigma_free__; + sigma_free__ = std::vector(sigma_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 10; + for (int sym1__ = 1; sym1__ <= sigma_1dim__; ++sym1__) { + current_statement__ = 10; + assign(sigma_free__, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_free(sigma[(sym1__ - 1)], 0), + "assigning variable sigma_free__");} + std::vector gamma_a; + gamma_a = std::vector(gamma_a_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 11; + assign(gamma_a, nil_index_list(), context__.vals_r("gamma_a"), + "assigning variable gamma_a"); + std::vector gamma_a_free__; + gamma_a_free__ = std::vector(gamma_a_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 11; + for (int sym1__ = 1; sym1__ <= gamma_a_1dim__; ++sym1__) { + current_statement__ = 11; + assign(gamma_a_free__, + cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_free(gamma_a[(sym1__ - 1)], 0), + "assigning variable gamma_a_free__");} + std::vector nb2_phi; + nb2_phi = std::vector(nb2_phi_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 12; + assign(nb2_phi, nil_index_list(), context__.vals_r("nb2_phi"), + "assigning variable nb2_phi"); + std::vector nb2_phi_free__; + nb2_phi_free__ = std::vector(nb2_phi_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 12; + for (int sym1__ = 1; sym1__ <= nb2_phi_1dim__; ++sym1__) { + current_statement__ = 12; + assign(nb2_phi_free__, + cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_free(nb2_phi[(sym1__ - 1)], 0), + "assigning variable nb2_phi_free__");} + std::vector nu; + nu = std::vector(estimate_nu, std::numeric_limits::quiet_NaN()); + + current_statement__ = 13; + assign(nu, nil_index_list(), context__.vals_r("nu"), + "assigning variable nu"); + std::vector nu_free__; + nu_free__ = std::vector(estimate_nu, std::numeric_limits::quiet_NaN()); + + current_statement__ = 13; + for (int sym1__ = 1; sym1__ <= estimate_nu; ++sym1__) { + current_statement__ = 13; + assign(nu_free__, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_free(nu[(sym1__ - 1)], 2), + "assigning variable nu_free__");} + std::vector ymiss; + ymiss = std::vector(n_na, std::numeric_limits::quiet_NaN()); + + current_statement__ = 14; + assign(ymiss, nil_index_list(), context__.vals_r("ymiss"), + "assigning variable ymiss"); + std::vector phi; + phi = std::vector(phi_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 15; + assign(phi, nil_index_list(), context__.vals_r("phi"), + "assigning variable phi"); + std::vector phi_free__; + phi_free__ = std::vector(phi_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 15; + for (int sym1__ = 1; sym1__ <= phi_1dim__; ++sym1__) { + current_statement__ = 15; + assign(phi_free__, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_free(phi[(sym1__ - 1)], -1, 1), + "assigning variable phi_free__");} + std::vector theta; + theta = std::vector(theta_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 16; + assign(theta, nil_index_list(), context__.vals_r("theta"), + "assigning variable theta"); + std::vector theta_free__; + theta_free__ = std::vector(theta_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 16; + for (int sym1__ = 1; sym1__ <= theta_1dim__; ++sym1__) { + current_statement__ = 16; + assign(theta_free__, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lub_free(theta[(sym1__ - 1)], -1, 1), + "assigning variable theta_free__");} + std::vector gp_theta; + gp_theta = std::vector(gp_theta_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 17; + assign(gp_theta, nil_index_list(), context__.vals_r("gp_theta"), + "assigning variable gp_theta"); + std::vector gp_theta_free__; + gp_theta_free__ = std::vector(gp_theta_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 17; + for (int sym1__ = 1; sym1__ <= gp_theta_1dim__; ++sym1__) { + current_statement__ = 17; + assign(gp_theta_free__, + cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_free(gp_theta[(sym1__ - 1)], 0), + "assigning variable gp_theta_free__");} + Eigen::Matrix Lcorr; + Lcorr = Eigen::Matrix(n_pcor, n_pcor); + stan::math::fill(Lcorr, std::numeric_limits::quiet_NaN()); + + { + std::vector Lcorr_flat__; + current_statement__ = 18; + assign(Lcorr_flat__, nil_index_list(), context__.vals_r("Lcorr"), + "assigning variable Lcorr_flat__"); + current_statement__ = 18; + pos__ = 1; + current_statement__ = 18; + for (int sym1__ = 1; sym1__ <= n_pcor; ++sym1__) { + current_statement__ = 18; + for (int sym2__ = 1; sym2__ <= n_pcor; ++sym2__) { + current_statement__ = 18; + assign(Lcorr, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + Lcorr_flat__[(pos__ - 1)], "assigning variable Lcorr"); + current_statement__ = 18; + pos__ = (pos__ + 1);}} + } + Eigen::Matrix Lcorr_free__; + Lcorr_free__ = Eigen::Matrix(((n_pcor * (n_pcor - 1)) / + 2)); + stan::math::fill(Lcorr_free__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 18; + assign(Lcorr_free__, nil_index_list(), + stan::math::cholesky_corr_free(Lcorr), + "assigning variable Lcorr_free__"); + std::vector sigma_process; + sigma_process = std::vector(sigma_process_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 19; + assign(sigma_process, nil_index_list(), + context__.vals_r("sigma_process"), "assigning variable sigma_process"); + std::vector sigma_process_free__; + sigma_process_free__ = std::vector(sigma_process_1dim__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 19; + for (int sym1__ = 1; sym1__ <= sigma_process_1dim__; ++sym1__) { + current_statement__ = 19; + assign(sigma_process_free__, + cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_free(sigma_process[(sym1__ - 1)], 0), + "assigning variable sigma_process_free__");} + std::vector> effectsKnots; + effectsKnots = std::vector>(effectsKnots_1dim__, Eigen::Matrix(effectsKnots_2dim__)); + stan::math::fill(effectsKnots, std::numeric_limits::quiet_NaN()); + + { + std::vector effectsKnots_flat__; + current_statement__ = 20; + assign(effectsKnots_flat__, nil_index_list(), + context__.vals_r("effectsKnots"), + "assigning variable effectsKnots_flat__"); + current_statement__ = 20; + pos__ = 1; + current_statement__ = 20; + for (int sym1__ = 1; sym1__ <= effectsKnots_2dim__; ++sym1__) { + current_statement__ = 20; + for (int sym2__ = 1; sym2__ <= effectsKnots_1dim__; ++sym2__) { + current_statement__ = 20; + assign(effectsKnots, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + effectsKnots_flat__[(pos__ - 1)], + "assigning variable effectsKnots"); + current_statement__ = 20; + pos__ = (pos__ + 1);}} + } + for (int sym1__ = 1; sym1__ <= devs_2dim__; ++sym1__) { + for (int sym2__ = 1; sym2__ <= devs_1dim__; ++sym2__) { + vars__.emplace_back( + rvalue(devs, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "devs"));}} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + vars__.emplace_back(x0[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= psi_1dim__; ++sym1__) { + vars__.emplace_back(psi_free__[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= z_1dim__; ++sym1__) { + vars__.emplace_back(z_free__[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= zpos_1dim__; ++sym1__) { + vars__.emplace_back(zpos_free__[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= p_z_1dim__; ++sym1__) { + for (int sym2__ = 1; sym2__ <= (K - 1); ++sym2__) { + vars__.emplace_back(p_z_free__[(sym1__ - 1)][(sym2__ - 1)]);}} + for (int sym1__ = 1; sym1__ <= spline_a_2dim__; ++sym1__) { + for (int sym2__ = 1; sym2__ <= spline_a_1dim__; ++sym2__) { + vars__.emplace_back( + rvalue(spline_a, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "spline_a")); + }} + for (int sym1__ = 1; sym1__ <= P; ++sym1__) { + for (int sym2__ = 1; sym2__ <= n_obs_covar; ++sym2__) { + vars__.emplace_back( + rvalue(b_obs, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "b_obs"));}} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + for (int sym2__ = 1; sym2__ <= n_pro_covar; ++sym2__) { + vars__.emplace_back( + rvalue(b_pro, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), "b_pro"));}} + for (int sym1__ = 1; sym1__ <= sigma_1dim__; ++sym1__) { + vars__.emplace_back(sigma_free__[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= gamma_a_1dim__; ++sym1__) { + vars__.emplace_back(gamma_a_free__[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= nb2_phi_1dim__; ++sym1__) { + vars__.emplace_back(nb2_phi_free__[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= estimate_nu; ++sym1__) { + vars__.emplace_back(nu_free__[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= n_na; ++sym1__) { + vars__.emplace_back(ymiss[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= phi_1dim__; ++sym1__) { + vars__.emplace_back(phi_free__[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= theta_1dim__; ++sym1__) { + vars__.emplace_back(theta_free__[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= gp_theta_1dim__; ++sym1__) { + vars__.emplace_back(gp_theta_free__[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= ((n_pcor * (n_pcor - 1)) / 2); ++sym1__) { + vars__.emplace_back(Lcorr_free__[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= sigma_process_1dim__; ++sym1__) { + vars__.emplace_back(sigma_process_free__[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= effectsKnots_1dim__; ++sym1__) { + for (int sym2__ = 1; sym2__ <= effectsKnots_2dim__; ++sym2__) { + vars__.emplace_back(effectsKnots[(sym1__ - 1)][(sym2__ - 1)]);}} + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } // transform_inits_impl() + + inline void get_param_names(std::vector& names__) const { + + names__.clear(); + names__.emplace_back("devs"); + names__.emplace_back("x0"); + names__.emplace_back("psi"); + names__.emplace_back("z"); + names__.emplace_back("zpos"); + names__.emplace_back("p_z"); + names__.emplace_back("spline_a"); + names__.emplace_back("b_obs"); + names__.emplace_back("b_pro"); + names__.emplace_back("sigma"); + names__.emplace_back("gamma_a"); + names__.emplace_back("nb2_phi"); + names__.emplace_back("nu"); + names__.emplace_back("ymiss"); + names__.emplace_back("phi"); + names__.emplace_back("theta"); + names__.emplace_back("gp_theta"); + names__.emplace_back("Lcorr"); + names__.emplace_back("sigma_process"); + names__.emplace_back("effectsKnots"); + names__.emplace_back("pred"); + names__.emplace_back("Z"); + names__.emplace_back("yall"); + names__.emplace_back("sigma_vec"); + names__.emplace_back("gamma_a_vec"); + names__.emplace_back("nb_phi_vec"); + names__.emplace_back("phi_vec"); + names__.emplace_back("theta_vec"); + names__.emplace_back("x"); + names__.emplace_back("indicator"); + names__.emplace_back("psi_root"); + names__.emplace_back("Sigma_derived"); + names__.emplace_back("Sigma_temp"); + names__.emplace_back("sigma12_vec"); + names__.emplace_back("temp_sums"); + names__.emplace_back("temp_counts"); + names__.emplace_back("cond_sigma_vec"); + names__.emplace_back("cond_mean_vec"); + names__.emplace_back("sigma11"); + names__.emplace_back("sigma_pro"); + names__.emplace_back("spline_a_trans"); + names__.emplace_back("SigmaKnots"); + names__.emplace_back("obs_cov_offset"); + names__.emplace_back("log_lik"); + names__.emplace_back("Omega"); + names__.emplace_back("Sigma"); + names__.emplace_back("xstar"); + names__.emplace_back("future_devs"); + names__.emplace_back("SigmaKnots_pred"); + names__.emplace_back("SigmaOffDiag_pred"); + names__.emplace_back("j"); + } // get_param_names() + + inline void get_dims(std::vector>& dimss__) const { + dimss__.clear(); + dimss__.emplace_back(std::vector{static_cast(devs_1dim__) + , + static_cast(devs_2dim__)}); + + dimss__.emplace_back(std::vector{static_cast(K)}); + + dimss__.emplace_back(std::vector{static_cast(psi_1dim__)}); + + dimss__.emplace_back(std::vector{static_cast(z_1dim__)}); + + dimss__.emplace_back(std::vector{static_cast(zpos_1dim__)}); + + dimss__.emplace_back(std::vector{static_cast(p_z_1dim__), + static_cast(K)}); + + dimss__.emplace_back(std::vector{ + static_cast(spline_a_1dim__) + , + static_cast(spline_a_2dim__) + }); + + dimss__.emplace_back(std::vector{static_cast(n_obs_covar) + , static_cast(P)}); + + dimss__.emplace_back(std::vector{static_cast(n_pro_covar) + , static_cast(K)}); + + dimss__.emplace_back(std::vector{ + static_cast(sigma_1dim__)}); + + dimss__.emplace_back(std::vector{ + static_cast(gamma_a_1dim__) + }); + + dimss__.emplace_back(std::vector{ + static_cast(nb2_phi_1dim__) + }); + + dimss__.emplace_back(std::vector{static_cast(estimate_nu)}); + + dimss__.emplace_back(std::vector{static_cast(n_na)}); + + dimss__.emplace_back(std::vector{static_cast(phi_1dim__)}); + + dimss__.emplace_back(std::vector{ + static_cast(theta_1dim__)}); + + dimss__.emplace_back(std::vector{ + static_cast(gp_theta_1dim__) + }); + + dimss__.emplace_back(std::vector{static_cast(n_pcor), + static_cast(n_pcor)}); + + dimss__.emplace_back(std::vector{ + static_cast(sigma_process_1dim__) + }); + + dimss__.emplace_back(std::vector{ + static_cast(effectsKnots_1dim__) + , + static_cast(effectsKnots_2dim__) + }); + + dimss__.emplace_back(std::vector{static_cast(P), + static_cast(N)}); + + dimss__.emplace_back(std::vector{static_cast(P), + static_cast(K)}); + + dimss__.emplace_back(std::vector{static_cast(P), + static_cast(N)}); + + dimss__.emplace_back(std::vector{ + static_cast(sigma_vec_1dim__) + }); + + dimss__.emplace_back(std::vector{ + static_cast(gamma_a_vec_1dim__) + }); + + dimss__.emplace_back(std::vector{ + static_cast(nb_phi_vec_1dim__) + }); + + dimss__.emplace_back(std::vector{static_cast(K)}); + + dimss__.emplace_back(std::vector{static_cast(K)}); + + dimss__.emplace_back(std::vector{static_cast(K), + static_cast(N)}); + + dimss__.emplace_back(std::vector{static_cast(K)}); + + dimss__.emplace_back(std::vector{ + static_cast(psi_root_1dim__) + }); + + dimss__.emplace_back(std::vector{ + static_cast(Sigma_derived_1dim__) + , + static_cast(Sigma_derived_2dim__) + }); + + dimss__.emplace_back(std::vector{ + static_cast(Sigma_temp_1dim__) + , + static_cast(Sigma_temp_2dim__) + }); + + dimss__.emplace_back(std::vector{ + static_cast(sigma12_vec_1dim__) + , static_cast(1)}); + + dimss__.emplace_back(std::vector{ + static_cast(temp_sums_1dim__) + , + static_cast(temp_sums_2dim__) + }); + + dimss__.emplace_back(std::vector{ + static_cast(temp_counts_1dim__) + , + static_cast(temp_counts_2dim__) + }); + + dimss__.emplace_back(std::vector{ + static_cast(cond_sigma_vec_1dim__) + }); + + dimss__.emplace_back(std::vector{ + static_cast(cond_mean_vec_1dim__) + }); + + dimss__.emplace_back(std::vector{}); + + dimss__.emplace_back(std::vector{static_cast(K)}); + + dimss__.emplace_back(std::vector{ + static_cast(spline_a_trans_1dim__) + , + static_cast(spline_a_trans_2dim__) + }); + + dimss__.emplace_back(std::vector{static_cast(K), + static_cast(n_knots), + static_cast(n_knots)}); + + dimss__.emplace_back(std::vector{static_cast(n_pos)}); + + dimss__.emplace_back(std::vector{static_cast(n_loglik)}); + + dimss__.emplace_back(std::vector{static_cast(n_pcor), + static_cast(n_pcor)}); + + dimss__.emplace_back(std::vector{static_cast(n_pcor), + static_cast(n_pcor)}); + + dimss__.emplace_back(std::vector{static_cast(K), + static_cast(1)}); + + dimss__.emplace_back(std::vector{static_cast(K)}); + + dimss__.emplace_back(std::vector{static_cast(n_knots), + static_cast(n_knots)}); + + dimss__.emplace_back(std::vector{static_cast(n_knots)}); + + 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 { + + for (int sym1__ = 1; sym1__ <= devs_2dim__; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= devs_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "devs" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + param_names__.emplace_back(std::string() + "x0" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= psi_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "psi" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= z_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "z" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= zpos_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "zpos" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= p_z_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "p_z" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= spline_a_2dim__; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= spline_a_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "spline_a" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= P; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= n_obs_covar; ++sym2__) { + { + param_names__.emplace_back(std::string() + "b_obs" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= n_pro_covar; ++sym2__) { + { + param_names__.emplace_back(std::string() + "b_pro" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= sigma_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "sigma" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= gamma_a_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "gamma_a" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= nb2_phi_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "nb2_phi" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= estimate_nu; ++sym1__) { + { + param_names__.emplace_back(std::string() + "nu" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= n_na; ++sym1__) { + { + param_names__.emplace_back(std::string() + "ymiss" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= phi_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "phi" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= theta_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "theta" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= gp_theta_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "gp_theta" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= n_pcor; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= n_pcor; ++sym2__) { + { + param_names__.emplace_back(std::string() + "Lcorr" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= sigma_process_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "sigma_process" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= effectsKnots_2dim__; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= effectsKnots_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "effectsKnots" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + if (emit_transformed_parameters__) { + for (int sym1__ = 1; sym1__ <= N; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= P; ++sym2__) { + { + param_names__.emplace_back(std::string() + "pred" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= P; ++sym2__) { + { + param_names__.emplace_back(std::string() + "Z" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= N; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= P; ++sym2__) { + { + param_names__.emplace_back(std::string() + "yall" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= sigma_vec_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "sigma_vec" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= gamma_a_vec_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "gamma_a_vec" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= nb_phi_vec_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "nb_phi_vec" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + param_names__.emplace_back(std::string() + "phi_vec" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + param_names__.emplace_back(std::string() + "theta_vec" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= N; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= K; ++sym2__) { + { + param_names__.emplace_back(std::string() + "x" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + param_names__.emplace_back(std::string() + "indicator" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= psi_root_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "psi_root" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= Sigma_derived_2dim__; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= Sigma_derived_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "Sigma_derived" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= Sigma_temp_2dim__; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= Sigma_temp_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "Sigma_temp" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= 1; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= sigma12_vec_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "sigma12_vec" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= temp_sums_2dim__; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= temp_sums_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "temp_sums" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= temp_counts_2dim__; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= temp_counts_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "temp_counts" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= cond_sigma_vec_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "cond_sigma_vec" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= cond_mean_vec_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "cond_mean_vec" + '.' + std::to_string(sym1__)); + }} + param_names__.emplace_back(std::string() + "sigma11"); + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + param_names__.emplace_back(std::string() + "sigma_pro" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= spline_a_trans_2dim__; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= spline_a_trans_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "spline_a_trans" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= n_knots; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= n_knots; ++sym2__) { + { + for (int sym3__ = 1; sym3__ <= K; ++sym3__) { + { + param_names__.emplace_back(std::string() + "SigmaKnots" + '.' + std::to_string(sym3__) + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + }} + for (int sym1__ = 1; sym1__ <= n_pos; ++sym1__) { + { + param_names__.emplace_back(std::string() + "obs_cov_offset" + '.' + std::to_string(sym1__)); + }} } + + if (emit_generated_quantities__) { + for (int sym1__ = 1; sym1__ <= n_loglik; ++sym1__) { + { + param_names__.emplace_back(std::string() + "log_lik" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= n_pcor; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= n_pcor; ++sym2__) { + { + param_names__.emplace_back(std::string() + "Omega" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= n_pcor; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= n_pcor; ++sym2__) { + { + param_names__.emplace_back(std::string() + "Sigma" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= 1; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= K; ++sym2__) { + { + param_names__.emplace_back(std::string() + "xstar" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + param_names__.emplace_back(std::string() + "future_devs" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= n_knots; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= n_knots; ++sym2__) { + { + param_names__.emplace_back(std::string() + "SigmaKnots_pred" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= n_knots; ++sym1__) { + { + param_names__.emplace_back(std::string() + "SigmaOffDiag_pred" + '.' + std::to_string(sym1__)); + }} + param_names__.emplace_back(std::string() + "j"); + } + + } // 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__ <= devs_2dim__; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= devs_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "devs" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + param_names__.emplace_back(std::string() + "x0" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= psi_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "psi" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= z_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "z" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= zpos_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "zpos" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= (K - 1); ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= p_z_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "p_z" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= spline_a_2dim__; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= spline_a_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "spline_a" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= P; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= n_obs_covar; ++sym2__) { + { + param_names__.emplace_back(std::string() + "b_obs" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= n_pro_covar; ++sym2__) { + { + param_names__.emplace_back(std::string() + "b_pro" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= sigma_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "sigma" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= gamma_a_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "gamma_a" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= nb2_phi_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "nb2_phi" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= estimate_nu; ++sym1__) { + { + param_names__.emplace_back(std::string() + "nu" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= n_na; ++sym1__) { + { + param_names__.emplace_back(std::string() + "ymiss" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= phi_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "phi" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= theta_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "theta" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= gp_theta_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "gp_theta" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= ((n_pcor * (n_pcor - 1)) / 2); ++sym1__) { + { + param_names__.emplace_back(std::string() + "Lcorr" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= sigma_process_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "sigma_process" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= effectsKnots_2dim__; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= effectsKnots_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "effectsKnots" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + if (emit_transformed_parameters__) { + for (int sym1__ = 1; sym1__ <= N; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= P; ++sym2__) { + { + param_names__.emplace_back(std::string() + "pred" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= P; ++sym2__) { + { + param_names__.emplace_back(std::string() + "Z" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= N; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= P; ++sym2__) { + { + param_names__.emplace_back(std::string() + "yall" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= sigma_vec_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "sigma_vec" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= gamma_a_vec_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "gamma_a_vec" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= nb_phi_vec_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "nb_phi_vec" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + param_names__.emplace_back(std::string() + "phi_vec" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + param_names__.emplace_back(std::string() + "theta_vec" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= N; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= K; ++sym2__) { + { + param_names__.emplace_back(std::string() + "x" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + param_names__.emplace_back(std::string() + "indicator" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= psi_root_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "psi_root" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= Sigma_derived_2dim__; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= Sigma_derived_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "Sigma_derived" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= Sigma_temp_2dim__; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= Sigma_temp_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "Sigma_temp" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= 1; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= sigma12_vec_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "sigma12_vec" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= temp_sums_2dim__; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= temp_sums_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "temp_sums" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= temp_counts_2dim__; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= temp_counts_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "temp_counts" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= cond_sigma_vec_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "cond_sigma_vec" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= cond_mean_vec_1dim__; ++sym1__) { + { + param_names__.emplace_back(std::string() + "cond_mean_vec" + '.' + std::to_string(sym1__)); + }} + param_names__.emplace_back(std::string() + "sigma11"); + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + param_names__.emplace_back(std::string() + "sigma_pro" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= spline_a_trans_2dim__; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= spline_a_trans_1dim__; ++sym2__) { + { + param_names__.emplace_back(std::string() + "spline_a_trans" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= n_knots; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= n_knots; ++sym2__) { + { + for (int sym3__ = 1; sym3__ <= K; ++sym3__) { + { + param_names__.emplace_back(std::string() + "SigmaKnots" + '.' + std::to_string(sym3__) + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + }} + for (int sym1__ = 1; sym1__ <= n_pos; ++sym1__) { + { + param_names__.emplace_back(std::string() + "obs_cov_offset" + '.' + std::to_string(sym1__)); + }} + } + + if (emit_generated_quantities__) { + for (int sym1__ = 1; sym1__ <= n_loglik; ++sym1__) { + { + param_names__.emplace_back(std::string() + "log_lik" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= n_pcor; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= n_pcor; ++sym2__) { + { + param_names__.emplace_back(std::string() + "Omega" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= n_pcor; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= n_pcor; ++sym2__) { + { + param_names__.emplace_back(std::string() + "Sigma" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= 1; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= K; ++sym2__) { + { + param_names__.emplace_back(std::string() + "xstar" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + param_names__.emplace_back(std::string() + "future_devs" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= n_knots; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= n_knots; ++sym2__) { + { + param_names__.emplace_back(std::string() + "SigmaKnots_pred" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= n_knots; ++sym1__) { + { + param_names__.emplace_back(std::string() + "SigmaOffDiag_pred" + '.' + std::to_string(sym1__)); + }} + param_names__.emplace_back(std::string() + "j"); + } + + } // unconstrained_param_names() + + inline std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"devs\",\"type\":{\"name\":\"matrix\",\"rows\":" << devs_1dim__ << ",\"cols\":" << devs_2dim__ << "},\"block\":\"parameters\"},{\"name\":\"x0\",\"type\":{\"name\":\"vector\",\"length\":" << K << "},\"block\":\"parameters\"},{\"name\":\"psi\",\"type\":{\"name\":\"vector\",\"length\":" << psi_1dim__ << "},\"block\":\"parameters\"},{\"name\":\"z\",\"type\":{\"name\":\"vector\",\"length\":" << z_1dim__ << "},\"block\":\"parameters\"},{\"name\":\"zpos\",\"type\":{\"name\":\"vector\",\"length\":" << zpos_1dim__ << "},\"block\":\"parameters\"},{\"name\":\"p_z\",\"type\":{\"name\":\"array\",\"length\":" << p_z_1dim__ << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"parameters\"},{\"name\":\"spline_a\",\"type\":{\"name\":\"matrix\",\"rows\":" << spline_a_1dim__ << ",\"cols\":" << spline_a_2dim__ << "},\"block\":\"parameters\"},{\"name\":\"b_obs\",\"type\":{\"name\":\"matrix\",\"rows\":" << n_obs_covar << ",\"cols\":" << P << "},\"block\":\"parameters\"},{\"name\":\"b_pro\",\"type\":{\"name\":\"matrix\",\"rows\":" << n_pro_covar << ",\"cols\":" << K << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"array\",\"length\":" << sigma_1dim__ << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"gamma_a\",\"type\":{\"name\":\"array\",\"length\":" << gamma_a_1dim__ << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"nb2_phi\",\"type\":{\"name\":\"array\",\"length\":" << nb2_phi_1dim__ << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"nu\",\"type\":{\"name\":\"array\",\"length\":" << estimate_nu << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"ymiss\",\"type\":{\"name\":\"array\",\"length\":" << n_na << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"array\",\"length\":" << phi_1dim__ << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"array\",\"length\":" << theta_1dim__ << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"gp_theta\",\"type\":{\"name\":\"array\",\"length\":" << gp_theta_1dim__ << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"Lcorr\",\"type\":{\"name\":\"matrix\",\"rows\":" << n_pcor << ",\"cols\":" << n_pcor << "},\"block\":\"parameters\"},{\"name\":\"sigma_process\",\"type\":{\"name\":\"array\",\"length\":" << sigma_process_1dim__ << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"effectsKnots\",\"type\":{\"name\":\"array\",\"length\":" << effectsKnots_1dim__ << ",\"element_type\":{\"name\":\"vector\",\"length\":" << effectsKnots_2dim__ << "}},\"block\":\"parameters\"},{\"name\":\"pred\",\"type\":{\"name\":\"matrix\",\"rows\":" << P << ",\"cols\":" << N << "},\"block\":\"transformed_parameters\"},{\"name\":\"Z\",\"type\":{\"name\":\"matrix\",\"rows\":" << P << ",\"cols\":" << K << "},\"block\":\"transformed_parameters\"},{\"name\":\"yall\",\"type\":{\"name\":\"matrix\",\"rows\":" << P << ",\"cols\":" << N << "},\"block\":\"transformed_parameters\"},{\"name\":\"sigma_vec\",\"type\":{\"name\":\"vector\",\"length\":" << sigma_vec_1dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"gamma_a_vec\",\"type\":{\"name\":\"vector\",\"length\":" << gamma_a_vec_1dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"nb_phi_vec\",\"type\":{\"name\":\"vector\",\"length\":" << nb_phi_vec_1dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"phi_vec\",\"type\":{\"name\":\"vector\",\"length\":" << K << "},\"block\":\"transformed_parameters\"},{\"name\":\"theta_vec\",\"type\":{\"name\":\"vector\",\"length\":" << K << "},\"block\":\"transformed_parameters\"},{\"name\":\"x\",\"type\":{\"name\":\"matrix\",\"rows\":" << K << ",\"cols\":" << N << "},\"block\":\"transformed_parameters\"},{\"name\":\"indicator\",\"type\":{\"name\":\"vector\",\"length\":" << K << "},\"block\":\"transformed_parameters\"},{\"name\":\"psi_root\",\"type\":{\"name\":\"vector\",\"length\":" << psi_root_1dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"Sigma_derived\",\"type\":{\"name\":\"matrix\",\"rows\":" << Sigma_derived_1dim__ << ",\"cols\":" << Sigma_derived_2dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"Sigma_temp\",\"type\":{\"name\":\"matrix\",\"rows\":" << Sigma_temp_1dim__ << ",\"cols\":" << Sigma_temp_2dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"sigma12_vec\",\"type\":{\"name\":\"matrix\",\"rows\":" << sigma12_vec_1dim__ << ",\"cols\":" << 1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"temp_sums\",\"type\":{\"name\":\"matrix\",\"rows\":" << temp_sums_1dim__ << ",\"cols\":" << temp_sums_2dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"temp_counts\",\"type\":{\"name\":\"matrix\",\"rows\":" << temp_counts_1dim__ << ",\"cols\":" << temp_counts_2dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"cond_sigma_vec\",\"type\":{\"name\":\"vector\",\"length\":" << cond_sigma_vec_1dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"cond_mean_vec\",\"type\":{\"name\":\"vector\",\"length\":" << cond_mean_vec_1dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"sigma11\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"sigma_pro\",\"type\":{\"name\":\"vector\",\"length\":" << K << "},\"block\":\"transformed_parameters\"},{\"name\":\"spline_a_trans\",\"type\":{\"name\":\"matrix\",\"rows\":" << spline_a_trans_1dim__ << ",\"cols\":" << spline_a_trans_2dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"SigmaKnots\",\"type\":{\"name\":\"array\",\"length\":" << K << ",\"element_type\":{\"name\":\"matrix\",\"rows\":" << n_knots << ",\"cols\":" << n_knots << "}},\"block\":\"transformed_parameters\"},{\"name\":\"obs_cov_offset\",\"type\":{\"name\":\"vector\",\"length\":" << n_pos << "},\"block\":\"transformed_parameters\"},{\"name\":\"log_lik\",\"type\":{\"name\":\"vector\",\"length\":" << n_loglik << "},\"block\":\"generated_quantities\"},{\"name\":\"Omega\",\"type\":{\"name\":\"matrix\",\"rows\":" << n_pcor << ",\"cols\":" << n_pcor << "},\"block\":\"generated_quantities\"},{\"name\":\"Sigma\",\"type\":{\"name\":\"matrix\",\"rows\":" << n_pcor << ",\"cols\":" << n_pcor << "},\"block\":\"generated_quantities\"},{\"name\":\"xstar\",\"type\":{\"name\":\"matrix\",\"rows\":" << K << ",\"cols\":" << 1 << "},\"block\":\"generated_quantities\"},{\"name\":\"future_devs\",\"type\":{\"name\":\"vector\",\"length\":" << K << "},\"block\":\"generated_quantities\"},{\"name\":\"SigmaKnots_pred\",\"type\":{\"name\":\"matrix\",\"rows\":" << n_knots << ",\"cols\":" << n_knots << "},\"block\":\"generated_quantities\"},{\"name\":\"SigmaOffDiag_pred\",\"type\":{\"name\":\"vector\",\"length\":" << n_knots << "},\"block\":\"generated_quantities\"},{\"name\":\"j\",\"type\":{\"name\":\"int\"},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + inline std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"devs\",\"type\":{\"name\":\"matrix\",\"rows\":" << devs_1dim__ << ",\"cols\":" << devs_2dim__ << "},\"block\":\"parameters\"},{\"name\":\"x0\",\"type\":{\"name\":\"vector\",\"length\":" << K << "},\"block\":\"parameters\"},{\"name\":\"psi\",\"type\":{\"name\":\"vector\",\"length\":" << psi_1dim__ << "},\"block\":\"parameters\"},{\"name\":\"z\",\"type\":{\"name\":\"vector\",\"length\":" << z_1dim__ << "},\"block\":\"parameters\"},{\"name\":\"zpos\",\"type\":{\"name\":\"vector\",\"length\":" << zpos_1dim__ << "},\"block\":\"parameters\"},{\"name\":\"p_z\",\"type\":{\"name\":\"array\",\"length\":" << p_z_1dim__ << ",\"element_type\":{\"name\":\"vector\",\"length\":" << (K - 1) << "}},\"block\":\"parameters\"},{\"name\":\"spline_a\",\"type\":{\"name\":\"matrix\",\"rows\":" << spline_a_1dim__ << ",\"cols\":" << spline_a_2dim__ << "},\"block\":\"parameters\"},{\"name\":\"b_obs\",\"type\":{\"name\":\"matrix\",\"rows\":" << n_obs_covar << ",\"cols\":" << P << "},\"block\":\"parameters\"},{\"name\":\"b_pro\",\"type\":{\"name\":\"matrix\",\"rows\":" << n_pro_covar << ",\"cols\":" << K << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"array\",\"length\":" << sigma_1dim__ << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"gamma_a\",\"type\":{\"name\":\"array\",\"length\":" << gamma_a_1dim__ << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"nb2_phi\",\"type\":{\"name\":\"array\",\"length\":" << nb2_phi_1dim__ << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"nu\",\"type\":{\"name\":\"array\",\"length\":" << estimate_nu << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"ymiss\",\"type\":{\"name\":\"array\",\"length\":" << n_na << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"array\",\"length\":" << phi_1dim__ << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"array\",\"length\":" << theta_1dim__ << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"gp_theta\",\"type\":{\"name\":\"array\",\"length\":" << gp_theta_1dim__ << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"Lcorr\",\"type\":{\"name\":\"vector\",\"length\":" << ((n_pcor * (n_pcor - 1)) / 2) << "},\"block\":\"parameters\"},{\"name\":\"sigma_process\",\"type\":{\"name\":\"array\",\"length\":" << sigma_process_1dim__ << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"effectsKnots\",\"type\":{\"name\":\"array\",\"length\":" << effectsKnots_1dim__ << ",\"element_type\":{\"name\":\"vector\",\"length\":" << effectsKnots_2dim__ << "}},\"block\":\"parameters\"},{\"name\":\"pred\",\"type\":{\"name\":\"matrix\",\"rows\":" << P << ",\"cols\":" << N << "},\"block\":\"transformed_parameters\"},{\"name\":\"Z\",\"type\":{\"name\":\"matrix\",\"rows\":" << P << ",\"cols\":" << K << "},\"block\":\"transformed_parameters\"},{\"name\":\"yall\",\"type\":{\"name\":\"matrix\",\"rows\":" << P << ",\"cols\":" << N << "},\"block\":\"transformed_parameters\"},{\"name\":\"sigma_vec\",\"type\":{\"name\":\"vector\",\"length\":" << sigma_vec_1dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"gamma_a_vec\",\"type\":{\"name\":\"vector\",\"length\":" << gamma_a_vec_1dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"nb_phi_vec\",\"type\":{\"name\":\"vector\",\"length\":" << nb_phi_vec_1dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"phi_vec\",\"type\":{\"name\":\"vector\",\"length\":" << K << "},\"block\":\"transformed_parameters\"},{\"name\":\"theta_vec\",\"type\":{\"name\":\"vector\",\"length\":" << K << "},\"block\":\"transformed_parameters\"},{\"name\":\"x\",\"type\":{\"name\":\"matrix\",\"rows\":" << K << ",\"cols\":" << N << "},\"block\":\"transformed_parameters\"},{\"name\":\"indicator\",\"type\":{\"name\":\"vector\",\"length\":" << K << "},\"block\":\"transformed_parameters\"},{\"name\":\"psi_root\",\"type\":{\"name\":\"vector\",\"length\":" << psi_root_1dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"Sigma_derived\",\"type\":{\"name\":\"matrix\",\"rows\":" << Sigma_derived_1dim__ << ",\"cols\":" << Sigma_derived_2dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"Sigma_temp\",\"type\":{\"name\":\"matrix\",\"rows\":" << Sigma_temp_1dim__ << ",\"cols\":" << Sigma_temp_2dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"sigma12_vec\",\"type\":{\"name\":\"matrix\",\"rows\":" << sigma12_vec_1dim__ << ",\"cols\":" << 1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"temp_sums\",\"type\":{\"name\":\"matrix\",\"rows\":" << temp_sums_1dim__ << ",\"cols\":" << temp_sums_2dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"temp_counts\",\"type\":{\"name\":\"matrix\",\"rows\":" << temp_counts_1dim__ << ",\"cols\":" << temp_counts_2dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"cond_sigma_vec\",\"type\":{\"name\":\"vector\",\"length\":" << cond_sigma_vec_1dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"cond_mean_vec\",\"type\":{\"name\":\"vector\",\"length\":" << cond_mean_vec_1dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"sigma11\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"sigma_pro\",\"type\":{\"name\":\"vector\",\"length\":" << K << "},\"block\":\"transformed_parameters\"},{\"name\":\"spline_a_trans\",\"type\":{\"name\":\"matrix\",\"rows\":" << spline_a_trans_1dim__ << ",\"cols\":" << spline_a_trans_2dim__ << "},\"block\":\"transformed_parameters\"},{\"name\":\"SigmaKnots\",\"type\":{\"name\":\"array\",\"length\":" << K << ",\"element_type\":{\"name\":\"matrix\",\"rows\":" << n_knots << ",\"cols\":" << n_knots << "}},\"block\":\"transformed_parameters\"},{\"name\":\"obs_cov_offset\",\"type\":{\"name\":\"vector\",\"length\":" << n_pos << "},\"block\":\"transformed_parameters\"},{\"name\":\"log_lik\",\"type\":{\"name\":\"vector\",\"length\":" << n_loglik << "},\"block\":\"generated_quantities\"},{\"name\":\"Omega\",\"type\":{\"name\":\"matrix\",\"rows\":" << n_pcor << ",\"cols\":" << n_pcor << "},\"block\":\"generated_quantities\"},{\"name\":\"Sigma\",\"type\":{\"name\":\"matrix\",\"rows\":" << n_pcor << ",\"cols\":" << n_pcor << "},\"block\":\"generated_quantities\"},{\"name\":\"xstar\",\"type\":{\"name\":\"matrix\",\"rows\":" << K << ",\"cols\":" << 1 << "},\"block\":\"generated_quantities\"},{\"name\":\"future_devs\",\"type\":{\"name\":\"vector\",\"length\":" << K << "},\"block\":\"generated_quantities\"},{\"name\":\"SigmaKnots_pred\",\"type\":{\"name\":\"matrix\",\"rows\":" << n_knots << ",\"cols\":" << n_knots << "},\"block\":\"generated_quantities\"},{\"name\":\"SigmaOffDiag_pred\",\"type\":{\"name\":\"vector\",\"length\":" << n_knots << "},\"block\":\"generated_quantities\"},{\"name\":\"j\",\"type\":{\"name\":\"int\"},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate template - void write_array(RNG& base_rng, - Eigen::Matrix& params_r, - Eigen::Matrix& vars, - bool include_tparams = true, - bool include_gqs = true, - std::ostream* pstream = 0) const { - std::vector params_r_vec(params_r.size()); - for (int i = 0; i < params_r.size(); ++i) - params_r_vec[i] = params_r(i); - std::vector vars_vec; - std::vector params_i_vec; - write_array(base_rng, params_r_vec, params_i_vec, vars_vec, include_tparams, include_gqs, pstream); + 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(i) = vars_vec[i]; + for (int i = 0; i < vars.size(); ++i) { + vars.coeffRef(i) = vars_vec[i]; + } } - std::string model_name() const { - return "model_dfa"; + 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); } - void constrained_param_names(std::vector& param_names__, - bool include_tparams__ = true, - bool include_gqs__ = true) const { - std::stringstream param_name_stream__; - size_t devs_j_2_max__ = ((N - 1) * est_rw); - size_t devs_j_1_max__ = (K * est_rw); - for (size_t j_2__ = 0; j_2__ < devs_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < devs_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "devs" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t x0_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < x0_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "x0" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t psi_j_1_max__ = ((K * (1 - proportional_model)) * use_expansion_prior); - for (size_t j_1__ = 0; j_1__ < psi_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "psi" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t z_j_1_max__ = (nZ * (1 - proportional_model)); - for (size_t j_1__ = 0; j_1__ < z_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "z" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t zpos_j_1_max__ = (K * (1 - proportional_model)); - for (size_t j_1__ = 0; j_1__ < zpos_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "zpos" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t p_z_j_1_max__ = K; - size_t p_z_k_0_max__ = (P * proportional_model); - for (size_t j_1__ = 0; j_1__ < p_z_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < p_z_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "p_z" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t spline_a_j_2_max__ = (n_knots * est_spline); - size_t spline_a_j_1_max__ = (K * est_spline); - for (size_t j_2__ = 0; j_2__ < spline_a_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < spline_a_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "spline_a" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t b_obs_j_2_max__ = P; - size_t b_obs_j_1_max__ = n_obs_covar; - for (size_t j_2__ = 0; j_2__ < b_obs_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < b_obs_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "b_obs" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t b_pro_j_2_max__ = K; - size_t b_pro_j_1_max__ = n_pro_covar; - for (size_t j_2__ = 0; j_2__ < b_pro_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < b_pro_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "b_pro" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t sigma_k_0_max__ = (nVariances * est_sigma_params); - for (size_t k_0__ = 0; k_0__ < sigma_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t gamma_a_k_0_max__ = (nVariances * est_gamma_params); - for (size_t k_0__ = 0; k_0__ < gamma_a_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "gamma_a" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t nb2_phi_k_0_max__ = (nVariances * est_nb2_params); - for (size_t k_0__ = 0; k_0__ < nb2_phi_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "nb2_phi" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t nu_k_0_max__ = estimate_nu; - for (size_t k_0__ = 0; k_0__ < nu_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "nu" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t ymiss_k_0_max__ = n_na; - for (size_t k_0__ = 0; k_0__ < ymiss_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "ymiss" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t phi_k_0_max__ = (est_phi * K); - for (size_t k_0__ = 0; k_0__ < phi_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "phi" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t theta_k_0_max__ = (est_theta * K); - for (size_t k_0__ = 0; k_0__ < theta_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "theta" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t gp_theta_k_0_max__ = (est_gp * K); - for (size_t k_0__ = 0; k_0__ < gp_theta_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "gp_theta" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t Lcorr_j_2_max__ = n_pcor; - size_t Lcorr_j_1_max__ = n_pcor; - for (size_t j_2__ = 0; j_2__ < Lcorr_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Lcorr_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "Lcorr" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t sigma_process_k_0_max__ = (est_sigma_process * n_sigma_process); - for (size_t k_0__ = 0; k_0__ < sigma_process_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma_process" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t effectsKnots_j_1_max__ = (n_knots * est_gp); - size_t effectsKnots_k_0_max__ = (K * est_gp); - for (size_t j_1__ = 0; j_1__ < effectsKnots_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < effectsKnots_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "effectsKnots" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - if (!include_gqs__ && !include_tparams__) return; - if (include_tparams__) { - size_t pred_j_2_max__ = N; - size_t pred_j_1_max__ = P; - for (size_t j_2__ = 0; j_2__ < pred_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < pred_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "pred" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t Z_j_2_max__ = K; - size_t Z_j_1_max__ = P; - for (size_t j_2__ = 0; j_2__ < Z_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Z_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "Z" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t yall_j_2_max__ = N; - size_t yall_j_1_max__ = P; - for (size_t j_2__ = 0; j_2__ < yall_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < yall_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "yall" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t sigma_vec_j_1_max__ = (P * est_sigma_params); - for (size_t j_1__ = 0; j_1__ < sigma_vec_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma_vec" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t gamma_a_vec_j_1_max__ = (P * est_gamma_params); - for (size_t j_1__ = 0; j_1__ < gamma_a_vec_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "gamma_a_vec" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t nb_phi_vec_j_1_max__ = (P * est_nb2_params); - for (size_t j_1__ = 0; j_1__ < nb_phi_vec_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "nb_phi_vec" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t phi_vec_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < phi_vec_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "phi_vec" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t theta_vec_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < theta_vec_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "theta_vec" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t x_j_2_max__ = N; - size_t x_j_1_max__ = K; - for (size_t j_2__ = 0; j_2__ < x_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < x_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "x" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t indicator_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < indicator_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "indicator" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t psi_root_j_1_max__ = (K * use_expansion_prior); - for (size_t j_1__ = 0; j_1__ < psi_root_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "psi_root" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t Sigma_derived_j_2_max__ = ((n_pcor * long_format) * est_cor); - size_t Sigma_derived_j_1_max__ = ((n_pcor * long_format) * est_cor); - for (size_t j_2__ = 0; j_2__ < Sigma_derived_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Sigma_derived_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "Sigma_derived" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t Sigma_temp_j_2_max__ = (((n_pcor - 1) * long_format) * est_cor); - size_t Sigma_temp_j_1_max__ = (((n_pcor - 1) * long_format) * est_cor); - for (size_t j_2__ = 0; j_2__ < Sigma_temp_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Sigma_temp_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "Sigma_temp" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t sigma12_vec_j_2_max__ = 1; - size_t sigma12_vec_j_1_max__ = (n_pcor - 1); - for (size_t j_2__ = 0; j_2__ < sigma12_vec_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < sigma12_vec_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma12_vec" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t temp_sums_j_2_max__ = ((N * long_format) * est_cor); - size_t temp_sums_j_1_max__ = ((P * long_format) * est_cor); - for (size_t j_2__ = 0; j_2__ < temp_sums_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < temp_sums_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "temp_sums" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t temp_counts_j_2_max__ = ((N * long_format) * est_cor); - size_t temp_counts_j_1_max__ = ((P * long_format) * est_cor); - for (size_t j_2__ = 0; j_2__ < temp_counts_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < temp_counts_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "temp_counts" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t cond_sigma_vec_j_1_max__ = ((P * long_format) * est_cor); - for (size_t j_1__ = 0; j_1__ < cond_sigma_vec_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "cond_sigma_vec" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t cond_mean_vec_j_1_max__ = ((P * long_format) * est_cor); - for (size_t j_1__ = 0; j_1__ < cond_mean_vec_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "cond_mean_vec" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma11"; - param_names__.push_back(param_name_stream__.str()); - size_t sigma_pro_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < sigma_pro_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma_pro" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t spline_a_trans_j_2_max__ = (n_knots * est_spline); - size_t spline_a_trans_j_1_max__ = (K * est_spline); - for (size_t j_2__ = 0; j_2__ < spline_a_trans_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < spline_a_trans_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "spline_a_trans" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t SigmaKnots_j_2_max__ = n_knots; - size_t SigmaKnots_j_1_max__ = n_knots; - size_t SigmaKnots_k_0_max__ = K; - for (size_t j_2__ = 0; j_2__ < SigmaKnots_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < SigmaKnots_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < SigmaKnots_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "SigmaKnots" << '.' << k_0__ + 1 << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - } - size_t obs_cov_offset_j_1_max__ = n_pos; - for (size_t j_1__ = 0; j_1__ < obs_cov_offset_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "obs_cov_offset" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - if (!include_gqs__) return; - size_t log_lik_j_1_max__ = n_loglik; - for (size_t j_1__ = 0; j_1__ < log_lik_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "log_lik" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t Omega_j_2_max__ = n_pcor; - size_t Omega_j_1_max__ = n_pcor; - for (size_t j_2__ = 0; j_2__ < Omega_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Omega_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "Omega" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t Sigma_j_2_max__ = n_pcor; - size_t Sigma_j_1_max__ = n_pcor; - for (size_t j_2__ = 0; j_2__ < Sigma_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Sigma_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "Sigma" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t xstar_j_2_max__ = 1; - size_t xstar_j_1_max__ = K; - for (size_t j_2__ = 0; j_2__ < xstar_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < xstar_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "xstar" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t future_devs_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < future_devs_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "future_devs" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t SigmaKnots_pred_j_2_max__ = n_knots; - size_t SigmaKnots_pred_j_1_max__ = n_knots; - for (size_t j_2__ = 0; j_2__ < SigmaKnots_pred_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < SigmaKnots_pred_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "SigmaKnots_pred" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t SigmaOffDiag_pred_j_1_max__ = n_knots; - for (size_t j_1__ = 0; j_1__ < SigmaOffDiag_pred_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "SigmaOffDiag_pred" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - param_name_stream__.str(std::string()); - param_name_stream__ << "j"; - param_names__.push_back(param_name_stream__.str()); + 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); } - void unconstrained_param_names(std::vector& param_names__, - bool include_tparams__ = true, - bool include_gqs__ = true) const { - std::stringstream param_name_stream__; - size_t devs_j_2_max__ = ((N - 1) * est_rw); - size_t devs_j_1_max__ = (K * est_rw); - for (size_t j_2__ = 0; j_2__ < devs_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < devs_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "devs" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t x0_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < x0_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "x0" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t psi_j_1_max__ = ((K * (1 - proportional_model)) * use_expansion_prior); - for (size_t j_1__ = 0; j_1__ < psi_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "psi" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t z_j_1_max__ = (nZ * (1 - proportional_model)); - for (size_t j_1__ = 0; j_1__ < z_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "z" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t zpos_j_1_max__ = (K * (1 - proportional_model)); - for (size_t j_1__ = 0; j_1__ < zpos_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "zpos" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t p_z_j_1_max__ = (K - 1); - size_t p_z_k_0_max__ = (P * proportional_model); - for (size_t j_1__ = 0; j_1__ < p_z_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < p_z_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "p_z" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t spline_a_j_2_max__ = (n_knots * est_spline); - size_t spline_a_j_1_max__ = (K * est_spline); - for (size_t j_2__ = 0; j_2__ < spline_a_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < spline_a_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "spline_a" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t b_obs_j_2_max__ = P; - size_t b_obs_j_1_max__ = n_obs_covar; - for (size_t j_2__ = 0; j_2__ < b_obs_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < b_obs_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "b_obs" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t b_pro_j_2_max__ = K; - size_t b_pro_j_1_max__ = n_pro_covar; - for (size_t j_2__ = 0; j_2__ < b_pro_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < b_pro_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "b_pro" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t sigma_k_0_max__ = (nVariances * est_sigma_params); - for (size_t k_0__ = 0; k_0__ < sigma_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t gamma_a_k_0_max__ = (nVariances * est_gamma_params); - for (size_t k_0__ = 0; k_0__ < gamma_a_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "gamma_a" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t nb2_phi_k_0_max__ = (nVariances * est_nb2_params); - for (size_t k_0__ = 0; k_0__ < nb2_phi_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "nb2_phi" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t nu_k_0_max__ = estimate_nu; - for (size_t k_0__ = 0; k_0__ < nu_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "nu" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t ymiss_k_0_max__ = n_na; - for (size_t k_0__ = 0; k_0__ < ymiss_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "ymiss" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t phi_k_0_max__ = (est_phi * K); - for (size_t k_0__ = 0; k_0__ < phi_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "phi" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t theta_k_0_max__ = (est_theta * K); - for (size_t k_0__ = 0; k_0__ < theta_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "theta" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t gp_theta_k_0_max__ = (est_gp * K); - for (size_t k_0__ = 0; k_0__ < gp_theta_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "gp_theta" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t Lcorr_j_1_max__ = ((n_pcor * (n_pcor - 1)) / 2); - for (size_t j_1__ = 0; j_1__ < Lcorr_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "Lcorr" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t sigma_process_k_0_max__ = (est_sigma_process * n_sigma_process); - for (size_t k_0__ = 0; k_0__ < sigma_process_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma_process" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t effectsKnots_j_1_max__ = (n_knots * est_gp); - size_t effectsKnots_k_0_max__ = (K * est_gp); - for (size_t j_1__ = 0; j_1__ < effectsKnots_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < effectsKnots_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "effectsKnots" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - if (!include_gqs__ && !include_tparams__) return; - if (include_tparams__) { - size_t pred_j_2_max__ = N; - size_t pred_j_1_max__ = P; - for (size_t j_2__ = 0; j_2__ < pred_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < pred_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "pred" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t Z_j_2_max__ = K; - size_t Z_j_1_max__ = P; - for (size_t j_2__ = 0; j_2__ < Z_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Z_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "Z" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t yall_j_2_max__ = N; - size_t yall_j_1_max__ = P; - for (size_t j_2__ = 0; j_2__ < yall_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < yall_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "yall" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t sigma_vec_j_1_max__ = (P * est_sigma_params); - for (size_t j_1__ = 0; j_1__ < sigma_vec_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma_vec" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t gamma_a_vec_j_1_max__ = (P * est_gamma_params); - for (size_t j_1__ = 0; j_1__ < gamma_a_vec_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "gamma_a_vec" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t nb_phi_vec_j_1_max__ = (P * est_nb2_params); - for (size_t j_1__ = 0; j_1__ < nb_phi_vec_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "nb_phi_vec" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t phi_vec_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < phi_vec_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "phi_vec" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t theta_vec_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < theta_vec_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "theta_vec" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t x_j_2_max__ = N; - size_t x_j_1_max__ = K; - for (size_t j_2__ = 0; j_2__ < x_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < x_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "x" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t indicator_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < indicator_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "indicator" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t psi_root_j_1_max__ = (K * use_expansion_prior); - for (size_t j_1__ = 0; j_1__ < psi_root_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "psi_root" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t Sigma_derived_j_2_max__ = ((n_pcor * long_format) * est_cor); - size_t Sigma_derived_j_1_max__ = ((n_pcor * long_format) * est_cor); - for (size_t j_2__ = 0; j_2__ < Sigma_derived_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Sigma_derived_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "Sigma_derived" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t Sigma_temp_j_2_max__ = (((n_pcor - 1) * long_format) * est_cor); - size_t Sigma_temp_j_1_max__ = (((n_pcor - 1) * long_format) * est_cor); - for (size_t j_2__ = 0; j_2__ < Sigma_temp_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Sigma_temp_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "Sigma_temp" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t sigma12_vec_j_2_max__ = 1; - size_t sigma12_vec_j_1_max__ = (n_pcor - 1); - for (size_t j_2__ = 0; j_2__ < sigma12_vec_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < sigma12_vec_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma12_vec" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t temp_sums_j_2_max__ = ((N * long_format) * est_cor); - size_t temp_sums_j_1_max__ = ((P * long_format) * est_cor); - for (size_t j_2__ = 0; j_2__ < temp_sums_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < temp_sums_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "temp_sums" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t temp_counts_j_2_max__ = ((N * long_format) * est_cor); - size_t temp_counts_j_1_max__ = ((P * long_format) * est_cor); - for (size_t j_2__ = 0; j_2__ < temp_counts_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < temp_counts_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "temp_counts" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t cond_sigma_vec_j_1_max__ = ((P * long_format) * est_cor); - for (size_t j_1__ = 0; j_1__ < cond_sigma_vec_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "cond_sigma_vec" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t cond_mean_vec_j_1_max__ = ((P * long_format) * est_cor); - for (size_t j_1__ = 0; j_1__ < cond_mean_vec_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "cond_mean_vec" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma11"; - param_names__.push_back(param_name_stream__.str()); - size_t sigma_pro_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < sigma_pro_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma_pro" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t spline_a_trans_j_2_max__ = (n_knots * est_spline); - size_t spline_a_trans_j_1_max__ = (K * est_spline); - for (size_t j_2__ = 0; j_2__ < spline_a_trans_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < spline_a_trans_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "spline_a_trans" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t SigmaKnots_j_2_max__ = n_knots; - size_t SigmaKnots_j_1_max__ = n_knots; - size_t SigmaKnots_k_0_max__ = K; - for (size_t j_2__ = 0; j_2__ < SigmaKnots_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < SigmaKnots_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < SigmaKnots_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "SigmaKnots" << '.' << k_0__ + 1 << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - } - size_t obs_cov_offset_j_1_max__ = n_pos; - for (size_t j_1__ = 0; j_1__ < obs_cov_offset_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "obs_cov_offset" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - if (!include_gqs__) return; - size_t log_lik_j_1_max__ = n_loglik; - for (size_t j_1__ = 0; j_1__ < log_lik_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "log_lik" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t Omega_j_2_max__ = n_pcor; - size_t Omega_j_1_max__ = n_pcor; - for (size_t j_2__ = 0; j_2__ < Omega_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Omega_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "Omega" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t Sigma_j_2_max__ = n_pcor; - size_t Sigma_j_1_max__ = n_pcor; - for (size_t j_2__ = 0; j_2__ < Sigma_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < Sigma_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "Sigma" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t xstar_j_2_max__ = 1; - size_t xstar_j_1_max__ = K; - for (size_t j_2__ = 0; j_2__ < xstar_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < xstar_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "xstar" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t future_devs_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < future_devs_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "future_devs" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t SigmaKnots_pred_j_2_max__ = n_knots; - size_t SigmaKnots_pred_j_1_max__ = n_knots; - for (size_t j_2__ = 0; j_2__ < SigmaKnots_pred_j_2_max__; ++j_2__) { - for (size_t j_1__ = 0; j_1__ < SigmaKnots_pred_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "SigmaKnots_pred" << '.' << j_1__ + 1 << '.' << j_2__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t SigmaOffDiag_pred_j_1_max__ = n_knots; - for (size_t j_1__ = 0; j_1__ < SigmaOffDiag_pred_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "SigmaOffDiag_pred" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - param_name_stream__.str(std::string()); - param_name_stream__ << "j"; - param_names__.push_back(param_name_stream__.str()); + 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); } -}; // model -} // namespace -typedef model_dfa_namespace::model_dfa stan_model; + + 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_dfa_namespace::model_dfa; #ifndef USING_R +// Boilerplate stan::model::model_base& new_model( stan::io::var_context& data_context, unsigned int seed, @@ -4910,5 +6276,8 @@ stan::model::model_base& new_model( stan_model* m = new stan_model(data_context, seed, msg_stream); return *m; } +stan::math::profile_map& get_stan_profile_data() { + return model_dfa_namespace::profiles__; +} #endif #endif diff --git a/src/stanExports_hmm_gaussian.h b/src/stanExports_hmm_gaussian.h index 0c80081..63306ac 100644 --- a/src/stanExports_hmm_gaussian.h +++ b/src/stanExports_hmm_gaussian.h @@ -17,1133 +17,1373 @@ #ifndef MODELS_HPP #define MODELS_HPP #define STAN__SERVICES__COMMAND_HPP +#ifndef USE_STANC3 +#define USE_STANC3 +#endif #include -// Code generated by Stan version 2.21.0 +// Code generated by stanc v2.26.1-4-gd72b68b7-dirty #include namespace model_hmm_gaussian_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::prob_grad; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; using namespace stan::math; -static int current_statement_begin__; -stan::io::program_reader prog_reader__() { - stan::io::program_reader reader; - reader.add_event(0, 0, "start", "model_hmm_gaussian"); - reader.add_event(180, 178, "end", "model_hmm_gaussian"); - return reader; -} +using stan::math::pow; +stan::math::profile_map profiles__; +static int current_statement__= 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'hmm_gaussian', line 17, column 2 to column 18)", + " (in 'hmm_gaussian', line 18, column 2 to column 21)", + " (in 'hmm_gaussian', line 21, column 2 to column 18)", + " (in 'hmm_gaussian', line 22, column 2 to column 27)", + " (in 'hmm_gaussian', line 25, column 2 to column 26)", + " (in 'hmm_gaussian', line 27, column 21 to column 22)", + " (in 'hmm_gaussian', line 27, column 4 to column 24)", + " (in 'hmm_gaussian', line 33, column 6 to column 73)", + " (in 'hmm_gaussian', line 31, column 11 to line 34, column 5)", + " (in 'hmm_gaussian', line 30, column 6 to column 70)", + " (in 'hmm_gaussian', line 28, column 23 to line 31, column 5)", + " (in 'hmm_gaussian', line 28, column 4 to line 34, column 5)", + " (in 'hmm_gaussian', line 45, column 14 to column 112)", + " (in 'hmm_gaussian', line 43, column 19 to line 46, column 13)", + " (in 'hmm_gaussian', line 42, column 14 to column 112)", + " (in 'hmm_gaussian', line 40, column 31 to line 43, column 13)", + " (in 'hmm_gaussian', line 40, column 12 to line 46, column 13)", + " (in 'hmm_gaussian', line 37, column 23 to line 47, column 9)", + " (in 'hmm_gaussian', line 37, column 8 to line 47, column 9)", + " (in 'hmm_gaussian', line 48, column 8 to column 52)", + " (in 'hmm_gaussian', line 36, column 21 to line 49, column 7)", + " (in 'hmm_gaussian', line 36, column 6 to line 49, column 7)", + " (in 'hmm_gaussian', line 35, column 19 to line 50, column 5)", + " (in 'hmm_gaussian', line 35, column 4 to line 50, column 5)", + " (in 'hmm_gaussian', line 26, column 2 to line 51, column 3)", + " (in 'hmm_gaussian', line 59, column 2 to column 25)", + " (in 'hmm_gaussian', line 60, column 2 to column 26)", + " (in 'hmm_gaussian', line 61, column 2 to column 24)", + " (in 'hmm_gaussian', line 62, column 2 to column 23)", + " (in 'hmm_gaussian', line 63, column 2 to column 24)", + " (in 'hmm_gaussian', line 64, column 2 to column 20)", + " (in 'hmm_gaussian', line 65, column 2 to column 35)", + " (in 'hmm_gaussian', line 66, column 2 to column 20)", + " (in 'hmm_gaussian', line 69, column 6 to column 43)", + " (in 'hmm_gaussian', line 68, column 4 to line 69, column 43)", + " (in 'hmm_gaussian', line 67, column 2 to line 70, column 3)", + " (in 'hmm_gaussian', line 72, column 21 to column 22)", + " (in 'hmm_gaussian', line 72, column 4 to column 24)", + " (in 'hmm_gaussian', line 74, column 6 to column 26)", + " (in 'hmm_gaussian', line 73, column 4 to line 74, column 26)", + " (in 'hmm_gaussian', line 76, column 6 to column 12)", + " (in 'hmm_gaussian', line 77, column 6 to column 23)", + " (in 'hmm_gaussian', line 85, column 14 to column 109)", + " (in 'hmm_gaussian', line 84, column 19 to line 86, column 13)", + " (in 'hmm_gaussian', line 83, column 14 to column 109)", + " (in 'hmm_gaussian', line 82, column 31 to line 84, column 13)", + " (in 'hmm_gaussian', line 82, column 12 to line 86, column 13)", + " (in 'hmm_gaussian', line 79, column 23 to line 87, column 11)", + " (in 'hmm_gaussian', line 79, column 8 to line 87, column 11)", + " (in 'hmm_gaussian', line 88, column 8 to column 53)", + " (in 'hmm_gaussian', line 78, column 21 to line 89, column 7)", + " (in 'hmm_gaussian', line 78, column 6 to line 89, column 7)", + " (in 'hmm_gaussian', line 75, column 30 to line 90, column 5)", + " (in 'hmm_gaussian', line 75, column 4 to line 90, column 5)", + " (in 'hmm_gaussian', line 92, column 6 to column 41)", + " (in 'hmm_gaussian', line 91, column 4 to line 92, column 41)", + " (in 'hmm_gaussian', line 71, column 2 to line 93, column 3)", + " (in 'hmm_gaussian', line 96, column 8 to column 50)", + " (in 'hmm_gaussian', line 97, column 8 to column 47)", + " (in 'hmm_gaussian', line 95, column 18 to line 98, column 5)", + " (in 'hmm_gaussian', line 95, column 4 to line 98, column 5)", + " (in 'hmm_gaussian', line 101, column 6 to column 21)", + " (in 'hmm_gaussian', line 107, column 10 to column 64)", + " (in 'hmm_gaussian', line 106, column 21 to line 108, column 7)", + " (in 'hmm_gaussian', line 106, column 6 to line 108, column 7)", + " (in 'hmm_gaussian', line 113, column 6 to column 35)", + " (in 'hmm_gaussian', line 99, column 18 to line 114, column 5)", + " (in 'hmm_gaussian', line 99, column 4 to line 114, column 5)", + " (in 'hmm_gaussian', line 94, column 2 to line 115, column 3)", + " (in 'hmm_gaussian', line 117, column 13 to column 14)", + " (in 'hmm_gaussian', line 117, column 16 to column 17)", + " (in 'hmm_gaussian', line 117, column 4 to column 19)", + " (in 'hmm_gaussian', line 118, column 18 to column 19)", + " (in 'hmm_gaussian', line 118, column 21 to column 22)", + " (in 'hmm_gaussian', line 118, column 4 to column 24)", + " (in 'hmm_gaussian', line 125, column 6 to column 65)", + " (in 'hmm_gaussian', line 124, column 4 to line 125, column 65)", + " (in 'hmm_gaussian', line 123, column 11 to line 126, column 5)", + " (in 'hmm_gaussian', line 122, column 6 to column 65)", + " (in 'hmm_gaussian', line 121, column 4 to line 122, column 65)", + " (in 'hmm_gaussian', line 120, column 23 to line 123, column 5)", + " (in 'hmm_gaussian', line 120, column 4 to line 126, column 5)", + " (in 'hmm_gaussian', line 129, column 8 to column 45)", + " (in 'hmm_gaussian', line 131, column 10 to column 20)", + " (in 'hmm_gaussian', line 135, column 12 to column 98)", + " (in 'hmm_gaussian', line 134, column 17 to line 136, column 11)", + " (in 'hmm_gaussian', line 133, column 10 to column 96)", + " (in 'hmm_gaussian', line 132, column 29 to line 134, column 11)", + " (in 'hmm_gaussian', line 132, column 10 to line 136, column 11)", + " (in 'hmm_gaussian', line 138, column 12 to column 27)", + " (in 'hmm_gaussian', line 139, column 12 to column 34)", + " (in 'hmm_gaussian', line 137, column 37 to line 140, column 11)", + " (in 'hmm_gaussian', line 137, column 10 to line 140, column 11)", + " (in 'hmm_gaussian', line 130, column 23 to line 141, column 9)", + " (in 'hmm_gaussian', line 130, column 8 to line 141, column 9)", + " (in 'hmm_gaussian', line 128, column 21 to line 142, column 7)", + " (in 'hmm_gaussian', line 128, column 6 to line 142, column 7)", + " (in 'hmm_gaussian', line 127, column 19 to line 143, column 5)", + " (in 'hmm_gaussian', line 127, column 4 to line 143, column 5)", + " (in 'hmm_gaussian', line 144, column 4 to column 36)", + " (in 'hmm_gaussian', line 147, column 8 to column 23)", + " (in 'hmm_gaussian', line 146, column 6 to line 147, column 23)", + " (in 'hmm_gaussian', line 145, column 4 to line 147, column 23)", + " (in 'hmm_gaussian', line 149, column 6 to column 59)", + " (in 'hmm_gaussian', line 148, column 25 to line 150, column 5)", + " (in 'hmm_gaussian', line 148, column 4 to line 150, column 5)", + " (in 'hmm_gaussian', line 116, column 2 to line 151, column 3)", + " (in 'hmm_gaussian', line 54, column 2 to column 31)", + " (in 'hmm_gaussian', line 55, column 2 to column 28)", + " (in 'hmm_gaussian', line 56, column 2 to column 39)", + " (in 'hmm_gaussian', line 9, column 2 to column 17)", + " (in 'hmm_gaussian', line 10, column 2 to column 17)", + " (in 'hmm_gaussian', line 11, column 11 to column 12)", + " (in 'hmm_gaussian', line 11, column 2 to column 14)", + " (in 'hmm_gaussian', line 12, column 2 to column 25)", + " (in 'hmm_gaussian', line 13, column 15 to column 16)", + " (in 'hmm_gaussian', line 13, column 2 to column 18)", + " (in 'hmm_gaussian', line 17, column 10 to column 11)", + " (in 'hmm_gaussian', line 18, column 18 to column 19)", + " (in 'hmm_gaussian', line 18, column 10 to column 11)", + " (in 'hmm_gaussian', line 21, column 10 to column 11)", + " (in 'hmm_gaussian', line 22, column 24 to column 25)", + " (in 'hmm_gaussian', line 25, column 23 to column 24)", + " (in 'hmm_gaussian', line 25, column 9 to column 10)", + " (in 'hmm_gaussian', line 59, column 22 to column 23)", + " (in 'hmm_gaussian', line 59, column 9 to column 10)", + " (in 'hmm_gaussian', line 60, column 23 to column 24)", + " (in 'hmm_gaussian', line 60, column 9 to column 10)", + " (in 'hmm_gaussian', line 61, column 21 to column 22)", + " (in 'hmm_gaussian', line 61, column 9 to column 10)", + " (in 'hmm_gaussian', line 62, column 20 to column 21)", + " (in 'hmm_gaussian', line 62, column 9 to column 10)", + " (in 'hmm_gaussian', line 63, column 21 to column 22)", + " (in 'hmm_gaussian', line 63, column 9 to column 10)", + " (in 'hmm_gaussian', line 64, column 9 to column 10)", + " (in 'hmm_gaussian', line 65, column 32 to column 33)", + " (in 'hmm_gaussian', line 5, column 4 to column 22)", + " (in 'hmm_gaussian', line 4, column 29 to line 6, column 3)"}; template -Eigen::Matrix::type, Eigen::Dynamic, 1> -normalize(const Eigen::Matrix& x, std::ostream* pstream__) { - typedef typename boost::math::tools::promote_args::type local_scalar_t__; - typedef local_scalar_t__ fun_return_scalar_t__; - const static bool propto__ = true; - (void) propto__; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - (void) DUMMY_VAR__; // suppress unused var warning - int current_statement_begin__ = -1; - try { - current_statement_begin__ = 6; - return stan::math::promote_scalar(divide(x, sum(x))); - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__()); - // Next line prevents compiler griping about no return - throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); - } +Eigen::Matrix>, -1, 1> +normalize(const T0__& x_arg__, std::ostream* pstream__) { + using local_scalar_t__ = stan::promote_args_t>; + const auto& x = to_ref(x_arg__); + const static bool propto__ = true; + (void) propto__; + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + (void) DUMMY_VAR__; // suppress unused var warning + + try { + current_statement__ = 137; + return divide(x, sum(x)); + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); + } + } struct normalize_functor__ { - template - Eigen::Matrix::type, Eigen::Dynamic, 1> - operator()(const Eigen::Matrix& x, std::ostream* pstream__) const { - return normalize(x, pstream__); - } +template +Eigen::Matrix>, -1, 1> +operator()(const T0__& x, std::ostream* pstream__) const +{ +return normalize(x, pstream__); +} }; #include -class model_hmm_gaussian - : public stan::model::model_base_crtp { +class model_hmm_gaussian final : public model_base_crtp { private: - int T; - int K; - std::vector x_t; - int est_sigma; - std::vector sigma_t; + int T; + int K; + std::vector x_t; + int est_sigma; + std::vector sigma_t; + public: - model_hmm_gaussian(stan::io::var_context& context__, - std::ostream* pstream__ = 0) - : model_base_crtp(0) { - ctor_body(context__, 0, pstream__); + ~model_hmm_gaussian() { } + + inline std::string model_name() const final { return "model_hmm_gaussian"; } + inline std::vector model_compile_info() const noexcept { + return std::vector{"stanc_version = stanc3 v2.26.1-4-gd72b68b7-dirty", "stancflags = "}; + } + + + model_hmm_gaussian(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_hmm_gaussian_namespace::model_hmm_gaussian"; + (void) function__; // suppress unused var warning + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + (void) DUMMY_VAR__; // suppress unused var warning + + try { + int pos__; + pos__ = std::numeric_limits::min(); + + pos__ = 1; + current_statement__ = 111; + context__.validate_dims("data initialization","T","int", + context__.to_vec()); + T = std::numeric_limits::min(); + + current_statement__ = 111; + T = context__.vals_i("T")[(1 - 1)]; + current_statement__ = 111; + current_statement__ = 111; + check_greater_or_equal(function__, "T", T, 1); + current_statement__ = 112; + context__.validate_dims("data initialization","K","int", + context__.to_vec()); + K = std::numeric_limits::min(); + + current_statement__ = 112; + K = context__.vals_i("K")[(1 - 1)]; + current_statement__ = 112; + current_statement__ = 112; + check_greater_or_equal(function__, "K", K, 1); + current_statement__ = 113; + validate_non_negative_index("x_t", "T", T); + current_statement__ = 114; + context__.validate_dims("data initialization","x_t","double", + context__.to_vec(T)); + x_t = std::vector(T, std::numeric_limits::quiet_NaN()); + + current_statement__ = 114; + assign(x_t, nil_index_list(), context__.vals_r("x_t"), + "assigning variable x_t"); + current_statement__ = 115; + context__.validate_dims("data initialization","est_sigma","int", + context__.to_vec()); + est_sigma = std::numeric_limits::min(); + + current_statement__ = 115; + est_sigma = context__.vals_i("est_sigma")[(1 - 1)]; + current_statement__ = 115; + current_statement__ = 115; + check_greater_or_equal(function__, "est_sigma", est_sigma, 0); + current_statement__ = 116; + validate_non_negative_index("sigma_t", "T", T); + current_statement__ = 117; + context__.validate_dims("data initialization","sigma_t","double", + context__.to_vec(T)); + sigma_t = std::vector(T, std::numeric_limits::quiet_NaN()); + + current_statement__ = 117; + assign(sigma_t, nil_index_list(), context__.vals_r("sigma_t"), + "assigning variable sigma_t"); + current_statement__ = 118; + validate_positive_index("p_1k", "K", K); + current_statement__ = 119; + validate_non_negative_index("A_ij", "K", K); + current_statement__ = 120; + validate_positive_index("A_ij", "K", K); + current_statement__ = 121; + validate_non_negative_index("mu_k", "K", K); + current_statement__ = 122; + validate_non_negative_index("sigma_k", "K", K); + current_statement__ = 123; + validate_non_negative_index("unalpha_tk", "T", T); + current_statement__ = 124; + validate_non_negative_index("unalpha_tk", "K", K); + current_statement__ = 125; + validate_non_negative_index("unbeta_tk", "T", T); + current_statement__ = 126; + validate_non_negative_index("unbeta_tk", "K", K); + current_statement__ = 127; + validate_non_negative_index("ungamma_tk", "T", T); + current_statement__ = 128; + validate_non_negative_index("ungamma_tk", "K", K); + current_statement__ = 129; + validate_non_negative_index("alpha_tk", "T", T); + current_statement__ = 130; + validate_non_negative_index("alpha_tk", "K", K); + current_statement__ = 131; + validate_non_negative_index("beta_tk", "T", T); + current_statement__ = 132; + validate_non_negative_index("beta_tk", "K", K); + current_statement__ = 133; + validate_non_negative_index("gamma_tk", "T", T); + current_statement__ = 134; + validate_non_negative_index("gamma_tk", "K", K); + current_statement__ = 135; + validate_non_negative_index("log_lik", "T", T); + current_statement__ = 136; + validate_non_negative_index("zstar_t", "T", T); + } 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 ***"); } - model_hmm_gaussian(stan::io::var_context& context__, - unsigned int random_seed__, - std::ostream* pstream__ = 0) - : model_base_crtp(0) { - ctor_body(context__, random_seed__, pstream__); + num_params_r__ = 0U; + + try { + num_params_r__ += (K - 1); + num_params_r__ += K * (K - 1); + num_params_r__ += K; + num_params_r__ += K; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); } - void ctor_body(stan::io::var_context& context__, - unsigned int random_seed__, - std::ostream* pstream__) { - typedef double local_scalar_t__; - boost::ecuyer1988 base_rng__ = - stan::services::util::create_rng(random_seed__, 0); - (void) base_rng__; // suppress unused var warning - current_statement_begin__ = -1; - static const char* function__ = "model_hmm_gaussian_namespace::model_hmm_gaussian"; - (void) function__; // dummy to suppress unused var warning - size_t pos__; - (void) pos__; // dummy to suppress unused var warning - std::vector vals_i__; - std::vector vals_r__; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - (void) DUMMY_VAR__; // suppress unused var warning - try { - // initialize data block variables from context__ - current_statement_begin__ = 11; - context__.validate_dims("data initialization", "T", "int", context__.to_vec()); - T = int(0); - vals_i__ = context__.vals_i("T"); - pos__ = 0; - T = vals_i__[pos__++]; - check_greater_or_equal(function__, "T", T, 1); - current_statement_begin__ = 12; - context__.validate_dims("data initialization", "K", "int", context__.to_vec()); - K = int(0); - vals_i__ = context__.vals_i("K"); - pos__ = 0; - K = vals_i__[pos__++]; - check_greater_or_equal(function__, "K", K, 1); - current_statement_begin__ = 13; - validate_non_negative_index("x_t", "T", T); - context__.validate_dims("data initialization", "x_t", "double", context__.to_vec(T)); - x_t = std::vector(T, double(0)); - vals_r__ = context__.vals_r("x_t"); - pos__ = 0; - size_t x_t_k_0_max__ = T; - for (size_t k_0__ = 0; k_0__ < x_t_k_0_max__; ++k_0__) { - x_t[k_0__] = vals_r__[pos__++]; - } - current_statement_begin__ = 14; - context__.validate_dims("data initialization", "est_sigma", "int", context__.to_vec()); - est_sigma = int(0); - vals_i__ = context__.vals_i("est_sigma"); - pos__ = 0; - est_sigma = vals_i__[pos__++]; - check_greater_or_equal(function__, "est_sigma", est_sigma, 0); - current_statement_begin__ = 15; - validate_non_negative_index("sigma_t", "T", T); - context__.validate_dims("data initialization", "sigma_t", "double", context__.to_vec(T)); - sigma_t = std::vector(T, double(0)); - vals_r__ = context__.vals_r("sigma_t"); - pos__ = 0; - size_t sigma_t_k_0_max__ = T; - for (size_t k_0__ = 0; k_0__ < sigma_t_k_0_max__; ++k_0__) { - sigma_t[k_0__] = vals_r__[pos__++]; - } - // initialize transformed data variables - // execute transformed data statements - // validate transformed data - // validate, set parameter ranges - num_params_r__ = 0U; - param_ranges_i__.clear(); - current_statement_begin__ = 20; - validate_non_negative_index("p_1k", "K", K); - num_params_r__ += (K - 1); - current_statement_begin__ = 21; - validate_non_negative_index("A_ij", "K", K); - validate_non_negative_index("A_ij", "K", K); - num_params_r__ += ((K - 1) * K); - current_statement_begin__ = 24; - validate_non_negative_index("mu_k", "K", K); - num_params_r__ += K; - current_statement_begin__ = 25; - validate_non_negative_index("sigma_k", "K", K); - num_params_r__ += (1 * K); - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__()); - // 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 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__; + static const char* function__ = "model_hmm_gaussian_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()); + (void) DUMMY_VAR__; // suppress unused var warning + + try { + Eigen::Matrix p_1k; + p_1k = Eigen::Matrix(K); + stan::math::fill(p_1k, DUMMY_VAR__); + + Eigen::Matrix p_1k_in__; + p_1k_in__ = Eigen::Matrix((K - 1)); + stan::math::fill(p_1k_in__, DUMMY_VAR__); + + current_statement__ = 1; + p_1k_in__ = in__.vector((K - 1)); + current_statement__ = 1; + if (jacobian__) { + current_statement__ = 1; + assign(p_1k, nil_index_list(), + stan::math::simplex_constrain(p_1k_in__, lp__), + "assigning variable p_1k"); + } else { + current_statement__ = 1; + assign(p_1k, nil_index_list(), + stan::math::simplex_constrain(p_1k_in__), "assigning variable p_1k"); + } + std::vector> A_ij; + A_ij = std::vector>(K, Eigen::Matrix(K)); + stan::math::fill(A_ij, DUMMY_VAR__); + + std::vector> A_ij_in__; + A_ij_in__ = std::vector>(K, Eigen::Matrix( + (K - 1))); + stan::math::fill(A_ij_in__, DUMMY_VAR__); + + current_statement__ = 2; + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + current_statement__ = 2; + assign(A_ij_in__, cons_list(index_uni(sym1__), nil_index_list()), + in__.vector((K - 1)), "assigning variable A_ij_in__");} + current_statement__ = 2; + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + assign(A_ij, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::simplex_constrain(A_ij_in__[(sym1__ - 1)], lp__), + "assigning variable A_ij"); + } else { + current_statement__ = 2; + assign(A_ij, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::simplex_constrain(A_ij_in__[(sym1__ - 1)]), + "assigning variable A_ij"); + }} + Eigen::Matrix mu_k; + mu_k = Eigen::Matrix(K); + stan::math::fill(mu_k, DUMMY_VAR__); + + current_statement__ = 3; + mu_k = in__.vector(K); + current_statement__ = 3; + if (jacobian__) { + current_statement__ = 3; + assign(mu_k, nil_index_list(), + stan::math::ordered_constrain(mu_k, lp__), + "assigning variable mu_k"); + } else { + current_statement__ = 3; + assign(mu_k, nil_index_list(), stan::math::ordered_constrain(mu_k), + "assigning variable mu_k"); + } + std::vector sigma_k; + sigma_k = std::vector(K, DUMMY_VAR__); + + current_statement__ = 4; + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + current_statement__ = 4; + assign(sigma_k, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable sigma_k");} + current_statement__ = 4; + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + current_statement__ = 4; + if (jacobian__) { + current_statement__ = 4; + assign(sigma_k, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(sigma_k[(sym1__ - 1)], 0, lp__), + "assigning variable sigma_k"); + } else { + current_statement__ = 4; + assign(sigma_k, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(sigma_k[(sym1__ - 1)], 0), + "assigning variable sigma_k"); + }} + std::vector> unalpha_tk; + unalpha_tk = std::vector>(T, Eigen::Matrix(K)); + stan::math::fill(unalpha_tk, DUMMY_VAR__); + + { + current_statement__ = 6; + validate_non_negative_index("accumulator", "K", K); + std::vector accumulator; + accumulator = std::vector(K, DUMMY_VAR__); + + current_statement__ = 12; + if (logical_eq(est_sigma, 1)) { + current_statement__ = 10; + assign(unalpha_tk, cons_list(index_uni(1), nil_index_list()), + add(stan::math::log(p_1k), + normal_lpdf(x_t[(1 - 1)], mu_k, sigma_k)), + "assigning variable unalpha_tk"); + } else { + current_statement__ = 8; + assign(unalpha_tk, cons_list(index_uni(1), nil_index_list()), + add(stan::math::log(p_1k), + normal_lpdf(x_t[(1 - 1)], mu_k, sigma_t[(1 - 1)])), + "assigning variable unalpha_tk"); } + current_statement__ = 24; + for (int t = 2; t <= T; ++t) { + current_statement__ = 22; + for (int j = 1; j <= K; ++j) { + current_statement__ = 19; + for (int i = 1; i <= K; ++i) { + current_statement__ = 17; + if (logical_eq(est_sigma, 1)) { + current_statement__ = 15; + assign(accumulator, + cons_list(index_uni(i), nil_index_list()), + ((unalpha_tk[((t - 1) - 1)][(i - 1)] + + stan::math::log(A_ij[(i - 1)][(j - 1)])) + + normal_lpdf(x_t[(t - 1)], mu_k[(j - 1)], + sigma_k[(j - 1)])), "assigning variable accumulator"); + } else { + current_statement__ = 13; + assign(accumulator, + cons_list(index_uni(i), nil_index_list()), + ((unalpha_tk[((t - 1) - 1)][(i - 1)] + + stan::math::log(A_ij[(i - 1)][(j - 1)])) + + normal_lpdf(x_t[(t - 1)], mu_k[(j - 1)], + sigma_t[(t - 1)])), "assigning variable accumulator"); + }} + current_statement__ = 20; + assign(unalpha_tk, + cons_list(index_uni(t), + cons_list(index_uni(j), nil_index_list())), + log_sum_exp(accumulator), "assigning variable unalpha_tk");}} + } + { + current_statement__ = 108; + lp_accum__.add(student_t_lpdf(sigma_k, 3, 0, 1)); + current_statement__ = 109; + lp_accum__.add(student_t_lpdf(mu_k, 3, 0, 3)); + current_statement__ = 110; + lp_accum__.add(log_sum_exp(unalpha_tk[(T - 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 ***"); } - ~model_hmm_gaussian() { } - void transform_inits(const stan::io::var_context& context__, - std::vector& params_i__, - std::vector& params_r__, - std::ostream* pstream__) const { - typedef double local_scalar_t__; - stan::io::writer writer__(params_r__, params_i__); - size_t pos__; - (void) pos__; // dummy call to supress warning - std::vector vals_r__; - std::vector vals_i__; - current_statement_begin__ = 20; - if (!(context__.contains_r("p_1k"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable p_1k missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("p_1k"); - pos__ = 0U; - validate_non_negative_index("p_1k", "K", K); - context__.validate_dims("parameter initialization", "p_1k", "vector_d", context__.to_vec(K)); - Eigen::Matrix p_1k(K); - size_t p_1k_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < p_1k_j_1_max__; ++j_1__) { - p_1k(j_1__) = vals_r__[pos__++]; - } - try { - writer__.simplex_unconstrain(p_1k); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable p_1k: ") + e.what()), current_statement_begin__, prog_reader__()); - } - current_statement_begin__ = 21; - if (!(context__.contains_r("A_ij"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable A_ij missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("A_ij"); - pos__ = 0U; - validate_non_negative_index("A_ij", "K", K); - validate_non_negative_index("A_ij", "K", K); - context__.validate_dims("parameter initialization", "A_ij", "vector_d", context__.to_vec(K,K)); - std::vector > A_ij(K, Eigen::Matrix(K)); - size_t A_ij_j_1_max__ = K; - size_t A_ij_k_0_max__ = K; - for (size_t j_1__ = 0; j_1__ < A_ij_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < A_ij_k_0_max__; ++k_0__) { - A_ij[k_0__](j_1__) = vals_r__[pos__++]; - } - } - size_t A_ij_i_0_max__ = K; - for (size_t i_0__ = 0; i_0__ < A_ij_i_0_max__; ++i_0__) { - try { - writer__.simplex_unconstrain(A_ij[i_0__]); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable A_ij: ") + e.what()), current_statement_begin__, prog_reader__()); - } - } - current_statement_begin__ = 24; - if (!(context__.contains_r("mu_k"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable mu_k missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("mu_k"); - pos__ = 0U; - validate_non_negative_index("mu_k", "K", K); - context__.validate_dims("parameter initialization", "mu_k", "vector_d", context__.to_vec(K)); - Eigen::Matrix mu_k(K); - size_t mu_k_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < mu_k_j_1_max__; ++j_1__) { - mu_k(j_1__) = vals_r__[pos__++]; - } - try { - writer__.ordered_unconstrain(mu_k); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable mu_k: ") + e.what()), current_statement_begin__, prog_reader__()); + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // 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; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "model_hmm_gaussian_namespace::write_array"; +(void) function__; // suppress unused var warning + (void) function__; // suppress unused var warning + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + (void) DUMMY_VAR__; // suppress unused var warning + + try { + Eigen::Matrix p_1k; + p_1k = Eigen::Matrix(K); + stan::math::fill(p_1k, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix p_1k_in__; + p_1k_in__ = Eigen::Matrix((K - 1)); + stan::math::fill(p_1k_in__, DUMMY_VAR__); + + current_statement__ = 1; + p_1k_in__ = in__.vector((K - 1)); + current_statement__ = 1; + assign(p_1k, nil_index_list(), + stan::math::simplex_constrain(p_1k_in__), "assigning variable p_1k"); + std::vector> A_ij; + A_ij = std::vector>(K, Eigen::Matrix(K)); + stan::math::fill(A_ij, std::numeric_limits::quiet_NaN()); + + std::vector> A_ij_in__; + A_ij_in__ = std::vector>(K, Eigen::Matrix( + (K - 1))); + stan::math::fill(A_ij_in__, DUMMY_VAR__); + + current_statement__ = 2; + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + current_statement__ = 2; + assign(A_ij_in__, cons_list(index_uni(sym1__), nil_index_list()), + in__.vector((K - 1)), "assigning variable A_ij_in__");} + current_statement__ = 2; + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + current_statement__ = 2; + assign(A_ij, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::simplex_constrain(A_ij_in__[(sym1__ - 1)]), + "assigning variable A_ij");} + Eigen::Matrix mu_k; + mu_k = Eigen::Matrix(K); + stan::math::fill(mu_k, std::numeric_limits::quiet_NaN()); + + current_statement__ = 3; + mu_k = in__.vector(K); + current_statement__ = 3; + assign(mu_k, nil_index_list(), stan::math::ordered_constrain(mu_k), + "assigning variable mu_k"); + std::vector sigma_k; + sigma_k = std::vector(K, std::numeric_limits::quiet_NaN()); + + current_statement__ = 4; + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + current_statement__ = 4; + assign(sigma_k, cons_list(index_uni(sym1__), nil_index_list()), + in__.scalar(), "assigning variable sigma_k");} + current_statement__ = 4; + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + current_statement__ = 4; + assign(sigma_k, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_constrain(sigma_k[(sym1__ - 1)], 0), + "assigning variable sigma_k");} + std::vector> unalpha_tk; + unalpha_tk = std::vector>(T, Eigen::Matrix(K)); + stan::math::fill(unalpha_tk, std::numeric_limits::quiet_NaN()); + + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + vars__.emplace_back(p_1k[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + for (int sym2__ = 1; sym2__ <= K; ++sym2__) { + vars__.emplace_back(A_ij[(sym2__ - 1)][(sym1__ - 1)]);}} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + vars__.emplace_back(mu_k[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + vars__.emplace_back(sigma_k[(sym1__ - 1)]);} + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + { + current_statement__ = 6; + validate_non_negative_index("accumulator", "K", K); + std::vector accumulator; + accumulator = std::vector(K, std::numeric_limits::quiet_NaN()); + + current_statement__ = 12; + if (logical_eq(est_sigma, 1)) { + current_statement__ = 10; + assign(unalpha_tk, cons_list(index_uni(1), nil_index_list()), + add(stan::math::log(p_1k), + normal_lpdf(x_t[(1 - 1)], mu_k, sigma_k)), + "assigning variable unalpha_tk"); + } else { + current_statement__ = 8; + assign(unalpha_tk, cons_list(index_uni(1), nil_index_list()), + add(stan::math::log(p_1k), + normal_lpdf(x_t[(1 - 1)], mu_k, sigma_t[(1 - 1)])), + "assigning variable unalpha_tk"); } - current_statement_begin__ = 25; - if (!(context__.contains_r("sigma_k"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable sigma_k missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("sigma_k"); - pos__ = 0U; - validate_non_negative_index("sigma_k", "K", K); - context__.validate_dims("parameter initialization", "sigma_k", "double", context__.to_vec(K)); - std::vector sigma_k(K, double(0)); - size_t sigma_k_k_0_max__ = K; - for (size_t k_0__ = 0; k_0__ < sigma_k_k_0_max__; ++k_0__) { - sigma_k[k_0__] = vals_r__[pos__++]; + current_statement__ = 24; + for (int t = 2; t <= T; ++t) { + current_statement__ = 22; + for (int j = 1; j <= K; ++j) { + current_statement__ = 19; + for (int i = 1; i <= K; ++i) { + current_statement__ = 17; + if (logical_eq(est_sigma, 1)) { + current_statement__ = 15; + assign(accumulator, + cons_list(index_uni(i), nil_index_list()), + ((unalpha_tk[((t - 1) - 1)][(i - 1)] + + stan::math::log(A_ij[(i - 1)][(j - 1)])) + + normal_lpdf(x_t[(t - 1)], mu_k[(j - 1)], + sigma_k[(j - 1)])), "assigning variable accumulator"); + } else { + current_statement__ = 13; + assign(accumulator, + cons_list(index_uni(i), nil_index_list()), + ((unalpha_tk[((t - 1) - 1)][(i - 1)] + + stan::math::log(A_ij[(i - 1)][(j - 1)])) + + normal_lpdf(x_t[(t - 1)], mu_k[(j - 1)], + sigma_t[(t - 1)])), "assigning variable accumulator"); + }} + current_statement__ = 20; + assign(unalpha_tk, + cons_list(index_uni(t), + cons_list(index_uni(j), nil_index_list())), + log_sum_exp(accumulator), "assigning variable unalpha_tk");}} + } + if (emit_transformed_parameters__) { + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { + vars__.emplace_back(unalpha_tk[(sym2__ - 1)][(sym1__ - 1)]);}} + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + std::vector> unbeta_tk; + unbeta_tk = std::vector>(T, Eigen::Matrix(K)); + stan::math::fill(unbeta_tk, std::numeric_limits::quiet_NaN()); + + std::vector> ungamma_tk; + ungamma_tk = std::vector>(T, Eigen::Matrix(K)); + stan::math::fill(ungamma_tk, std::numeric_limits::quiet_NaN()); + + std::vector> alpha_tk; + alpha_tk = std::vector>(T, Eigen::Matrix(K)); + stan::math::fill(alpha_tk, std::numeric_limits::quiet_NaN()); + + std::vector> beta_tk; + beta_tk = std::vector>(T, Eigen::Matrix(K)); + stan::math::fill(beta_tk, std::numeric_limits::quiet_NaN()); + + std::vector> gamma_tk; + gamma_tk = std::vector>(T, Eigen::Matrix(K)); + stan::math::fill(gamma_tk, std::numeric_limits::quiet_NaN()); + + Eigen::Matrix log_lik; + log_lik = Eigen::Matrix(T); + stan::math::fill(log_lik, std::numeric_limits::quiet_NaN()); + + std::vector zstar_t; + zstar_t = std::vector(T, std::numeric_limits::min()); + + double logp_zstar_t; + logp_zstar_t = std::numeric_limits::quiet_NaN(); + + { + current_statement__ = 35; + for (int t = 1; t <= T; ++t) { + current_statement__ = 34; + assign(alpha_tk, cons_list(index_uni(t), nil_index_list()), + softmax(unalpha_tk[(t - 1)]), "assigning variable alpha_tk");} + } + { + current_statement__ = 37; + validate_non_negative_index("accumulator", "K", K); + std::vector accumulator; + accumulator = std::vector(K, std::numeric_limits::quiet_NaN()); + + current_statement__ = 40; + for (int j = 1; j <= K; ++j) { + current_statement__ = 39; + assign(unbeta_tk, + cons_list(index_uni(T), + cons_list(index_uni(j), nil_index_list())), 1, + "assigning variable unbeta_tk");} + current_statement__ = 54; + for (int tforward = 0; tforward <= (T - 2); ++tforward) { + int t; + t = std::numeric_limits::min(); + + current_statement__ = 42; + t = (T - tforward); + current_statement__ = 52; + for (int j = 1; j <= K; ++j) { + current_statement__ = 49; + for (int i = 1; i <= K; ++i) { + current_statement__ = 47; + if (logical_eq(est_sigma, 1)) { + current_statement__ = 45; + assign(accumulator, + cons_list(index_uni(i), nil_index_list()), + ((unbeta_tk[(t - 1)][(i - 1)] + + stan::math::log(A_ij[(j - 1)][(i - 1)])) + + normal_lpdf(x_t[(t - 1)], mu_k[(i - 1)], + sigma_k[(i - 1)])), "assigning variable accumulator"); + } else { + current_statement__ = 43; + assign(accumulator, + cons_list(index_uni(i), nil_index_list()), + ((unbeta_tk[(t - 1)][(i - 1)] + + stan::math::log(A_ij[(j - 1)][(i - 1)])) + + normal_lpdf(x_t[(t - 1)], mu_k[(i - 1)], + sigma_t[(t - 1)])), "assigning variable accumulator"); + }} + current_statement__ = 50; + assign(unbeta_tk, + cons_list(index_uni((t - 1)), + cons_list(index_uni(j), nil_index_list())), + log_sum_exp(accumulator), "assigning variable unbeta_tk");}} + current_statement__ = 56; + for (int t = 1; t <= T; ++t) { + current_statement__ = 55; + assign(beta_tk, cons_list(index_uni(t), nil_index_list()), + softmax(unbeta_tk[(t - 1)]), "assigning variable beta_tk");} + } + { + current_statement__ = 61; + for (int t = 1; t <= T; ++t) { + current_statement__ = 58; + assign(ungamma_tk, cons_list(index_uni(t), nil_index_list()), + elt_multiply(alpha_tk[(t - 1)], beta_tk[(t - 1)]), + "assigning variable ungamma_tk"); + current_statement__ = 59; + assign(gamma_tk, cons_list(index_uni(t), nil_index_list()), + normalize(ungamma_tk[(t - 1)], pstream__), + "assigning variable gamma_tk");} + current_statement__ = 68; + for (int t = 1; t <= T; ++t) { + current_statement__ = 62; + assign(log_lik, cons_list(index_uni(t), nil_index_list()), 0, + "assigning variable log_lik"); + current_statement__ = 65; + for (int j = 1; j <= K; ++j) { + current_statement__ = 63; + assign(log_lik, cons_list(index_uni(t), nil_index_list()), + (log_lik[(t - 1)] + + (gamma_tk[(t - 1)][(j - 1)] * alpha_tk[(t - 1)][(j - 1)])), + "assigning variable log_lik");} + current_statement__ = 66; + assign(log_lik, cons_list(index_uni(t), nil_index_list()), + stan::math::log(log_lik[(t - 1)]), "assigning variable log_lik"); } - size_t sigma_k_i_0_max__ = K; - for (size_t i_0__ = 0; i_0__ < sigma_k_i_0_max__; ++i_0__) { - try { - writer__.scalar_lb_unconstrain(0, sigma_k[i_0__]); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable sigma_k: ") + e.what()), current_statement_begin__, prog_reader__()); - } + } + { + current_statement__ = 70; + validate_non_negative_index("a_tk", "T", T); + current_statement__ = 71; + validate_non_negative_index("a_tk", "K", K); + std::vector> a_tk; + a_tk = std::vector>(T, std::vector(K, std::numeric_limits::min())); + + current_statement__ = 73; + validate_non_negative_index("delta_tk", "T", T); + current_statement__ = 74; + validate_non_negative_index("delta_tk", "K", K); + std::vector> delta_tk; + delta_tk = std::vector>(T, std::vector(K, std::numeric_limits::quiet_NaN())); + + current_statement__ = 82; + if (logical_eq(est_sigma, 1)) { + current_statement__ = 80; + for (int j = 1; j <= K; ++j) { + current_statement__ = 79; + assign(delta_tk, + cons_list(index_uni(1), + cons_list(index_uni(K), nil_index_list())), + normal_lpdf(x_t[(1 - 1)], mu_k[(j - 1)], + sigma_k[(j - 1)]), "assigning variable delta_tk");} + } else { + current_statement__ = 77; + for (int j = 1; j <= K; ++j) { + current_statement__ = 76; + assign(delta_tk, + cons_list(index_uni(1), + cons_list(index_uni(K), nil_index_list())), + normal_lpdf(x_t[(1 - 1)], mu_k[(j - 1)], + sigma_t[(1 - 1)]), "assigning variable delta_tk");} } - params_r__ = writer__.data_r(); - params_i__ = writer__.data_i(); + current_statement__ = 99; + for (int t = 2; t <= T; ++t) { + current_statement__ = 97; + for (int j = 1; j <= K; ++j) { + current_statement__ = 83; + assign(delta_tk, + cons_list(index_uni(t), + cons_list(index_uni(j), nil_index_list())), + stan::math::negative_infinity(), "assigning variable delta_tk"); + current_statement__ = 95; + for (int i = 1; i <= K; ++i) { + double logp; + logp = std::numeric_limits::quiet_NaN(); + + current_statement__ = 89; + if (logical_eq(est_sigma, 1)) { + current_statement__ = 87; + logp = ((delta_tk[((t - 1) - 1)][(i - 1)] + + stan::math::log(A_ij[(i - 1)][(j - 1)])) + + normal_lpdf(x_t[(t - 1)], mu_k[(j - 1)], + sigma_k[(j - 1)])); + } else { + current_statement__ = 85; + logp = ((delta_tk[((t - 1) - 1)][(i - 1)] + + stan::math::log(A_ij[(i - 1)][(j - 1)])) + + normal_lpdf(x_t[(t - 1)], mu_k[(j - 1)], + sigma_t[(t - 1)])); + } + current_statement__ = 93; + if (logical_gt(logp, delta_tk[(t - 1)][(j - 1)])) { + current_statement__ = 90; + assign(a_tk, + cons_list(index_uni(t), + cons_list(index_uni(j), nil_index_list())), i, + "assigning variable a_tk"); + current_statement__ = 91; + assign(delta_tk, + cons_list(index_uni(t), + cons_list(index_uni(j), nil_index_list())), logp, + "assigning variable delta_tk"); + } }}} + current_statement__ = 100; + logp_zstar_t = max(delta_tk[(T - 1)]); + current_statement__ = 103; + for (int j = 1; j <= K; ++j) { + current_statement__ = 102; + if (logical_eq(delta_tk[(T - 1)][(j - 1)], logp_zstar_t)) { + current_statement__ = 101; + assign(zstar_t, cons_list(index_uni(T), nil_index_list()), j, + "assigning variable zstar_t"); + } } + current_statement__ = 106; + for (int t = 1; t <= (T - 1); ++t) { + current_statement__ = 104; + assign(zstar_t, cons_list(index_uni((T - t)), nil_index_list()), + a_tk[(((T - t) + 1) - 1)][(zstar_t[(((T - t) + 1) - 1)] - 1)], + "assigning variable zstar_t");} + } + current_statement__ = 32; + for (int sym1__ = 1; sym1__ <= T; ++sym1__) { + current_statement__ = 32; + current_statement__ = 32; + check_greater_or_equal(function__, "zstar_t[sym1__]", + zstar_t[(sym1__ - 1)], 1);} + current_statement__ = 32; + for (int sym1__ = 1; sym1__ <= T; ++sym1__) { + current_statement__ = 32; + current_statement__ = 32; + check_less_or_equal(function__, "zstar_t[sym1__]", + zstar_t[(sym1__ - 1)], K);} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { + vars__.emplace_back(unbeta_tk[(sym2__ - 1)][(sym1__ - 1)]);}} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { + vars__.emplace_back(ungamma_tk[(sym2__ - 1)][(sym1__ - 1)]);}} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { + vars__.emplace_back(alpha_tk[(sym2__ - 1)][(sym1__ - 1)]);}} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { + vars__.emplace_back(beta_tk[(sym2__ - 1)][(sym1__ - 1)]);}} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { + vars__.emplace_back(gamma_tk[(sym2__ - 1)][(sym1__ - 1)]);}} + for (int sym1__ = 1; sym1__ <= T; ++sym1__) { + vars__.emplace_back(log_lik[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= T; ++sym1__) { + vars__.emplace_back(zstar_t[(sym1__ - 1)]);} + vars__.emplace_back(logp_zstar_t); + } 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 ***"); } - void transform_inits(const stan::io::var_context& context, - Eigen::Matrix& params_r, - std::ostream* pstream__) const { - std::vector params_r_vec; - std::vector params_i_vec; - transform_inits(context, params_i_vec, params_r_vec, pstream__); - params_r.resize(params_r_vec.size()); - for (int i = 0; i < params_r.size(); ++i) - params_r(i) = params_r_vec[i]; + } // 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; + vars__.clear(); + vars__.reserve(num_params_r__); + + try { + int pos__; + pos__ = std::numeric_limits::min(); + + pos__ = 1; + Eigen::Matrix p_1k; + p_1k = Eigen::Matrix(K); + stan::math::fill(p_1k, std::numeric_limits::quiet_NaN()); + + { + std::vector p_1k_flat__; + current_statement__ = 1; + assign(p_1k_flat__, nil_index_list(), context__.vals_r("p_1k"), + "assigning variable p_1k_flat__"); + current_statement__ = 1; + pos__ = 1; + current_statement__ = 1; + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + current_statement__ = 1; + assign(p_1k, cons_list(index_uni(sym1__), nil_index_list()), + p_1k_flat__[(pos__ - 1)], "assigning variable p_1k"); + current_statement__ = 1; + pos__ = (pos__ + 1);} + } + Eigen::Matrix p_1k_free__; + p_1k_free__ = Eigen::Matrix((K - 1)); + stan::math::fill(p_1k_free__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 1; + assign(p_1k_free__, nil_index_list(), stan::math::simplex_free(p_1k), + "assigning variable p_1k_free__"); + std::vector> A_ij; + A_ij = std::vector>(K, Eigen::Matrix(K)); + stan::math::fill(A_ij, std::numeric_limits::quiet_NaN()); + + { + std::vector A_ij_flat__; + current_statement__ = 2; + assign(A_ij_flat__, nil_index_list(), context__.vals_r("A_ij"), + "assigning variable A_ij_flat__"); + current_statement__ = 2; + pos__ = 1; + current_statement__ = 2; + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + current_statement__ = 2; + for (int sym2__ = 1; sym2__ <= K; ++sym2__) { + current_statement__ = 2; + assign(A_ij, + cons_list(index_uni(sym2__), + cons_list(index_uni(sym1__), nil_index_list())), + A_ij_flat__[(pos__ - 1)], "assigning variable A_ij"); + current_statement__ = 2; + pos__ = (pos__ + 1);}} + } + std::vector> A_ij_free__; + A_ij_free__ = std::vector>(K, Eigen::Matrix( + (K - 1))); + stan::math::fill(A_ij_free__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 2; + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + current_statement__ = 2; + assign(A_ij_free__, cons_list(index_uni(sym1__), nil_index_list()), + stan::math::simplex_free(A_ij[(sym1__ - 1)]), + "assigning variable A_ij_free__");} + Eigen::Matrix mu_k; + mu_k = Eigen::Matrix(K); + stan::math::fill(mu_k, std::numeric_limits::quiet_NaN()); + + { + std::vector mu_k_flat__; + current_statement__ = 3; + assign(mu_k_flat__, nil_index_list(), context__.vals_r("mu_k"), + "assigning variable mu_k_flat__"); + current_statement__ = 3; + pos__ = 1; + current_statement__ = 3; + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + current_statement__ = 3; + assign(mu_k, cons_list(index_uni(sym1__), nil_index_list()), + mu_k_flat__[(pos__ - 1)], "assigning variable mu_k"); + current_statement__ = 3; + pos__ = (pos__ + 1);} + } + Eigen::Matrix mu_k_free__; + mu_k_free__ = Eigen::Matrix(K); + stan::math::fill(mu_k_free__, std::numeric_limits::quiet_NaN()); + + current_statement__ = 3; + assign(mu_k_free__, nil_index_list(), stan::math::ordered_free(mu_k), + "assigning variable mu_k_free__"); + std::vector sigma_k; + sigma_k = std::vector(K, std::numeric_limits::quiet_NaN()); + + current_statement__ = 4; + assign(sigma_k, nil_index_list(), context__.vals_r("sigma_k"), + "assigning variable sigma_k"); + std::vector sigma_k_free__; + sigma_k_free__ = std::vector(K, std::numeric_limits::quiet_NaN()); + + current_statement__ = 4; + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + current_statement__ = 4; + assign(sigma_k_free__, + cons_list(index_uni(sym1__), nil_index_list()), + stan::math::lb_free(sigma_k[(sym1__ - 1)], 0), + "assigning variable sigma_k_free__");} + for (int sym1__ = 1; sym1__ <= (K - 1); ++sym1__) { + vars__.emplace_back(p_1k_free__[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + for (int sym2__ = 1; sym2__ <= (K - 1); ++sym2__) { + vars__.emplace_back(A_ij_free__[(sym1__ - 1)][(sym2__ - 1)]);}} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + vars__.emplace_back(mu_k_free__[(sym1__ - 1)]);} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + vars__.emplace_back(sigma_k_free__[(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 - T__ log_prob(std::vector& params_r__, - std::vector& params_i__, - std::ostream* pstream__ = 0) const { - typedef T__ local_scalar_t__; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - (void) DUMMY_VAR__; // dummy to suppress unused var warning - T__ lp__(0.0); - stan::math::accumulator lp_accum__; - try { - stan::io::reader in__(params_r__, params_i__); - // model parameters - current_statement_begin__ = 20; - Eigen::Matrix p_1k; - (void) p_1k; // dummy to suppress unused var warning - if (jacobian__) - p_1k = in__.simplex_constrain(K, lp__); - else - p_1k = in__.simplex_constrain(K); - current_statement_begin__ = 21; - std::vector > A_ij; - size_t A_ij_d_0_max__ = K; - A_ij.reserve(A_ij_d_0_max__); - for (size_t d_0__ = 0; d_0__ < A_ij_d_0_max__; ++d_0__) { - if (jacobian__) - A_ij.push_back(in__.simplex_constrain(K, lp__)); - else - A_ij.push_back(in__.simplex_constrain(K)); - } - current_statement_begin__ = 24; - Eigen::Matrix mu_k; - (void) mu_k; // dummy to suppress unused var warning - if (jacobian__) - mu_k = in__.ordered_constrain(K, lp__); - else - mu_k = in__.ordered_constrain(K); - current_statement_begin__ = 25; - std::vector sigma_k; - size_t sigma_k_d_0_max__ = K; - sigma_k.reserve(sigma_k_d_0_max__); - for (size_t d_0__ = 0; d_0__ < sigma_k_d_0_max__; ++d_0__) { - if (jacobian__) - sigma_k.push_back(in__.scalar_lb_constrain(0, lp__)); - else - sigma_k.push_back(in__.scalar_lb_constrain(0)); - } - // transformed parameters - current_statement_begin__ = 29; - validate_non_negative_index("unalpha_tk", "K", K); - validate_non_negative_index("unalpha_tk", "T", T); - std::vector > unalpha_tk(T, Eigen::Matrix(K)); - stan::math::initialize(unalpha_tk, DUMMY_VAR__); - stan::math::fill(unalpha_tk, DUMMY_VAR__); - // transformed parameters block statements + } // transform_inits_impl() + + inline void get_param_names(std::vector& names__) const { + + names__.clear(); + names__.emplace_back("p_1k"); + names__.emplace_back("A_ij"); + names__.emplace_back("mu_k"); + names__.emplace_back("sigma_k"); + names__.emplace_back("unalpha_tk"); + names__.emplace_back("unbeta_tk"); + names__.emplace_back("ungamma_tk"); + names__.emplace_back("alpha_tk"); + names__.emplace_back("beta_tk"); + names__.emplace_back("gamma_tk"); + names__.emplace_back("log_lik"); + names__.emplace_back("zstar_t"); + names__.emplace_back("logp_zstar_t"); + } // get_param_names() + + inline void get_dims(std::vector>& dimss__) const { + dimss__.clear(); + dimss__.emplace_back(std::vector{static_cast(K)}); + + dimss__.emplace_back(std::vector{static_cast(K), + static_cast(K)}); + + dimss__.emplace_back(std::vector{static_cast(K)}); + + dimss__.emplace_back(std::vector{static_cast(K)}); + + dimss__.emplace_back(std::vector{static_cast(T), + static_cast(K)}); + + dimss__.emplace_back(std::vector{static_cast(T), + static_cast(K)}); + + dimss__.emplace_back(std::vector{static_cast(T), + static_cast(K)}); + + dimss__.emplace_back(std::vector{static_cast(T), + static_cast(K)}); + + dimss__.emplace_back(std::vector{static_cast(T), + static_cast(K)}); + + dimss__.emplace_back(std::vector{static_cast(T), + static_cast(K)}); + + dimss__.emplace_back(std::vector{static_cast(T)}); + + dimss__.emplace_back(std::vector{static_cast(T)}); + + 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 { + + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + param_names__.emplace_back(std::string() + "p_1k" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= K; ++sym2__) { + { + param_names__.emplace_back(std::string() + "A_ij" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + param_names__.emplace_back(std::string() + "mu_k" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + param_names__.emplace_back(std::string() + "sigma_k" + '.' + std::to_string(sym1__)); + }} + if (emit_transformed_parameters__) { + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { { - current_statement_begin__ = 32; - validate_non_negative_index("accumulator", "K", K); - std::vector accumulator(K, local_scalar_t__(DUMMY_VAR__)); - stan::math::initialize(accumulator, DUMMY_VAR__); - stan::math::fill(accumulator, DUMMY_VAR__); - current_statement_begin__ = 34; - if (as_bool(logical_eq(est_sigma, 1))) { - current_statement_begin__ = 36; - stan::model::assign(unalpha_tk, - stan::model::cons_list(stan::model::index_uni(1), stan::model::nil_index_list()), - add(stan::math::log(p_1k), normal_log(get_base1(x_t, 1, "x_t", 1), mu_k, sigma_k)), - "assigning variable unalpha_tk"); - } else { - current_statement_begin__ = 39; - stan::model::assign(unalpha_tk, - stan::model::cons_list(stan::model::index_uni(1), stan::model::nil_index_list()), - add(stan::math::log(p_1k), normal_log(get_base1(x_t, 1, "x_t", 1), mu_k, get_base1(sigma_t, 1, "sigma_t", 1))), - "assigning variable unalpha_tk"); - } - current_statement_begin__ = 42; - for (int t = 2; t <= T; ++t) { - current_statement_begin__ = 43; - for (int j = 1; j <= K; ++j) { - current_statement_begin__ = 44; - for (int i = 1; i <= K; ++i) { - current_statement_begin__ = 47; - if (as_bool(logical_eq(est_sigma, 1))) { - current_statement_begin__ = 49; - stan::model::assign(accumulator, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - ((get_base1(get_base1(unalpha_tk, (t - 1), "unalpha_tk", 1), i, "unalpha_tk", 2) + stan::math::log(get_base1(get_base1(A_ij, i, "A_ij", 1), j, "A_ij", 2))) + normal_log(get_base1(x_t, t, "x_t", 1), get_base1(mu_k, j, "mu_k", 1), get_base1(sigma_k, j, "sigma_k", 1))), - "assigning variable accumulator"); - } else { - current_statement_begin__ = 52; - stan::model::assign(accumulator, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - ((get_base1(get_base1(unalpha_tk, (t - 1), "unalpha_tk", 1), i, "unalpha_tk", 2) + stan::math::log(get_base1(get_base1(A_ij, i, "A_ij", 1), j, "A_ij", 2))) + normal_log(get_base1(x_t, t, "x_t", 1), get_base1(mu_k, j, "mu_k", 1), get_base1(sigma_t, t, "sigma_t", 1))), - "assigning variable accumulator"); - } - } - current_statement_begin__ = 56; - stan::model::assign(unalpha_tk, - stan::model::cons_list(stan::model::index_uni(t), stan::model::cons_list(stan::model::index_uni(j), stan::model::nil_index_list())), - log_sum_exp(accumulator), - "assigning variable unalpha_tk"); - } - } - } - // validate transformed parameters - const char* function__ = "validate transformed params"; - (void) function__; // dummy to suppress unused var warning - current_statement_begin__ = 29; - size_t unalpha_tk_k_0_max__ = T; - size_t unalpha_tk_j_1_max__ = K; - for (size_t k_0__ = 0; k_0__ < unalpha_tk_k_0_max__; ++k_0__) { - for (size_t j_1__ = 0; j_1__ < unalpha_tk_j_1_max__; ++j_1__) { - if (stan::math::is_uninitialized(unalpha_tk[k_0__](j_1__))) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: unalpha_tk" << "[" << k_0__ << "]" << "(" << j_1__ << ")"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable unalpha_tk: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - } - // model body - current_statement_begin__ = 63; - lp_accum__.add(student_t_log(sigma_k, 3, 0, 1)); - current_statement_begin__ = 64; - lp_accum__.add(student_t_log(mu_k, 3, 0, 3)); - current_statement_begin__ = 65; - lp_accum__.add(log_sum_exp(get_base1(unalpha_tk, T, "unalpha_tk", 1))); - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__()); - // Next line prevents compiler griping about no return - throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); - } - lp_accum__.add(lp__); - return lp_accum__.sum(); - } // log_prob() - template - T_ log_prob(Eigen::Matrix& params_r, - std::ostream* pstream = 0) const { - std::vector vec_params_r; - vec_params_r.reserve(params_r.size()); - for (int i = 0; i < params_r.size(); ++i) - vec_params_r.push_back(params_r(i)); - std::vector vec_params_i; - return log_prob(vec_params_r, vec_params_i, pstream); + param_names__.emplace_back(std::string() + "unalpha_tk" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} } - void get_param_names(std::vector& names__) const { - names__.resize(0); - names__.push_back("p_1k"); - names__.push_back("A_ij"); - names__.push_back("mu_k"); - names__.push_back("sigma_k"); - names__.push_back("unalpha_tk"); - names__.push_back("unbeta_tk"); - names__.push_back("ungamma_tk"); - names__.push_back("alpha_tk"); - names__.push_back("beta_tk"); - names__.push_back("gamma_tk"); - names__.push_back("log_lik"); - names__.push_back("zstar_t"); - names__.push_back("logp_zstar_t"); + + if (emit_generated_quantities__) { + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { + { + param_names__.emplace_back(std::string() + "unbeta_tk" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { + { + param_names__.emplace_back(std::string() + "ungamma_tk" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { + { + param_names__.emplace_back(std::string() + "alpha_tk" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { + { + param_names__.emplace_back(std::string() + "beta_tk" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { + { + param_names__.emplace_back(std::string() + "gamma_tk" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= T; ++sym1__) { + { + param_names__.emplace_back(std::string() + "log_lik" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= T; ++sym1__) { + { + param_names__.emplace_back(std::string() + "zstar_t" + '.' + std::to_string(sym1__)); + }} + param_names__.emplace_back(std::string() + "logp_zstar_t"); } - void get_dims(std::vector >& dimss__) const { - dimss__.resize(0); - std::vector dims__; - dims__.resize(0); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(K); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(T); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(T); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(T); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(T); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(T); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(T); - dims__.push_back(K); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(T); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(T); - dimss__.push_back(dims__); - dims__.resize(0); - dimss__.push_back(dims__); + + } // 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__ <= (K - 1); ++sym1__) { + { + param_names__.emplace_back(std::string() + "p_1k" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= (K - 1); ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= K; ++sym2__) { + { + param_names__.emplace_back(std::string() + "A_ij" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + param_names__.emplace_back(std::string() + "mu_k" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + param_names__.emplace_back(std::string() + "sigma_k" + '.' + std::to_string(sym1__)); + }} + if (emit_transformed_parameters__) { + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { + { + param_names__.emplace_back(std::string() + "unalpha_tk" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} } - template - void write_array(RNG& base_rng__, - std::vector& params_r__, - std::vector& params_i__, - std::vector& vars__, - bool include_tparams__ = true, - bool include_gqs__ = true, - std::ostream* pstream__ = 0) const { - typedef double local_scalar_t__; - vars__.resize(0); - stan::io::reader in__(params_r__, params_i__); - static const char* function__ = "model_hmm_gaussian_namespace::write_array"; - (void) function__; // dummy to suppress unused var warning - // read-transform, write parameters - Eigen::Matrix p_1k = in__.simplex_constrain(K); - size_t p_1k_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < p_1k_j_1_max__; ++j_1__) { - vars__.push_back(p_1k(j_1__)); - } - std::vector > A_ij; - size_t A_ij_d_0_max__ = K; - A_ij.reserve(A_ij_d_0_max__); - for (size_t d_0__ = 0; d_0__ < A_ij_d_0_max__; ++d_0__) { - A_ij.push_back(in__.simplex_constrain(K)); - } - size_t A_ij_j_1_max__ = K; - size_t A_ij_k_0_max__ = K; - for (size_t j_1__ = 0; j_1__ < A_ij_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < A_ij_k_0_max__; ++k_0__) { - vars__.push_back(A_ij[k_0__](j_1__)); - } - } - Eigen::Matrix mu_k = in__.ordered_constrain(K); - size_t mu_k_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < mu_k_j_1_max__; ++j_1__) { - vars__.push_back(mu_k(j_1__)); - } - std::vector sigma_k; - size_t sigma_k_d_0_max__ = K; - sigma_k.reserve(sigma_k_d_0_max__); - for (size_t d_0__ = 0; d_0__ < sigma_k_d_0_max__; ++d_0__) { - sigma_k.push_back(in__.scalar_lb_constrain(0)); - } - size_t sigma_k_k_0_max__ = K; - for (size_t k_0__ = 0; k_0__ < sigma_k_k_0_max__; ++k_0__) { - vars__.push_back(sigma_k[k_0__]); - } - double lp__ = 0.0; - (void) lp__; // dummy to suppress unused var warning - stan::math::accumulator lp_accum__; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - (void) DUMMY_VAR__; // suppress unused var warning - if (!include_tparams__ && !include_gqs__) return; - try { - // declare and define transformed parameters - current_statement_begin__ = 29; - validate_non_negative_index("unalpha_tk", "K", K); - validate_non_negative_index("unalpha_tk", "T", T); - std::vector > unalpha_tk(T, Eigen::Matrix(K)); - stan::math::initialize(unalpha_tk, DUMMY_VAR__); - stan::math::fill(unalpha_tk, DUMMY_VAR__); - // do transformed parameters statements + + if (emit_generated_quantities__) { + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { { - current_statement_begin__ = 32; - validate_non_negative_index("accumulator", "K", K); - std::vector accumulator(K, local_scalar_t__(DUMMY_VAR__)); - stan::math::initialize(accumulator, DUMMY_VAR__); - stan::math::fill(accumulator, DUMMY_VAR__); - current_statement_begin__ = 34; - if (as_bool(logical_eq(est_sigma, 1))) { - current_statement_begin__ = 36; - stan::model::assign(unalpha_tk, - stan::model::cons_list(stan::model::index_uni(1), stan::model::nil_index_list()), - add(stan::math::log(p_1k), normal_log(get_base1(x_t, 1, "x_t", 1), mu_k, sigma_k)), - "assigning variable unalpha_tk"); - } else { - current_statement_begin__ = 39; - stan::model::assign(unalpha_tk, - stan::model::cons_list(stan::model::index_uni(1), stan::model::nil_index_list()), - add(stan::math::log(p_1k), normal_log(get_base1(x_t, 1, "x_t", 1), mu_k, get_base1(sigma_t, 1, "sigma_t", 1))), - "assigning variable unalpha_tk"); - } - current_statement_begin__ = 42; - for (int t = 2; t <= T; ++t) { - current_statement_begin__ = 43; - for (int j = 1; j <= K; ++j) { - current_statement_begin__ = 44; - for (int i = 1; i <= K; ++i) { - current_statement_begin__ = 47; - if (as_bool(logical_eq(est_sigma, 1))) { - current_statement_begin__ = 49; - stan::model::assign(accumulator, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - ((get_base1(get_base1(unalpha_tk, (t - 1), "unalpha_tk", 1), i, "unalpha_tk", 2) + stan::math::log(get_base1(get_base1(A_ij, i, "A_ij", 1), j, "A_ij", 2))) + normal_log(get_base1(x_t, t, "x_t", 1), get_base1(mu_k, j, "mu_k", 1), get_base1(sigma_k, j, "sigma_k", 1))), - "assigning variable accumulator"); - } else { - current_statement_begin__ = 52; - stan::model::assign(accumulator, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - ((get_base1(get_base1(unalpha_tk, (t - 1), "unalpha_tk", 1), i, "unalpha_tk", 2) + stan::math::log(get_base1(get_base1(A_ij, i, "A_ij", 1), j, "A_ij", 2))) + normal_log(get_base1(x_t, t, "x_t", 1), get_base1(mu_k, j, "mu_k", 1), get_base1(sigma_t, t, "sigma_t", 1))), - "assigning variable accumulator"); - } - } - current_statement_begin__ = 56; - stan::model::assign(unalpha_tk, - stan::model::cons_list(stan::model::index_uni(t), stan::model::cons_list(stan::model::index_uni(j), stan::model::nil_index_list())), - log_sum_exp(accumulator), - "assigning variable unalpha_tk"); - } - } - } - if (!include_gqs__ && !include_tparams__) return; - // validate transformed parameters - const char* function__ = "validate transformed params"; - (void) function__; // dummy to suppress unused var warning - // write transformed parameters - if (include_tparams__) { - size_t unalpha_tk_j_1_max__ = K; - size_t unalpha_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < unalpha_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < unalpha_tk_k_0_max__; ++k_0__) { - vars__.push_back(unalpha_tk[k_0__](j_1__)); - } - } - } - if (!include_gqs__) return; - // declare and define generated quantities - current_statement_begin__ = 69; - validate_non_negative_index("unbeta_tk", "K", K); - validate_non_negative_index("unbeta_tk", "T", T); - std::vector > unbeta_tk(T, Eigen::Matrix(K)); - stan::math::initialize(unbeta_tk, DUMMY_VAR__); - stan::math::fill(unbeta_tk, DUMMY_VAR__); - current_statement_begin__ = 70; - validate_non_negative_index("ungamma_tk", "K", K); - validate_non_negative_index("ungamma_tk", "T", T); - std::vector > ungamma_tk(T, Eigen::Matrix(K)); - stan::math::initialize(ungamma_tk, DUMMY_VAR__); - stan::math::fill(ungamma_tk, DUMMY_VAR__); - current_statement_begin__ = 71; - validate_non_negative_index("alpha_tk", "K", K); - validate_non_negative_index("alpha_tk", "T", T); - std::vector > alpha_tk(T, Eigen::Matrix(K)); - stan::math::initialize(alpha_tk, DUMMY_VAR__); - stan::math::fill(alpha_tk, DUMMY_VAR__); - current_statement_begin__ = 72; - validate_non_negative_index("beta_tk", "K", K); - validate_non_negative_index("beta_tk", "T", T); - std::vector > beta_tk(T, Eigen::Matrix(K)); - stan::math::initialize(beta_tk, DUMMY_VAR__); - stan::math::fill(beta_tk, DUMMY_VAR__); - current_statement_begin__ = 73; - validate_non_negative_index("gamma_tk", "K", K); - validate_non_negative_index("gamma_tk", "T", T); - std::vector > gamma_tk(T, Eigen::Matrix(K)); - stan::math::initialize(gamma_tk, DUMMY_VAR__); - stan::math::fill(gamma_tk, DUMMY_VAR__); - current_statement_begin__ = 74; - validate_non_negative_index("log_lik", "T", T); - Eigen::Matrix log_lik(T); - stan::math::initialize(log_lik, DUMMY_VAR__); - stan::math::fill(log_lik, DUMMY_VAR__); - current_statement_begin__ = 75; - validate_non_negative_index("zstar_t", "T", T); - std::vector zstar_t(T, int(0)); - stan::math::fill(zstar_t, std::numeric_limits::min()); - current_statement_begin__ = 76; - double logp_zstar_t; - (void) logp_zstar_t; // dummy to suppress unused var warning - stan::math::initialize(logp_zstar_t, DUMMY_VAR__); - stan::math::fill(logp_zstar_t, DUMMY_VAR__); - // generated quantities statements - current_statement_begin__ = 79; - for (int t = 1; t <= T; ++t) { - current_statement_begin__ = 80; - stan::model::assign(alpha_tk, - stan::model::cons_list(stan::model::index_uni(t), stan::model::nil_index_list()), - softmax(get_base1(unalpha_tk, t, "unalpha_tk", 1)), - "assigning variable alpha_tk"); - } + param_names__.emplace_back(std::string() + "unbeta_tk" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { { - current_statement_begin__ = 84; - validate_non_negative_index("accumulator", "K", K); - std::vector accumulator(K, local_scalar_t__(DUMMY_VAR__)); - stan::math::initialize(accumulator, DUMMY_VAR__); - stan::math::fill(accumulator, DUMMY_VAR__); - current_statement_begin__ = 86; - for (int j = 1; j <= K; ++j) { - current_statement_begin__ = 87; - stan::model::assign(unbeta_tk, - stan::model::cons_list(stan::model::index_uni(T), stan::model::cons_list(stan::model::index_uni(j), stan::model::nil_index_list())), - 1, - "assigning variable unbeta_tk"); - } - current_statement_begin__ = 89; - for (int tforward = 0; tforward <= (T - 2); ++tforward) { - { - current_statement_begin__ = 90; - int t(0); - (void) t; // dummy to suppress unused var warning - stan::math::fill(t, std::numeric_limits::min()); - current_statement_begin__ = 91; - stan::math::assign(t, (T - tforward)); - current_statement_begin__ = 93; - for (int j = 1; j <= K; ++j) { - current_statement_begin__ = 94; - for (int i = 1; i <= K; ++i) { - current_statement_begin__ = 97; - if (as_bool(logical_eq(est_sigma, 1))) { - current_statement_begin__ = 98; - stan::model::assign(accumulator, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - ((get_base1(get_base1(unbeta_tk, t, "unbeta_tk", 1), i, "unbeta_tk", 2) + stan::math::log(get_base1(get_base1(A_ij, j, "A_ij", 1), i, "A_ij", 2))) + normal_log(get_base1(x_t, t, "x_t", 1), get_base1(mu_k, i, "mu_k", 1), get_base1(sigma_k, i, "sigma_k", 1))), - "assigning variable accumulator"); - } else { - current_statement_begin__ = 100; - stan::model::assign(accumulator, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - ((get_base1(get_base1(unbeta_tk, t, "unbeta_tk", 1), i, "unbeta_tk", 2) + stan::math::log(get_base1(get_base1(A_ij, j, "A_ij", 1), i, "A_ij", 2))) + normal_log(get_base1(x_t, t, "x_t", 1), get_base1(mu_k, i, "mu_k", 1), get_base1(sigma_t, t, "sigma_t", 1))), - "assigning variable accumulator"); - } - } - current_statement_begin__ = 104; - stan::model::assign(unbeta_tk, - stan::model::cons_list(stan::model::index_uni((t - 1)), stan::model::cons_list(stan::model::index_uni(j), stan::model::nil_index_list())), - log_sum_exp(accumulator), - "assigning variable unbeta_tk"); - } - } - } - current_statement_begin__ = 108; - for (int t = 1; t <= T; ++t) { - current_statement_begin__ = 109; - stan::model::assign(beta_tk, - stan::model::cons_list(stan::model::index_uni(t), stan::model::nil_index_list()), - softmax(get_base1(unbeta_tk, t, "unbeta_tk", 1)), - "assigning variable beta_tk"); - } - } - current_statement_begin__ = 113; - for (int t = 1; t <= T; ++t) { - current_statement_begin__ = 114; - stan::model::assign(ungamma_tk, - stan::model::cons_list(stan::model::index_uni(t), stan::model::nil_index_list()), - elt_multiply(get_base1(alpha_tk, t, "alpha_tk", 1), get_base1(beta_tk, t, "beta_tk", 1)), - "assigning variable ungamma_tk"); - current_statement_begin__ = 115; - stan::model::assign(gamma_tk, - stan::model::cons_list(stan::model::index_uni(t), stan::model::nil_index_list()), - normalize(get_base1(ungamma_tk, t, "ungamma_tk", 1), pstream__), - "assigning variable gamma_tk"); - } - current_statement_begin__ = 118; - for (int t = 1; t <= T; ++t) { - current_statement_begin__ = 121; - stan::model::assign(log_lik, - stan::model::cons_list(stan::model::index_uni(t), stan::model::nil_index_list()), - 0, - "assigning variable log_lik"); - current_statement_begin__ = 126; - for (int j = 1; j <= K; ++j) { - current_statement_begin__ = 127; - stan::model::assign(log_lik, - stan::model::cons_list(stan::model::index_uni(t), stan::model::nil_index_list()), - (get_base1(log_lik, t, "log_lik", 1) + (get_base1(get_base1(gamma_tk, t, "gamma_tk", 1), j, "gamma_tk", 2) * get_base1(get_base1(alpha_tk, t, "alpha_tk", 1), j, "alpha_tk", 2))), - "assigning variable log_lik"); - } - current_statement_begin__ = 133; - stan::model::assign(log_lik, - stan::model::cons_list(stan::model::index_uni(t), stan::model::nil_index_list()), - stan::math::log(get_base1(log_lik, t, "log_lik", 1)), - "assigning variable log_lik"); - } + param_names__.emplace_back(std::string() + "ungamma_tk" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { { - current_statement_begin__ = 139; - validate_non_negative_index("a_tk", "T", T); - validate_non_negative_index("a_tk", "K", K); - std::vector > a_tk(T, std::vector(K, int(0))); - stan::math::fill(a_tk, std::numeric_limits::min()); - current_statement_begin__ = 140; - validate_non_negative_index("delta_tk", "T", T); - validate_non_negative_index("delta_tk", "K", K); - std::vector > delta_tk(T, std::vector(K, local_scalar_t__(DUMMY_VAR__))); - stan::math::initialize(delta_tk, DUMMY_VAR__); - stan::math::fill(delta_tk, DUMMY_VAR__); - current_statement_begin__ = 142; - if (as_bool(logical_eq(est_sigma, 1))) { - current_statement_begin__ = 143; - for (int j = 1; j <= K; ++j) { - current_statement_begin__ = 144; - stan::model::assign(delta_tk, - stan::model::cons_list(stan::model::index_uni(1), stan::model::cons_list(stan::model::index_uni(K), stan::model::nil_index_list())), - normal_log(get_base1(x_t, 1, "x_t", 1), get_base1(mu_k, j, "mu_k", 1), get_base1(sigma_k, j, "sigma_k", 1)), - "assigning variable delta_tk"); - } - } else { - current_statement_begin__ = 146; - for (int j = 1; j <= K; ++j) { - current_statement_begin__ = 147; - stan::model::assign(delta_tk, - stan::model::cons_list(stan::model::index_uni(1), stan::model::cons_list(stan::model::index_uni(K), stan::model::nil_index_list())), - normal_log(get_base1(x_t, 1, "x_t", 1), get_base1(mu_k, j, "mu_k", 1), get_base1(sigma_t, 1, "sigma_t", 1)), - "assigning variable delta_tk"); - } - } - current_statement_begin__ = 150; - for (int t = 2; t <= T; ++t) { - current_statement_begin__ = 151; - for (int j = 1; j <= K; ++j) { - current_statement_begin__ = 152; - stan::model::assign(delta_tk, - stan::model::cons_list(stan::model::index_uni(t), stan::model::cons_list(stan::model::index_uni(j), stan::model::nil_index_list())), - stan::math::negative_infinity(), - "assigning variable delta_tk"); - current_statement_begin__ = 153; - for (int i = 1; i <= K; ++i) { - { - current_statement_begin__ = 154; - local_scalar_t__ logp(DUMMY_VAR__); - (void) logp; // dummy to suppress unused var warning - stan::math::initialize(logp, DUMMY_VAR__); - stan::math::fill(logp, DUMMY_VAR__); - current_statement_begin__ = 155; - if (as_bool(logical_eq(est_sigma, 1))) { - current_statement_begin__ = 156; - stan::math::assign(logp, ((get_base1(get_base1(delta_tk, (t - 1), "delta_tk", 1), i, "delta_tk", 2) + stan::math::log(get_base1(get_base1(A_ij, i, "A_ij", 1), j, "A_ij", 2))) + normal_log(get_base1(x_t, t, "x_t", 1), get_base1(mu_k, j, "mu_k", 1), get_base1(sigma_k, j, "sigma_k", 1)))); - } else { - current_statement_begin__ = 158; - stan::math::assign(logp, ((get_base1(get_base1(delta_tk, (t - 1), "delta_tk", 1), i, "delta_tk", 2) + stan::math::log(get_base1(get_base1(A_ij, i, "A_ij", 1), j, "A_ij", 2))) + normal_log(get_base1(x_t, t, "x_t", 1), get_base1(mu_k, j, "mu_k", 1), get_base1(sigma_t, t, "sigma_t", 1)))); - } - current_statement_begin__ = 160; - if (as_bool(logical_gt(logp, get_base1(get_base1(delta_tk, t, "delta_tk", 1), j, "delta_tk", 2)))) { - current_statement_begin__ = 161; - stan::model::assign(a_tk, - stan::model::cons_list(stan::model::index_uni(t), stan::model::cons_list(stan::model::index_uni(j), stan::model::nil_index_list())), - i, - "assigning variable a_tk"); - current_statement_begin__ = 162; - stan::model::assign(delta_tk, - stan::model::cons_list(stan::model::index_uni(t), stan::model::cons_list(stan::model::index_uni(j), stan::model::nil_index_list())), - logp, - "assigning variable delta_tk"); - } - } - } - } - } - current_statement_begin__ = 168; - stan::math::assign(logp_zstar_t, max(get_base1(delta_tk, T, "delta_tk", 1))); - current_statement_begin__ = 170; - for (int j = 1; j <= K; ++j) { - current_statement_begin__ = 171; - if (as_bool(logical_eq(get_base1(get_base1(delta_tk, T, "delta_tk", 1), j, "delta_tk", 2), logp_zstar_t))) { - current_statement_begin__ = 172; - stan::model::assign(zstar_t, - stan::model::cons_list(stan::model::index_uni(T), stan::model::nil_index_list()), - j, - "assigning variable zstar_t"); - } - } - current_statement_begin__ = 174; - for (int t = 1; t <= (T - 1); ++t) { - current_statement_begin__ = 175; - stan::model::assign(zstar_t, - stan::model::cons_list(stan::model::index_uni((T - t)), stan::model::nil_index_list()), - get_base1(get_base1(a_tk, ((T - t) + 1), "a_tk", 1), get_base1(zstar_t, ((T - t) + 1), "zstar_t", 1), "a_tk", 2), - "assigning variable zstar_t"); - } - } - // validate, write generated quantities - current_statement_begin__ = 69; - size_t unbeta_tk_j_1_max__ = K; - size_t unbeta_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < unbeta_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < unbeta_tk_k_0_max__; ++k_0__) { - vars__.push_back(unbeta_tk[k_0__](j_1__)); - } - } - current_statement_begin__ = 70; - size_t ungamma_tk_j_1_max__ = K; - size_t ungamma_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < ungamma_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < ungamma_tk_k_0_max__; ++k_0__) { - vars__.push_back(ungamma_tk[k_0__](j_1__)); - } - } - current_statement_begin__ = 71; - size_t alpha_tk_j_1_max__ = K; - size_t alpha_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < alpha_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < alpha_tk_k_0_max__; ++k_0__) { - vars__.push_back(alpha_tk[k_0__](j_1__)); - } - } - current_statement_begin__ = 72; - size_t beta_tk_j_1_max__ = K; - size_t beta_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < beta_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < beta_tk_k_0_max__; ++k_0__) { - vars__.push_back(beta_tk[k_0__](j_1__)); - } - } - current_statement_begin__ = 73; - size_t gamma_tk_j_1_max__ = K; - size_t gamma_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < gamma_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < gamma_tk_k_0_max__; ++k_0__) { - vars__.push_back(gamma_tk[k_0__](j_1__)); - } - } - current_statement_begin__ = 74; - size_t log_lik_j_1_max__ = T; - for (size_t j_1__ = 0; j_1__ < log_lik_j_1_max__; ++j_1__) { - vars__.push_back(log_lik(j_1__)); - } - current_statement_begin__ = 75; - size_t zstar_t_i_0_max__ = T; - for (size_t i_0__ = 0; i_0__ < zstar_t_i_0_max__; ++i_0__) { - check_greater_or_equal(function__, "zstar_t[i_0__]", zstar_t[i_0__], 1); - check_less_or_equal(function__, "zstar_t[i_0__]", zstar_t[i_0__], K); - } - size_t zstar_t_k_0_max__ = T; - for (size_t k_0__ = 0; k_0__ < zstar_t_k_0_max__; ++k_0__) { - vars__.push_back(zstar_t[k_0__]); - } - current_statement_begin__ = 76; - vars__.push_back(logp_zstar_t); - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__()); - // Next line prevents compiler griping about no return - throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); - } + param_names__.emplace_back(std::string() + "alpha_tk" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { + { + param_names__.emplace_back(std::string() + "beta_tk" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= K; ++sym1__) { + { + for (int sym2__ = 1; sym2__ <= T; ++sym2__) { + { + param_names__.emplace_back(std::string() + "gamma_tk" + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__)); + }} + }} + for (int sym1__ = 1; sym1__ <= T; ++sym1__) { + { + param_names__.emplace_back(std::string() + "log_lik" + '.' + std::to_string(sym1__)); + }} + for (int sym1__ = 1; sym1__ <= T; ++sym1__) { + { + param_names__.emplace_back(std::string() + "zstar_t" + '.' + std::to_string(sym1__)); + }} + param_names__.emplace_back(std::string() + "logp_zstar_t"); } + + } // unconstrained_param_names() + + inline std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"p_1k\",\"type\":{\"name\":\"vector\",\"length\":" << K << "},\"block\":\"parameters\"},{\"name\":\"A_ij\",\"type\":{\"name\":\"array\",\"length\":" << K << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"parameters\"},{\"name\":\"mu_k\",\"type\":{\"name\":\"vector\",\"length\":" << K << "},\"block\":\"parameters\"},{\"name\":\"sigma_k\",\"type\":{\"name\":\"array\",\"length\":" << K << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"unalpha_tk\",\"type\":{\"name\":\"array\",\"length\":" << T << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"transformed_parameters\"},{\"name\":\"unbeta_tk\",\"type\":{\"name\":\"array\",\"length\":" << T << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"generated_quantities\"},{\"name\":\"ungamma_tk\",\"type\":{\"name\":\"array\",\"length\":" << T << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"generated_quantities\"},{\"name\":\"alpha_tk\",\"type\":{\"name\":\"array\",\"length\":" << T << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"generated_quantities\"},{\"name\":\"beta_tk\",\"type\":{\"name\":\"array\",\"length\":" << T << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"generated_quantities\"},{\"name\":\"gamma_tk\",\"type\":{\"name\":\"array\",\"length\":" << T << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"generated_quantities\"},{\"name\":\"log_lik\",\"type\":{\"name\":\"vector\",\"length\":" << T << "},\"block\":\"generated_quantities\"},{\"name\":\"zstar_t\",\"type\":{\"name\":\"array\",\"length\":" << T << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"logp_zstar_t\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + inline std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"p_1k\",\"type\":{\"name\":\"vector\",\"length\":" << (K - 1) << "},\"block\":\"parameters\"},{\"name\":\"A_ij\",\"type\":{\"name\":\"array\",\"length\":" << K << ",\"element_type\":{\"name\":\"vector\",\"length\":" << (K - 1) << "}},\"block\":\"parameters\"},{\"name\":\"mu_k\",\"type\":{\"name\":\"vector\",\"length\":" << K << "},\"block\":\"parameters\"},{\"name\":\"sigma_k\",\"type\":{\"name\":\"array\",\"length\":" << K << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"unalpha_tk\",\"type\":{\"name\":\"array\",\"length\":" << T << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"transformed_parameters\"},{\"name\":\"unbeta_tk\",\"type\":{\"name\":\"array\",\"length\":" << T << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"generated_quantities\"},{\"name\":\"ungamma_tk\",\"type\":{\"name\":\"array\",\"length\":" << T << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"generated_quantities\"},{\"name\":\"alpha_tk\",\"type\":{\"name\":\"array\",\"length\":" << T << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"generated_quantities\"},{\"name\":\"beta_tk\",\"type\":{\"name\":\"array\",\"length\":" << T << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"generated_quantities\"},{\"name\":\"gamma_tk\",\"type\":{\"name\":\"array\",\"length\":" << T << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"generated_quantities\"},{\"name\":\"log_lik\",\"type\":{\"name\":\"vector\",\"length\":" << T << "},\"block\":\"generated_quantities\"},{\"name\":\"zstar_t\",\"type\":{\"name\":\"array\",\"length\":" << T << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"logp_zstar_t\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate template - void write_array(RNG& base_rng, - Eigen::Matrix& params_r, - Eigen::Matrix& vars, - bool include_tparams = true, - bool include_gqs = true, - std::ostream* pstream = 0) const { - std::vector params_r_vec(params_r.size()); - for (int i = 0; i < params_r.size(); ++i) - params_r_vec[i] = params_r(i); - std::vector vars_vec; - std::vector params_i_vec; - write_array(base_rng, params_r_vec, params_i_vec, vars_vec, include_tparams, include_gqs, pstream); + 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(i) = vars_vec[i]; + for (int i = 0; i < vars.size(); ++i) { + vars.coeffRef(i) = vars_vec[i]; + } } - std::string model_name() const { - return "model_hmm_gaussian"; + 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); } - void constrained_param_names(std::vector& param_names__, - bool include_tparams__ = true, - bool include_gqs__ = true) const { - std::stringstream param_name_stream__; - size_t p_1k_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < p_1k_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "p_1k" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t A_ij_j_1_max__ = K; - size_t A_ij_k_0_max__ = K; - for (size_t j_1__ = 0; j_1__ < A_ij_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < A_ij_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "A_ij" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t mu_k_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < mu_k_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "mu_k" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t sigma_k_k_0_max__ = K; - for (size_t k_0__ = 0; k_0__ < sigma_k_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma_k" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - if (!include_gqs__ && !include_tparams__) return; - if (include_tparams__) { - size_t unalpha_tk_j_1_max__ = K; - size_t unalpha_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < unalpha_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < unalpha_tk_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "unalpha_tk" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - } - if (!include_gqs__) return; - size_t unbeta_tk_j_1_max__ = K; - size_t unbeta_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < unbeta_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < unbeta_tk_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "unbeta_tk" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t ungamma_tk_j_1_max__ = K; - size_t ungamma_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < ungamma_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < ungamma_tk_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "ungamma_tk" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t alpha_tk_j_1_max__ = K; - size_t alpha_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < alpha_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < alpha_tk_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "alpha_tk" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t beta_tk_j_1_max__ = K; - size_t beta_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < beta_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < beta_tk_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "beta_tk" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t gamma_tk_j_1_max__ = K; - size_t gamma_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < gamma_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < gamma_tk_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "gamma_tk" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t log_lik_j_1_max__ = T; - for (size_t j_1__ = 0; j_1__ < log_lik_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "log_lik" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t zstar_t_k_0_max__ = T; - for (size_t k_0__ = 0; k_0__ < zstar_t_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "zstar_t" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - param_name_stream__.str(std::string()); - param_name_stream__ << "logp_zstar_t"; - param_names__.push_back(param_name_stream__.str()); + 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); } - void unconstrained_param_names(std::vector& param_names__, - bool include_tparams__ = true, - bool include_gqs__ = true) const { - std::stringstream param_name_stream__; - size_t p_1k_j_1_max__ = (K - 1); - for (size_t j_1__ = 0; j_1__ < p_1k_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "p_1k" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t A_ij_j_1_max__ = (K - 1); - size_t A_ij_k_0_max__ = K; - for (size_t j_1__ = 0; j_1__ < A_ij_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < A_ij_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "A_ij" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t mu_k_j_1_max__ = K; - for (size_t j_1__ = 0; j_1__ < mu_k_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "mu_k" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t sigma_k_k_0_max__ = K; - for (size_t k_0__ = 0; k_0__ < sigma_k_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma_k" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - if (!include_gqs__ && !include_tparams__) return; - if (include_tparams__) { - size_t unalpha_tk_j_1_max__ = K; - size_t unalpha_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < unalpha_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < unalpha_tk_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "unalpha_tk" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - } - if (!include_gqs__) return; - size_t unbeta_tk_j_1_max__ = K; - size_t unbeta_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < unbeta_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < unbeta_tk_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "unbeta_tk" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t ungamma_tk_j_1_max__ = K; - size_t ungamma_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < ungamma_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < ungamma_tk_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "ungamma_tk" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t alpha_tk_j_1_max__ = K; - size_t alpha_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < alpha_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < alpha_tk_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "alpha_tk" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t beta_tk_j_1_max__ = K; - size_t beta_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < beta_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < beta_tk_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "beta_tk" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t gamma_tk_j_1_max__ = K; - size_t gamma_tk_k_0_max__ = T; - for (size_t j_1__ = 0; j_1__ < gamma_tk_j_1_max__; ++j_1__) { - for (size_t k_0__ = 0; k_0__ < gamma_tk_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "gamma_tk" << '.' << k_0__ + 1 << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - size_t log_lik_j_1_max__ = T; - for (size_t j_1__ = 0; j_1__ < log_lik_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "log_lik" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - size_t zstar_t_k_0_max__ = T; - for (size_t k_0__ = 0; k_0__ < zstar_t_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "zstar_t" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - param_name_stream__.str(std::string()); - param_name_stream__ << "logp_zstar_t"; - param_names__.push_back(param_name_stream__.str()); + 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]; + } } -}; // model -} // namespace -typedef model_hmm_gaussian_namespace::model_hmm_gaussian stan_model; + 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_hmm_gaussian_namespace::model_hmm_gaussian; #ifndef USING_R +// Boilerplate stan::model::model_base& new_model( stan::io::var_context& data_context, unsigned int seed, @@ -1151,5 +1391,8 @@ stan::model::model_base& new_model( stan_model* m = new stan_model(data_context, seed, msg_stream); return *m; } +stan::math::profile_map& get_stan_profile_data() { + return model_hmm_gaussian_namespace::profiles__; +} #endif #endif diff --git a/src/stanExports_regime_1.h b/src/stanExports_regime_1.h index 34b6caf..3f1c566 100644 --- a/src/stanExports_regime_1.h +++ b/src/stanExports_regime_1.h @@ -17,451 +17,522 @@ #ifndef MODELS_HPP #define MODELS_HPP #define STAN__SERVICES__COMMAND_HPP +#ifndef USE_STANC3 +#define USE_STANC3 +#endif #include -// Code generated by Stan version 2.21.0 +// Code generated by stanc v2.26.1-4-gd72b68b7-dirty #include namespace model_regime_1_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::prob_grad; +using stan::model::model_base_crtp; +using stan::model::rvalue; +using stan::model::cons_list; +using stan::model::index_uni; +using stan::model::index_max; +using stan::model::index_min; +using stan::model::index_min_max; +using stan::model::index_multi; +using stan::model::index_omni; +using stan::model::nil_index_list; using namespace stan::math; -static int current_statement_begin__; -stan::io::program_reader prog_reader__() { - stan::io::program_reader reader; - reader.add_event(0, 0, "start", "model_regime_1"); - reader.add_event(34, 32, "end", "model_regime_1"); - return reader; -} +using stan::math::pow; +stan::math::profile_map profiles__; +static int current_statement__= 0; +static const std::vector locations_array__ = {" (found before start of program)", + " (in 'regime_1', line 9, column 2 to column 12)", + " (in 'regime_1', line 10, column 2 to column 24)", + " (in 'regime_1', line 13, column 2 to column 17)", + " (in 'regime_1', line 17, column 18 to column 41)", + " (in 'regime_1', line 17, column 4 to column 41)", + " (in 'regime_1', line 16, column 9 to line 18, column 3)", + " (in 'regime_1', line 15, column 18 to column 38)", + " (in 'regime_1', line 15, column 4 to column 38)", + " (in 'regime_1', line 14, column 21 to line 16, column 3)", + " (in 'regime_1', line 14, column 2 to line 18, column 3)", + " (in 'regime_1', line 26, column 2 to column 20)", + " (in 'regime_1', line 29, column 4 to column 55)", + " (in 'regime_1', line 28, column 17 to line 30, column 3)", + " (in 'regime_1', line 28, column 2 to line 30, column 3)", + " (in 'regime_1', line 21, column 2 to column 28)", + " (in 'regime_1', line 22, column 2 to column 31)", + " (in 'regime_1', line 23, column 2 to column 29)", + " (in 'regime_1', line 2, column 2 to column 17)", + " (in 'regime_1', line 3, column 2 to column 17)", + " (in 'regime_1', line 4, column 11 to column 12)", + " (in 'regime_1', line 4, column 2 to column 14)", + " (in 'regime_1', line 5, column 2 to column 25)", + " (in 'regime_1', line 6, column 15 to column 16)", + " (in 'regime_1', line 6, column 2 to column 18)", + " (in 'regime_1', line 13, column 14 to column 15)", + " (in 'regime_1', line 26, column 9 to column 10)"}; #include -class model_regime_1 - : public stan::model::model_base_crtp { +class model_regime_1 final : public model_base_crtp { private: - int T; - int K; - std::vector x_t; - int est_sigma; - std::vector sigma_t; + int T; + int K; + std::vector x_t; + int est_sigma; + std::vector sigma_t; + public: - model_regime_1(stan::io::var_context& context__, - std::ostream* pstream__ = 0) - : model_base_crtp(0) { - ctor_body(context__, 0, pstream__); + ~model_regime_1() { } + + inline std::string model_name() const final { return "model_regime_1"; } + inline std::vector model_compile_info() const noexcept { + return std::vector{"stanc_version = stanc3 v2.26.1-4-gd72b68b7-dirty", "stancflags = "}; + } + + + model_regime_1(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_regime_1_namespace::model_regime_1"; + (void) function__; // suppress unused var warning + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + (void) DUMMY_VAR__; // suppress unused var warning + + try { + int pos__; + pos__ = std::numeric_limits::min(); + + pos__ = 1; + current_statement__ = 18; + context__.validate_dims("data initialization","T","int", + context__.to_vec()); + T = std::numeric_limits::min(); + + current_statement__ = 18; + T = context__.vals_i("T")[(1 - 1)]; + current_statement__ = 18; + current_statement__ = 18; + check_greater_or_equal(function__, "T", T, 1); + current_statement__ = 19; + context__.validate_dims("data initialization","K","int", + context__.to_vec()); + K = std::numeric_limits::min(); + + current_statement__ = 19; + K = context__.vals_i("K")[(1 - 1)]; + current_statement__ = 19; + current_statement__ = 19; + check_greater_or_equal(function__, "K", K, 1); + current_statement__ = 20; + validate_non_negative_index("x_t", "T", T); + current_statement__ = 21; + context__.validate_dims("data initialization","x_t","double", + context__.to_vec(T)); + x_t = std::vector(T, std::numeric_limits::quiet_NaN()); + + current_statement__ = 21; + assign(x_t, nil_index_list(), context__.vals_r("x_t"), + "assigning variable x_t"); + current_statement__ = 22; + context__.validate_dims("data initialization","est_sigma","int", + context__.to_vec()); + est_sigma = std::numeric_limits::min(); + + current_statement__ = 22; + est_sigma = context__.vals_i("est_sigma")[(1 - 1)]; + current_statement__ = 22; + current_statement__ = 22; + check_greater_or_equal(function__, "est_sigma", est_sigma, 0); + current_statement__ = 23; + validate_non_negative_index("sigma_t", "T", T); + current_statement__ = 24; + context__.validate_dims("data initialization","sigma_t","double", + context__.to_vec(T)); + sigma_t = std::vector(T, std::numeric_limits::quiet_NaN()); + + current_statement__ = 24; + assign(sigma_t, nil_index_list(), context__.vals_r("sigma_t"), + "assigning variable sigma_t"); + current_statement__ = 25; + validate_non_negative_index("sigmas", "T", T); + current_statement__ = 26; + validate_non_negative_index("log_lik", "T", T); + } 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 ***"); } - model_regime_1(stan::io::var_context& context__, - unsigned int random_seed__, - std::ostream* pstream__ = 0) - : model_base_crtp(0) { - ctor_body(context__, random_seed__, pstream__); + num_params_r__ = 0U; + + try { + num_params_r__ += 1; + num_params_r__ += 1; + } catch (const std::exception& e) { + stan::lang::rethrow_located(e, locations_array__[current_statement__]); + // Next line prevents compiler griping about no return + throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); } - void ctor_body(stan::io::var_context& context__, - unsigned int random_seed__, - std::ostream* pstream__) { - typedef double local_scalar_t__; - boost::ecuyer1988 base_rng__ = - stan::services::util::create_rng(random_seed__, 0); - (void) base_rng__; // suppress unused var warning - current_statement_begin__ = -1; - static const char* function__ = "model_regime_1_namespace::model_regime_1"; - (void) function__; // dummy to suppress unused var warning - size_t pos__; - (void) pos__; // dummy to suppress unused var warning - std::vector vals_i__; - std::vector vals_r__; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - (void) DUMMY_VAR__; // suppress unused var warning - try { - // initialize data block variables from context__ - current_statement_begin__ = 2; - context__.validate_dims("data initialization", "T", "int", context__.to_vec()); - T = int(0); - vals_i__ = context__.vals_i("T"); - pos__ = 0; - T = vals_i__[pos__++]; - check_greater_or_equal(function__, "T", T, 1); - current_statement_begin__ = 3; - context__.validate_dims("data initialization", "K", "int", context__.to_vec()); - K = int(0); - vals_i__ = context__.vals_i("K"); - pos__ = 0; - K = vals_i__[pos__++]; - check_greater_or_equal(function__, "K", K, 1); - current_statement_begin__ = 4; - validate_non_negative_index("x_t", "T", T); - context__.validate_dims("data initialization", "x_t", "double", context__.to_vec(T)); - x_t = std::vector(T, double(0)); - vals_r__ = context__.vals_r("x_t"); - pos__ = 0; - size_t x_t_k_0_max__ = T; - for (size_t k_0__ = 0; k_0__ < x_t_k_0_max__; ++k_0__) { - x_t[k_0__] = vals_r__[pos__++]; - } - current_statement_begin__ = 5; - context__.validate_dims("data initialization", "est_sigma", "int", context__.to_vec()); - est_sigma = int(0); - vals_i__ = context__.vals_i("est_sigma"); - pos__ = 0; - est_sigma = vals_i__[pos__++]; - check_greater_or_equal(function__, "est_sigma", est_sigma, 0); - current_statement_begin__ = 6; - validate_non_negative_index("sigma_t", "T", T); - context__.validate_dims("data initialization", "sigma_t", "double", context__.to_vec(T)); - sigma_t = std::vector(T, double(0)); - vals_r__ = context__.vals_r("sigma_t"); - pos__ = 0; - size_t sigma_t_k_0_max__ = T; - for (size_t k_0__ = 0; k_0__ < sigma_t_k_0_max__; ++k_0__) { - sigma_t[k_0__] = vals_r__[pos__++]; - } - // initialize transformed data variables - // execute transformed data statements - // validate transformed data - // validate, set parameter ranges - num_params_r__ = 0U; - param_ranges_i__.clear(); - current_statement_begin__ = 9; - num_params_r__ += 1; - current_statement_begin__ = 10; - num_params_r__ += 1; - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__()); - // 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 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__; + static const char* function__ = "model_regime_1_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()); + (void) DUMMY_VAR__; // suppress unused var warning + + try { + local_scalar_t__ mu_k; + mu_k = DUMMY_VAR__; + + current_statement__ = 1; + mu_k = in__.scalar(); + local_scalar_t__ sigma_k; + sigma_k = DUMMY_VAR__; + + current_statement__ = 2; + sigma_k = in__.scalar(); + current_statement__ = 2; + if (jacobian__) { + current_statement__ = 2; + sigma_k = stan::math::lb_constrain(sigma_k, 0, lp__); + } else { + current_statement__ = 2; + sigma_k = stan::math::lb_constrain(sigma_k, 0); + } + std::vector sigmas; + sigmas = std::vector(T, DUMMY_VAR__); + + current_statement__ = 10; + if (logical_eq(est_sigma, 1)) { + current_statement__ = 8; + for (int i = 1; i <= T; ++i) { + current_statement__ = 7; + assign(sigmas, cons_list(index_uni(i), nil_index_list()), sigma_k, + "assigning variable sigmas");} + } else { + current_statement__ = 5; + for (int i = 1; i <= T; ++i) { + current_statement__ = 4; + assign(sigmas, cons_list(index_uni(i), nil_index_list()), + sigma_t[(i - 1)], "assigning variable sigmas");} + } + { + current_statement__ = 15; + lp_accum__.add(student_t_lpdf(mu_k, 3, 0, 3)); + current_statement__ = 16; + lp_accum__.add(student_t_lpdf(sigma_k, 3, 0, 1)); + current_statement__ = 17; + lp_accum__.add(normal_lpdf(x_t, mu_k, sigmas)); + } + } 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 ***"); } - ~model_regime_1() { } - void transform_inits(const stan::io::var_context& context__, - std::vector& params_i__, - std::vector& params_r__, - std::ostream* pstream__) const { - typedef double local_scalar_t__; - stan::io::writer writer__(params_r__, params_i__); - size_t pos__; - (void) pos__; // dummy call to supress warning - std::vector vals_r__; - std::vector vals_i__; - current_statement_begin__ = 9; - if (!(context__.contains_r("mu_k"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable mu_k missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("mu_k"); - pos__ = 0U; - context__.validate_dims("parameter initialization", "mu_k", "double", context__.to_vec()); - double mu_k(0); - mu_k = vals_r__[pos__++]; - try { - writer__.scalar_unconstrain(mu_k); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable mu_k: ") + e.what()), current_statement_begin__, prog_reader__()); - } - current_statement_begin__ = 10; - if (!(context__.contains_r("sigma_k"))) - stan::lang::rethrow_located(std::runtime_error(std::string("Variable sigma_k missing")), current_statement_begin__, prog_reader__()); - vals_r__ = context__.vals_r("sigma_k"); - pos__ = 0U; - context__.validate_dims("parameter initialization", "sigma_k", "double", context__.to_vec()); - double sigma_k(0); - sigma_k = vals_r__[pos__++]; - try { - writer__.scalar_lb_unconstrain(0, sigma_k); - } catch (const std::exception& e) { - stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable sigma_k: ") + e.what()), current_statement_begin__, prog_reader__()); - } - params_r__ = writer__.data_r(); - params_i__ = writer__.data_i(); + lp_accum__.add(lp__); + return lp_accum__.sum(); + } // 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; + vars__.resize(0); + stan::io::reader in__(params_r__, params_i__); + static const char* function__ = "model_regime_1_namespace::write_array"; +(void) function__; // suppress unused var warning + (void) function__; // suppress unused var warning + double lp__ = 0.0; + (void) lp__; // dummy to suppress unused var warning + stan::math::accumulator lp_accum__; + local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); + (void) DUMMY_VAR__; // suppress unused var warning + + try { + double mu_k; + mu_k = std::numeric_limits::quiet_NaN(); + + current_statement__ = 1; + mu_k = in__.scalar(); + double sigma_k; + sigma_k = std::numeric_limits::quiet_NaN(); + + current_statement__ = 2; + sigma_k = in__.scalar(); + current_statement__ = 2; + sigma_k = stan::math::lb_constrain(sigma_k, 0); + std::vector sigmas; + sigmas = std::vector(T, std::numeric_limits::quiet_NaN()); + + vars__.emplace_back(mu_k); + vars__.emplace_back(sigma_k); + if (logical_negation((primitive_value(emit_transformed_parameters__) || + primitive_value(emit_generated_quantities__)))) { + return ; + } + current_statement__ = 10; + if (logical_eq(est_sigma, 1)) { + current_statement__ = 8; + for (int i = 1; i <= T; ++i) { + current_statement__ = 7; + assign(sigmas, cons_list(index_uni(i), nil_index_list()), sigma_k, + "assigning variable sigmas");} + } else { + current_statement__ = 5; + for (int i = 1; i <= T; ++i) { + current_statement__ = 4; + assign(sigmas, cons_list(index_uni(i), nil_index_list()), + sigma_t[(i - 1)], "assigning variable sigmas");} + } + if (emit_transformed_parameters__) { + for (int sym1__ = 1; sym1__ <= T; ++sym1__) { + vars__.emplace_back(sigmas[(sym1__ - 1)]);} + } + if (logical_negation(emit_generated_quantities__)) { + return ; + } + Eigen::Matrix log_lik; + log_lik = Eigen::Matrix(T); + stan::math::fill(log_lik, std::numeric_limits::quiet_NaN()); + + current_statement__ = 14; + for (int n = 1; n <= T; ++n) { + current_statement__ = 12; + assign(log_lik, cons_list(index_uni(n), nil_index_list()), + normal_lpdf(x_t[(n - 1)], mu_k, sigmas[(n - 1)]), + "assigning variable log_lik");} + for (int sym1__ = 1; sym1__ <= T; ++sym1__) { + vars__.emplace_back(log_lik[(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 ***"); } - void transform_inits(const stan::io::var_context& context, - Eigen::Matrix& params_r, - std::ostream* pstream__) const { - std::vector params_r_vec; - std::vector params_i_vec; - transform_inits(context, params_i_vec, params_r_vec, pstream__); - params_r.resize(params_r_vec.size()); - for (int i = 0; i < params_r.size(); ++i) - params_r(i) = params_r_vec[i]; + } // 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; + vars__.clear(); + vars__.reserve(num_params_r__); + + try { + int pos__; + pos__ = std::numeric_limits::min(); + + pos__ = 1; + double mu_k; + mu_k = std::numeric_limits::quiet_NaN(); + + current_statement__ = 1; + mu_k = context__.vals_r("mu_k")[(1 - 1)]; + double sigma_k; + sigma_k = std::numeric_limits::quiet_NaN(); + + current_statement__ = 2; + sigma_k = context__.vals_r("sigma_k")[(1 - 1)]; + double sigma_k_free__; + sigma_k_free__ = std::numeric_limits::quiet_NaN(); + + current_statement__ = 2; + sigma_k_free__ = stan::math::lb_free(sigma_k, 0); + vars__.emplace_back(mu_k); + vars__.emplace_back(sigma_k_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 ***"); } - template - T__ log_prob(std::vector& params_r__, - std::vector& params_i__, - std::ostream* pstream__ = 0) const { - typedef T__ local_scalar_t__; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - (void) DUMMY_VAR__; // dummy to suppress unused var warning - T__ lp__(0.0); - stan::math::accumulator lp_accum__; - try { - stan::io::reader in__(params_r__, params_i__); - // model parameters - current_statement_begin__ = 9; - local_scalar_t__ mu_k; - (void) mu_k; // dummy to suppress unused var warning - if (jacobian__) - mu_k = in__.scalar_constrain(lp__); - else - mu_k = in__.scalar_constrain(); - current_statement_begin__ = 10; - local_scalar_t__ sigma_k; - (void) sigma_k; // dummy to suppress unused var warning - if (jacobian__) - sigma_k = in__.scalar_lb_constrain(0, lp__); - else - sigma_k = in__.scalar_lb_constrain(0); - // transformed parameters - current_statement_begin__ = 13; - validate_non_negative_index("sigmas", "T", T); - std::vector sigmas(T, local_scalar_t__(0)); - stan::math::initialize(sigmas, DUMMY_VAR__); - stan::math::fill(sigmas, DUMMY_VAR__); - // transformed parameters block statements - current_statement_begin__ = 14; - if (as_bool(logical_eq(est_sigma, 1))) { - current_statement_begin__ = 15; - for (int i = 1; i <= T; ++i) { - current_statement_begin__ = 15; - stan::model::assign(sigmas, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - sigma_k, - "assigning variable sigmas"); - } - } else { - current_statement_begin__ = 17; - for (int i = 1; i <= T; ++i) { - current_statement_begin__ = 17; - stan::model::assign(sigmas, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - get_base1(sigma_t, i, "sigma_t", 1), - "assigning variable sigmas"); - } - } - // validate transformed parameters - const char* function__ = "validate transformed params"; - (void) function__; // dummy to suppress unused var warning - current_statement_begin__ = 13; - size_t sigmas_k_0_max__ = T; - for (size_t k_0__ = 0; k_0__ < sigmas_k_0_max__; ++k_0__) { - if (stan::math::is_uninitialized(sigmas[k_0__])) { - std::stringstream msg__; - msg__ << "Undefined transformed parameter: sigmas" << "[" << k_0__ << "]"; - stan::lang::rethrow_located(std::runtime_error(std::string("Error initializing variable sigmas: ") + msg__.str()), current_statement_begin__, prog_reader__()); - } - } - // model body - current_statement_begin__ = 21; - lp_accum__.add(student_t_log(mu_k, 3, 0, 3)); - current_statement_begin__ = 22; - lp_accum__.add(student_t_log(sigma_k, 3, 0, 1)); - current_statement_begin__ = 24; - lp_accum__.add(normal_log(x_t, mu_k, sigmas)); - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__()); - // Next line prevents compiler griping about no return - throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); - } - lp_accum__.add(lp__); - return lp_accum__.sum(); - } // log_prob() - template - T_ log_prob(Eigen::Matrix& params_r, - std::ostream* pstream = 0) const { - std::vector vec_params_r; - vec_params_r.reserve(params_r.size()); - for (int i = 0; i < params_r.size(); ++i) - vec_params_r.push_back(params_r(i)); - std::vector vec_params_i; - return log_prob(vec_params_r, vec_params_i, pstream); + } // transform_inits_impl() + + inline void get_param_names(std::vector& names__) const { + + names__.clear(); + names__.emplace_back("mu_k"); + names__.emplace_back("sigma_k"); + names__.emplace_back("sigmas"); + names__.emplace_back("log_lik"); + } // 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{static_cast(T)}); + + dimss__.emplace_back(std::vector{static_cast(T)}); + + } // 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() + "mu_k"); + param_names__.emplace_back(std::string() + "sigma_k"); + if (emit_transformed_parameters__) { + for (int sym1__ = 1; sym1__ <= T; ++sym1__) { + { + param_names__.emplace_back(std::string() + "sigmas" + '.' + std::to_string(sym1__)); + }} } - void get_param_names(std::vector& names__) const { - names__.resize(0); - names__.push_back("mu_k"); - names__.push_back("sigma_k"); - names__.push_back("sigmas"); - names__.push_back("log_lik"); + + if (emit_generated_quantities__) { + for (int sym1__ = 1; sym1__ <= T; ++sym1__) { + { + param_names__.emplace_back(std::string() + "log_lik" + '.' + std::to_string(sym1__)); + }} } - void get_dims(std::vector >& dimss__) const { - dimss__.resize(0); - std::vector dims__; - dims__.resize(0); - dimss__.push_back(dims__); - dims__.resize(0); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(T); - dimss__.push_back(dims__); - dims__.resize(0); - dims__.push_back(T); - dimss__.push_back(dims__); + + } // 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() + "mu_k"); + param_names__.emplace_back(std::string() + "sigma_k"); + if (emit_transformed_parameters__) { + for (int sym1__ = 1; sym1__ <= T; ++sym1__) { + { + param_names__.emplace_back(std::string() + "sigmas" + '.' + std::to_string(sym1__)); + }} } - template - void write_array(RNG& base_rng__, - std::vector& params_r__, - std::vector& params_i__, - std::vector& vars__, - bool include_tparams__ = true, - bool include_gqs__ = true, - std::ostream* pstream__ = 0) const { - typedef double local_scalar_t__; - vars__.resize(0); - stan::io::reader in__(params_r__, params_i__); - static const char* function__ = "model_regime_1_namespace::write_array"; - (void) function__; // dummy to suppress unused var warning - // read-transform, write parameters - double mu_k = in__.scalar_constrain(); - vars__.push_back(mu_k); - double sigma_k = in__.scalar_lb_constrain(0); - vars__.push_back(sigma_k); - double lp__ = 0.0; - (void) lp__; // dummy to suppress unused var warning - stan::math::accumulator lp_accum__; - local_scalar_t__ DUMMY_VAR__(std::numeric_limits::quiet_NaN()); - (void) DUMMY_VAR__; // suppress unused var warning - if (!include_tparams__ && !include_gqs__) return; - try { - // declare and define transformed parameters - current_statement_begin__ = 13; - validate_non_negative_index("sigmas", "T", T); - std::vector sigmas(T, double(0)); - stan::math::initialize(sigmas, DUMMY_VAR__); - stan::math::fill(sigmas, DUMMY_VAR__); - // do transformed parameters statements - current_statement_begin__ = 14; - if (as_bool(logical_eq(est_sigma, 1))) { - current_statement_begin__ = 15; - for (int i = 1; i <= T; ++i) { - current_statement_begin__ = 15; - stan::model::assign(sigmas, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - sigma_k, - "assigning variable sigmas"); - } - } else { - current_statement_begin__ = 17; - for (int i = 1; i <= T; ++i) { - current_statement_begin__ = 17; - stan::model::assign(sigmas, - stan::model::cons_list(stan::model::index_uni(i), stan::model::nil_index_list()), - get_base1(sigma_t, i, "sigma_t", 1), - "assigning variable sigmas"); - } - } - if (!include_gqs__ && !include_tparams__) return; - // validate transformed parameters - const char* function__ = "validate transformed params"; - (void) function__; // dummy to suppress unused var warning - // write transformed parameters - if (include_tparams__) { - size_t sigmas_k_0_max__ = T; - for (size_t k_0__ = 0; k_0__ < sigmas_k_0_max__; ++k_0__) { - vars__.push_back(sigmas[k_0__]); - } - } - if (!include_gqs__) return; - // declare and define generated quantities - current_statement_begin__ = 27; - validate_non_negative_index("log_lik", "T", T); - Eigen::Matrix log_lik(T); - stan::math::initialize(log_lik, DUMMY_VAR__); - stan::math::fill(log_lik, DUMMY_VAR__); - // generated quantities statements - current_statement_begin__ = 29; - for (int n = 1; n <= T; ++n) { - current_statement_begin__ = 30; - stan::model::assign(log_lik, - stan::model::cons_list(stan::model::index_uni(n), stan::model::nil_index_list()), - normal_log(get_base1(x_t, n, "x_t", 1), mu_k, get_base1(sigmas, n, "sigmas", 1)), - "assigning variable log_lik"); - } - // validate, write generated quantities - current_statement_begin__ = 27; - size_t log_lik_j_1_max__ = T; - for (size_t j_1__ = 0; j_1__ < log_lik_j_1_max__; ++j_1__) { - vars__.push_back(log_lik(j_1__)); - } - } catch (const std::exception& e) { - stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__()); - // Next line prevents compiler griping about no return - throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); - } + + if (emit_generated_quantities__) { + for (int sym1__ = 1; sym1__ <= T; ++sym1__) { + { + param_names__.emplace_back(std::string() + "log_lik" + '.' + std::to_string(sym1__)); + }} } + + } // unconstrained_param_names() + + inline std::string get_constrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mu_k\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_k\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigmas\",\"type\":{\"name\":\"array\",\"length\":" << T << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"transformed_parameters\"},{\"name\":\"log_lik\",\"type\":{\"name\":\"vector\",\"length\":" << T << "},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_constrained_sizedtypes() + + inline std::string get_unconstrained_sizedtypes() const { + stringstream s__; + s__ << "[{\"name\":\"mu_k\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_k\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigmas\",\"type\":{\"name\":\"array\",\"length\":" << T << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"transformed_parameters\"},{\"name\":\"log_lik\",\"type\":{\"name\":\"vector\",\"length\":" << T << "},\"block\":\"generated_quantities\"}]"; + return s__.str(); + } // get_unconstrained_sizedtypes() + + + // Begin method overload boilerplate template - void write_array(RNG& base_rng, - Eigen::Matrix& params_r, - Eigen::Matrix& vars, - bool include_tparams = true, - bool include_gqs = true, - std::ostream* pstream = 0) const { - std::vector params_r_vec(params_r.size()); - for (int i = 0; i < params_r.size(); ++i) - params_r_vec[i] = params_r(i); - std::vector vars_vec; - std::vector params_i_vec; - write_array(base_rng, params_r_vec, params_i_vec, vars_vec, include_tparams, include_gqs, pstream); + 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(i) = vars_vec[i]; + for (int i = 0; i < vars.size(); ++i) { + vars.coeffRef(i) = vars_vec[i]; + } } - std::string model_name() const { - return "model_regime_1"; + 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); } - void constrained_param_names(std::vector& param_names__, - bool include_tparams__ = true, - bool include_gqs__ = true) const { - std::stringstream param_name_stream__; - param_name_stream__.str(std::string()); - param_name_stream__ << "mu_k"; - param_names__.push_back(param_name_stream__.str()); - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma_k"; - param_names__.push_back(param_name_stream__.str()); - if (!include_gqs__ && !include_tparams__) return; - if (include_tparams__) { - size_t sigmas_k_0_max__ = T; - for (size_t k_0__ = 0; k_0__ < sigmas_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "sigmas" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - if (!include_gqs__) return; - size_t log_lik_j_1_max__ = T; - for (size_t j_1__ = 0; j_1__ < log_lik_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "log_lik" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } + 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); } - void unconstrained_param_names(std::vector& param_names__, - bool include_tparams__ = true, - bool include_gqs__ = true) const { - std::stringstream param_name_stream__; - param_name_stream__.str(std::string()); - param_name_stream__ << "mu_k"; - param_names__.push_back(param_name_stream__.str()); - param_name_stream__.str(std::string()); - param_name_stream__ << "sigma_k"; - param_names__.push_back(param_name_stream__.str()); - if (!include_gqs__ && !include_tparams__) return; - if (include_tparams__) { - size_t sigmas_k_0_max__ = T; - for (size_t k_0__ = 0; k_0__ < sigmas_k_0_max__; ++k_0__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "sigmas" << '.' << k_0__ + 1; - param_names__.push_back(param_name_stream__.str()); - } - } - if (!include_gqs__) return; - size_t log_lik_j_1_max__ = T; - for (size_t j_1__ = 0; j_1__ < log_lik_j_1_max__; ++j_1__) { - param_name_stream__.str(std::string()); - param_name_stream__ << "log_lik" << '.' << j_1__ + 1; - param_names__.push_back(param_name_stream__.str()); - } + 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); } -}; // model -} // namespace -typedef model_regime_1_namespace::model_regime_1 stan_model; + + 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_regime_1_namespace::model_regime_1; #ifndef USING_R +// Boilerplate stan::model::model_base& new_model( stan::io::var_context& data_context, unsigned int seed, @@ -469,5 +540,8 @@ stan::model::model_base& new_model( stan_model* m = new stan_model(data_context, seed, msg_stream); return *m; } +stan::math::profile_map& get_stan_profile_data() { + return model_regime_1_namespace::profiles__; +} #endif #endif