1 #ifndef STAN_LANG_GENERATOR_HPP 2 #define STAN_LANG_GENERATOR_HPP 4 #include <boost/variant/apply_visitor.hpp> 5 #include <boost/lexical_cast.hpp> 32 const std::string& scalar_t_name,
37 bool include_sampling,
43 bool include_sampling,
47 const std::string
EOL(
"\n");
48 const std::string
EOL2(
"\n\n");
49 const std::string
INDENT(
" ");
55 return !
is_nil(x.range_.low_.expr_) && !
is_nil(x.range_.high_.expr_);
59 return is_nil(x.range_.low_.expr_) && !
is_nil(x.range_.high_.expr_);
63 return !
is_nil(x.range_.low_.expr_) &&
is_nil(x.range_.high_.expr_);
74 for (
size_t k = 0; k < indent; ++k)
82 o <<
"(void) " << name <<
"; // dummy to suppress unused var warning";
90 explicit visgen(std::ostream& o) : o_(o) { }
95 o <<
"namespace " << name <<
"_namespace {" <<
EOL2;
99 o <<
"} // namespace" <<
EOL2;
105 o <<
"// " << msg <<
EOL;
121 for (
size_t i = 0; i < s.size(); ++i) {
122 o << ((s[i] ==
'"') ?
'\'' : s[i]);
128 const std::vector<expression> indexes,
131 static const bool user_facing =
true;
133 if (indexes.size() == 0)
return;
135 for (
size_t i = 0; i < indexes.size(); ++i) {
136 if (i > 0) o <<
", ";
142 template <
bool isLHS>
144 const std::vector<expression> indexes,
153 size_t ai_size = indexes.size();
159 if (ai_size <= (e_num_dims + 1) || base_type !=
MATRIX_T) {
160 for (
size_t n = 0; n < ai_size; ++n)
161 o << (isLHS ?
"get_base1_lhs(" :
"get_base1(");
163 for (
size_t n = 0; n < ai_size; ++n) {
168 o <<
',' << (n+1) <<
')';
171 for (
size_t n = 0; n < ai_size - 1; ++n)
172 o << (isLHS ?
"get_base1_lhs(" :
"get_base1(");
174 for (
size_t n = 0; n < ai_size - 2; ++n) {
179 o <<
',' << (n+1) <<
')';
187 o <<
',' << (ai_size-1U) <<
')';
193 const std::vector<expression>& ,
196 for (
size_t i = 0; i < end; ++i) o <<
"std::vector<";
198 for (
size_t i = 0; i < end; ++i) {
214 void generate_real_var_type(const var_origin& vo, 218 if (is_fun_origin(vo)) { 219 o << "fun_scalar_t__"; 220 } else if (is_var_context && has_var) { 238 void generate_array_var_type(const base_expr_type base_type, 239 const std::string& real_var_type, 250 o << (is_var_context ? 251 "Eigen::Matrix<T__,Eigen::Dynamic,1> " :"vector_d"); 254 o << (is_var_context ? 255 "Eigen::Matrix<T__,1,Eigen::Dynamic> " : "row_vector_d"); 258 o << (is_var_context ? 259 "Eigen::Matrix<T__,Eigen::Dynamic,Eigen::Dynamic> " : "matrix_d"); 264 void generate_idxs(const std::vector<idx>& idxs, 266 void generate_idxs_user(const std::vector<idx>& idxs, 269 struct expression_visgen : public visgen { 270 const bool user_facing_; 271 const bool is_var_context_; 272 explicit expression_visgen(std::ostream& o, bool user_facing, 275 user_facing_(user_facing), 276 is_var_context_(is_var_context) { 278 void operator()(const nil& /*x*/) const { 281 void operator()(const int_literal& n) const { o_ << n.val_; } 282 void operator()(const double_literal& x) const { 283 std::string num_str = boost::lexical_cast<std::string>(x.val_); 285 if (num_str.find_first_of("eE.") == std::string::npos) 286 o_ << ".0"; // trailing 0 to ensure C++ makes it a double 288 void operator()(const array_expr& x) const { 289 std::stringstream ssRealType; 290 generate_real_var_type(x.var_origin_, x.has_var_, is_var_context_, 292 std::stringstream ssArrayType; 293 generate_array_var_type(x.type_.base_type_, ssRealType.str(), 294 is_var_context_, ssArrayType); 295 o_ << "static_cast<"; 296 generate_type(ssArrayType.str(), 301 o_ << "stan::math::array_builder<"; 302 generate_type(ssArrayType.str(), 304 x.type_.num_dims_ - 1, 307 for (size_t i = 0; i < x.args_.size(); ++i) { 309 generate_expression(x.args_[i], user_facing_, is_var_context_, o_); 315 void operator()(const variable& v) const { o_ << v.name_; } 316 void operator()(int n) const { // NOLINT 317 o_ << static_cast<long>(n); // NOLINT 319 void operator()(double x) const { o_ << x; } 320 void operator()(const std::string& x) const { o_ << x; } // identifiers 321 void operator()(const index_op& x) const { 322 std::stringstream expr_o; 323 generate_expression(x.expr_, expr_o); 324 std::string expr_string = expr_o.str(); 325 std::vector<expression> indexes; 326 size_t e_num_dims = x.expr_.expression_type().num_dims_; 327 base_expr_type base_type = x.expr_.expression_type().base_type_; 328 for (size_t i = 0; i < x.dimss_.size(); ++i) 329 for (size_t j = 0; j < x.dimss_[i].size(); ++j) 330 indexes.push_back(x.dimss_[i][j]); // wasteful copy, could use refs 331 generate_indexed_expr<false>(expr_string, indexes, base_type, 332 e_num_dims, user_facing_, o_); 334 void operator()(const index_op_sliced& x) const { 335 if (x.idxs_.size() == 0) { 336 generate_expression(x.expr_, user_facing_, o_); 340 generate_expression(x.expr_, user_facing_, o_); 341 generate_idxs_user(x.idxs_, o_); 344 o_ << "stan::model::rvalue("; 345 generate_expression(x.expr_, o_); 347 generate_idxs(x.idxs_, o_); 350 bool user_facing = true; 351 generate_expression(x.expr_, user_facing, o_); 355 void operator()(const integrate_ode& fx) const { 356 o_ << (fx.integration_function_name_ == "integrate_ode" 357 ? "integrate_ode_rk45" 358 : fx.integration_function_name_) 360 << fx.system_function_name_ 363 generate_expression(fx.y0_, o_); 366 generate_expression(fx.t0_, o_); 369 generate_expression(fx.ts_, o_); 372 generate_expression(fx.theta_, o_); 375 generate_expression(fx.x_, o_); 378 generate_expression(fx.x_int_, o_); 379 o_ << ", pstream__)"; 381 void operator()(const integrate_ode_control& fx) const { 382 o_ << fx.integration_function_name_ 384 << fx.system_function_name_ 387 generate_expression(fx.y0_, o_); 390 generate_expression(fx.t0_, o_); 393 generate_expression(fx.ts_, o_); 396 generate_expression(fx.theta_, o_); 399 generate_expression(fx.x_, o_); 402 generate_expression(fx.x_int_, o_); 403 o_ << ", pstream__, "; 405 generate_expression(fx.rel_tol_, o_); 408 generate_expression(fx.abs_tol_, o_); 411 generate_expression(fx.max_num_steps_, o_); 414 void operator()(const fun& fx) const { 415 // first test if short-circuit op (binary && and || applied to 416 // primitives; overloads are eager, not short-circuiting) 417 if (fx.name_ == "logical_or" || fx.name_ == "logical_and") { 418 o_ << "(primitive_value("; 419 boost::apply_visitor(*this, fx.args_[0].expr_); 420 o_ << ") " << ((fx.name_ == "logical_or") ? "||" : "&&") 421 << " primitive_value("; 422 boost::apply_visitor(*this, fx.args_[1].expr_); 426 o_ << fx.name_ << '(
'; 427 for (size_t i = 0; i < fx.args_.size(); ++i) { 428 if (i > 0) o_ << ',
'; 429 boost::apply_visitor(*this, fx.args_[i].expr_); 431 if (fx.args_.size() > 0 432 && (has_rng_suffix(fx.name_) || has_lp_suffix(fx.name_))) 434 if (has_rng_suffix(fx.name_)) 436 if (has_lp_suffix(fx.name_)) 437 o_ << "lp__, lp_accum__"; 438 if (is_user_defined(fx)) { 439 if (fx.args_.size() > 0 440 || has_rng_suffix(fx.name_) 441 || has_lp_suffix(fx.name_)) 448 void operator()(const conditional_op& expr) const { 449 bool types_prim_match 450 = (expr.type_.is_primitive() && expr.type_.base_type_ == INT_T) 451 || (!expr.has_var_ && expr.type_.is_primitive() 452 && (expr.true_val_.expression_type() 453 == expr.false_val_.expression_type())); 455 std::stringstream ss; 456 generate_real_var_type(expr.var_origin_, expr.has_var_, 457 is_var_context_, ss); 460 boost::apply_visitor(*this, expr.cond_.expr_); 462 if (types_prim_match) { 463 boost::apply_visitor(*this, expr.true_val_.expr_); 465 o_ << "stan::math::promote_scalar<" 468 boost::apply_visitor(*this, expr.true_val_.expr_); 472 if (types_prim_match) { 473 boost::apply_visitor(*this, expr.false_val_.expr_); 475 o_ << "stan::math::promote_scalar<" 478 boost::apply_visitor(*this, expr.false_val_.expr_); 484 void operator()(const binary_op& expr) const { 486 boost::apply_visitor(*this, expr.left.expr_); 487 o_ << ' ' << expr.op << ' '; 488 boost::apply_visitor(*this, expr.right.expr_); 491 void operator()(const unary_op& expr) const { 492 o_ << expr.op << '(
'; 493 boost::apply_visitor(*this, expr.subject.expr_); 496 }; // close struct expression_visgen 498 void generate_expression(const expression& e, 502 expression_visgen vis(o, user_facing, is_var_context); 503 boost::apply_visitor(vis, e.expr_); 507 void generate_expression(const expression& e, 510 static const bool is_var_context = false; // default value 511 expression_visgen vis(o, user_facing, is_var_context); 512 boost::apply_visitor(vis, e.expr_); 515 void generate_expression(const expression& e, std::ostream& o) { 516 static const bool user_facing = false; // default value 517 static const bool is_var_context = false; // default value 518 generate_expression(e, user_facing, is_var_context, o); 521 static void print_string_literal(std::ostream& o, 522 const std::string& s) { 524 for (size_t i = 0; i < s.size(); ++i) { 525 if (s[i] == '"' || s[i] == '\\
' || s[i] == '\
'' )
534 std::stringstream ss;
555 o <<
"using " << type <<
";" <<
EOL;
559 o <<
"using namespace " << ns <<
";" <<
EOL;
576 const std::string& abbrev,
578 o <<
"typedef" <<
" " << type <<
" " << abbrev <<
";" <<
EOL;
592 o <<
"#include" <<
" " <<
"<" << lib_name <<
">" <<
EOL;
601 o <<
"// Code generated by Stan version " 607 o <<
"class " << model_name <<
" : public prob_grad {" <<
EOL;
611 o <<
"}; // model" <<
EOL2;
617 o <<
"static_cast<Eigen::VectorXd::Index>(";
623 const std::string& base_type,
624 const std::vector<expression>& dims,
627 for (
size_t i = 0; i < dims.size(); ++i) {
641 }
else if (!
is_nil(type_arg2.expr_)) {
648 for (
size_t i = 0; i < dims.size(); ++i)
655 const std::string& stage,
656 const std::string& var_name,
657 const std::string& base_type,
658 const std::vector<expression>& dims,
664 <<
"context__.validate_dims(" 665 <<
'"' << stage <<
'"' 666 <<
", " <<
'"' << var_name <<
'"' 667 <<
", " <<
'"' << base_type <<
'"' 668 <<
", context__.to_vec(";
669 for (
size_t i = 0; i < dims.size(); ++i) {
674 if (dims.size() > 0) o <<
",";
696 o_ <<
"stan::math::fill(" << x.
name_ 697 <<
", std::numeric_limits<int>::min());" 702 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
706 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
710 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
714 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
718 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
722 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
726 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
730 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
734 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
738 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
742 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
746 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
756 " avoid seg fault on val access",
758 for (
size_t i = 0; i < vs.size(); ++i) {
759 if (!vs[i].has_def()) {
760 boost::apply_visitor(vis, vs[i].decl_);
772 is_var_context_(is_var_context),
817 template <
typename T>
820 o_ <<
"stan::math::initialize(" << x.name_ <<
", " 823 :
"std::numeric_limits<double>::quiet_NaN()")
893 o <<
"validate_non_negative_index(\"" << var_name <<
"\", ";
901 const std::string& var_name,
902 const std::string& base_type,
903 const std::vector<expression>& dims,
907 for (
size_t i = 0; i < dims.size(); ++i)
916 << var_name <<
" = ";
974 for (
size_t i = 0; i < vs.size(); ++i) {
975 boost::apply_visitor(vis_resizer, vs[i].decl_);
976 boost::apply_visitor(vis_filler, vs[i].decl_);
977 if (vs[i].has_def()) {
978 o <<
INDENT2 <<
"stan::math::assign(" 996 declare_vars_(declare_vars),
997 is_var_context_(is_var_context) {
999 template <
typename D>
1001 const std::string& base_type,
1002 const std::string& read_fun_prefix,
1003 const std::vector<expression>& dim_args)
const {
1004 std::vector<expression> read_args;
1005 std::string read_fun(read_fun_prefix);
1008 read_args.push_back(x.range_.low_);
1009 read_args.push_back(x.range_.high_);
1012 read_args.push_back(x.range_.low_);
1015 read_args.push_back(x.range_.high_);
1017 for (
size_t i = 0; i < dim_args.size(); ++i)
1018 read_args.push_back(dim_args[i]);
1019 generate_initialize_array(base_type, read_fun, read_args,
1024 generate_initialize_array(
"int",
"integer", EMPTY_EXP_VECTOR,
1028 std::vector<expression> read_args;
1029 generate_initialize_array_bounded(x,
1030 is_var_context_ ?
"T__" :
"double",
1031 "scalar", read_args);
1034 std::vector<expression> read_args;
1035 read_args.push_back(x.
M_);
1036 generate_initialize_array_bounded(x,
1039 "<T__,Eigen::Dynamic,1> " 1041 "vector", read_args);
1044 std::vector<expression> read_args;
1045 read_args.push_back(x.
N_);
1046 generate_initialize_array_bounded(x,
1049 "<T__,1,Eigen::Dynamic> " 1051 "row_vector", read_args);
1054 std::vector<expression> read_args;
1055 read_args.push_back(x.
M_);
1056 read_args.push_back(x.
N_);
1057 generate_initialize_array_bounded(x,
1060 "<T__,Eigen::Dynamic,Eigen::Dynamic> " 1062 "matrix", read_args);
1065 std::vector<expression> read_args;
1066 read_args.push_back(x.
K_);
1067 generate_initialize_array(is_var_context_
1069 "<T__,Eigen::Dynamic,1> " 1074 std::vector<expression> read_args;
1075 read_args.push_back(x.
K_);
1076 generate_initialize_array(is_var_context_
1078 "<T__,Eigen::Dynamic,1> " 1083 std::vector<expression> read_args;
1084 read_args.push_back(x.
K_);
1085 generate_initialize_array(is_var_context_
1087 "<T__,Eigen::Dynamic,1> " 1092 std::vector<expression> read_args;
1093 read_args.push_back(x.
K_);
1094 generate_initialize_array(is_var_context_
1096 "<T__,Eigen::Dynamic,1> " 1098 "positive_ordered", read_args,
1102 std::vector<expression> read_args;
1103 read_args.push_back(x.
M_);
1104 read_args.push_back(x.
N_);
1105 generate_initialize_array(is_var_context_
1107 "<T__,Eigen::Dynamic,Eigen::Dynamic> " 1109 "cholesky_factor", read_args,
1113 std::vector<expression> read_args;
1114 read_args.push_back(x.
K_);
1115 generate_initialize_array(is_var_context_
1117 "<T__,Eigen::Dynamic,Eigen::Dynamic> " 1119 "cholesky_corr", read_args, x.
name_, x.
dims_);
1123 std::vector<expression> read_args;
1124 read_args.push_back(x.
K_);
1125 generate_initialize_array(is_var_context_
1127 "<T__,Eigen::Dynamic,Eigen::Dynamic> " 1132 std::vector<expression> read_args;
1133 read_args.push_back(x.
K_);
1134 generate_initialize_array(is_var_context_
1136 "<T__,Eigen::Dynamic,Eigen::Dynamic> " 1143 const std::string& read_type,
1144 const std::vector<expression>& read_args,
1145 const std::string& name,
1146 const std::vector<expression>& dims)
1148 if (declare_vars_) {
1150 for (
size_t i = 0; i < dims.size(); ++i)
o_ <<
"vector<";
1152 for (
size_t i = 0; i < dims.size(); ++i)
o_ <<
"> ";
1153 if (dims.size() == 0)
o_ <<
" ";
1154 o_ << name <<
";" <<
EOL;
1157 if (dims.size() == 0) {
1163 o_ << name <<
" = in__." << read_type <<
"_constrain(";
1164 for (
size_t j = 0; j < read_args.size(); ++j) {
1165 if (j > 0)
o_ <<
",";
1168 if (read_args.size() > 0)
1177 o_ << name <<
" = in__." << read_type <<
"_constrain(";
1178 for (
size_t j = 0; j < read_args.size(); ++j) {
1179 if (j > 0)
o_ <<
",";
1186 std::string name_dims(name);
1187 for (
size_t i = 0; i < dims.size(); ++i) {
1189 o_ <<
"size_t dim_" << name <<
"_" << i <<
"__ = ";
1193 if (i < dims.size() - 1) {
1195 o_ << name_dims <<
".resize(dim" <<
"_" 1196 << name <<
"_" << i <<
"__);" 1198 name_dims.append(
"[k_").append(
to_string(i)).append(
"__]");
1202 if (i == dims.size() - 1) {
1203 o_ << name_dims <<
".reserve(dim_" << name
1204 <<
"_" << i <<
"__);" <<
EOL;
1208 o_ <<
"for (size_t k_" << i <<
"__ = 0;" 1209 <<
" k_" << i <<
"__ < dim_" << name <<
"_" << i <<
"__;" 1210 <<
" ++k_" << i <<
"__) {" <<
EOL;
1213 if (i == dims.size() - 1) {
1215 o_ <<
"if (jacobian__)" <<
EOL;
1219 o_ << name_dims <<
".push_back(in__." 1220 << read_type <<
"_constrain(";
1221 for (
size_t j = 0; j < read_args.size(); ++j) {
1222 if (j > 0)
o_ <<
",";
1225 if (read_args.size() > 0)
1231 o_ <<
"else" <<
EOL;
1235 o_ << name_dims <<
".push_back(in__." 1236 << read_type <<
"_constrain(";
1237 for (
size_t j = 0; j < read_args.size(); ++j) {
1238 if (j > 0)
o_ <<
",";
1245 for (
size_t i = dims.size(); i > 0; --i) {
1256 bool is_var_context,
1260 <<
"stan::io::reader<" 1261 << (is_var_context ?
"T__" :
"double")
1262 <<
"> in__(params_r__,params_i__);" <<
EOL2;
1264 for (
size_t i = 0; i < vs.size(); ++i) {
1265 boost::apply_visitor(vis_init, vs[i].decl_);
1271 o <<
"public:" <<
EOL;
1275 o <<
"private:" <<
EOL;
1287 for (
size_t i = 0; i < dims.size(); ++i) {
1289 o_ <<
"for (int k" << i <<
"__ = 0;" 1290 <<
" k" << i <<
"__ < ";
1293 o_ <<
" ++k" << i <<
"__) {" <<
EOL;
1297 for (
size_t i = 0; i < dims_size; ++i) {
1303 size_t dims_size)
const {
1305 for (
size_t i = 0; i < dims_size; ++i)
1306 o_ <<
"[k" << i <<
"__]";
1309 template <
typename T>
1311 if (!(x.range_.has_low() || x.range_.has_high())) {
1314 generate_begin_for_dims(x.dims_);
1315 if (x.range_.has_low()) {
1317 o_ <<
"check_greater_or_equal(function__,";
1319 generate_loop_var(x.name_, x.dims_.size());
1321 generate_loop_var(x.name_, x.dims_.size());
1326 if (x.range_.has_high()) {
1328 o_ <<
"check_less_or_equal(function__,";
1330 generate_loop_var(x.name_, x.dims_.size());
1332 generate_loop_var(x.name_, x.dims_.size());
1337 generate_end_for_dims(x.dims_.size());
1354 template <
typename T>
1356 const std::string& type_name)
const {
1357 generate_begin_for_dims(x.dims_);
1359 o_ <<
"stan::math::check_" << type_name <<
"(function__,";
1361 generate_loop_var(x.name_, x.dims_.size());
1363 generate_loop_var(x.name_, x.dims_.size());
1366 generate_end_for_dims(x.dims_.size());
1369 nonbasic_validate(x,
"unit_vector");
1372 nonbasic_validate(x,
"simplex");
1375 nonbasic_validate(x,
"ordered");
1378 nonbasic_validate(x,
"positive_ordered");
1381 nonbasic_validate(x,
"cholesky_factor");
1384 nonbasic_validate(x,
"cholesky_factor_corr");
1387 nonbasic_validate(x,
"cov_matrix");
1390 nonbasic_validate(x,
"corr_matrix");
1399 boost::apply_visitor(vis, decl.
decl_);
1405 for (
size_t i = 0; i < decls.size(); ++i)
1419 declare_array(
"int", x.
name_, x.
dims_.size());
1422 declare_array(
"double", x.
name_, x.
dims_.size());
1425 declare_array((
"vector_d"), x.
name_, x.
dims_.size());
1428 declare_array((
"vector_d"), x.
name_, x.
dims_.size());
1431 declare_array((
"vector_d"), x.
name_, x.
dims_.size());
1434 declare_array((
"vector_d"), x.
name_, x.
dims_.size());
1437 declare_array((
"matrix_d"), x.
name_, x.
dims_.size());
1440 declare_array((
"matrix_d"), x.
name_, x.
dims_.size());
1443 declare_array((
"matrix_d"), x.
name_, x.
dims_.size());
1446 declare_array((
"matrix_d"), x.
name_, x.
dims_.size());
1449 declare_array((
"vector_d"), x.
name_, x.
dims_.size());
1452 declare_array((
"row_vector_d"), x.
name_, x.
dims_.size());
1455 declare_array((
"matrix_d"), x.
name_, x.
dims_.size());
1458 const std::string& name,
1459 size_t size)
const {
1460 for (
int i = 0; i < indents_; ++i)
1462 for (
size_t i = 0; i < size; ++i) {
1469 for (
size_t i = 1; i < size; ++i) {
1472 o_ <<
" " << name <<
";" <<
EOL;
1480 for (
size_t i = 0; i < vs.size(); ++i)
1481 boost::apply_visitor(vis, vs[i].decl_);
1490 bool is_var_context,
1495 is_var_context_(is_var_context),
1496 is_fun_return_(is_fun_return) {
1500 std::vector<expression> ctor_args;
1501 declare_array(
"int", ctor_args, x.
name_, x.
dims_);
1504 std::vector<expression> ctor_args;
1505 declare_array(is_fun_return_
1507 : (is_var_context_ ?
"T__" :
"double"),
1511 std::vector<expression> ctor_args;
1512 ctor_args.push_back(x.
M_);
1513 declare_array(is_fun_return_
1514 ?
"Eigen::Matrix<fun_scalar_t__,Eigen::Dynamic,1> " 1516 ?
"Eigen::Matrix<T__,Eigen::Dynamic,1> " :
"vector_d"),
1520 std::vector<expression> ctor_args;
1521 ctor_args.push_back(x.
N_);
1522 declare_array(is_fun_return_
1523 ?
"Eigen::Matrix<fun_scalar_t__,1,Eigen::Dynamic> " 1525 ?
"Eigen::Matrix<T__,1,Eigen::Dynamic> " 1530 std::vector<expression> ctor_args;
1531 ctor_args.push_back(x.
M_);
1532 ctor_args.push_back(x.
N_);
1533 declare_array(is_fun_return_
1534 ?
"Eigen::Matrix<fun_scalar_t__," 1535 "Eigen::Dynamic,Eigen::Dynamic> " 1537 ?
"Eigen::Matrix<T__,Eigen::Dynamic,Eigen::Dynamic> " 1542 std::vector<expression> ctor_args;
1543 ctor_args.push_back(x.
K_);
1544 declare_array(is_fun_return_
1545 ?
"Eigen::Matrix<fun_scalar_t__,Eigen::Dynamic,1> " 1547 ?
"Eigen::Matrix<T__,Eigen::Dynamic,1> " :
"vector_d"),
1551 std::vector<expression> ctor_args;
1552 ctor_args.push_back(x.
K_);
1553 declare_array(is_fun_return_
1554 ?
"Eigen::Matrix<fun_scalar_t__,Eigen::Dynamic,1> " 1556 ?
"Eigen::Matrix<T__,Eigen::Dynamic,1> " :
"vector_d"),
1560 std::vector<expression> ctor_args;
1561 ctor_args.push_back(x.
K_);
1562 declare_array(is_fun_return_
1563 ?
"Eigen::Matrix<fun_scalar_t__,Eigen::Dynamic,1> " 1565 ?
"Eigen::Matrix<T__,Eigen::Dynamic,1> " :
"vector_d"),
1569 std::vector<expression> ctor_args;
1570 ctor_args.push_back(x.
K_);
1571 declare_array(is_fun_return_
1572 ?
"Eigen::Matrix<fun_scalar_t__,Eigen::Dynamic,1> " 1574 ?
"Eigen::Matrix<T__,Eigen::Dynamic,1> " :
"vector_d"),
1578 std::vector<expression> ctor_args;
1579 ctor_args.push_back(x.
M_);
1580 ctor_args.push_back(x.
N_);
1581 declare_array(is_fun_return_
1582 ?
"Eigen::Matrix<fun_scalar_t__," 1583 "Eigen::Dynamic,Eigen::Dynamic> " 1585 ?
"Eigen::Matrix<T__,Eigen::Dynamic,Eigen::Dynamic> " 1590 std::vector<expression> ctor_args;
1591 ctor_args.push_back(x.
K_);
1592 ctor_args.push_back(x.
K_);
1593 declare_array(is_var_context_
1594 ?
"Eigen::Matrix<T__,Eigen::Dynamic,Eigen::Dynamic> " 1599 std::vector<expression> ctor_args;
1600 ctor_args.push_back(x.
K_);
1601 ctor_args.push_back(x.
K_);
1602 declare_array(is_fun_return_
1603 ?
"Eigen::Matrix<fun_scalar_t__," 1604 "Eigen::Dynamic,Eigen::Dynamic> " 1606 ?
"Eigen::Matrix<T__,Eigen::Dynamic,Eigen::Dynamic> " 1611 std::vector<expression> ctor_args;
1612 ctor_args.push_back(x.
K_);
1613 ctor_args.push_back(x.
K_);
1614 declare_array(is_fun_return_
1615 ?
"Eigen::Matrix<fun_scalar_t__," 1616 "Eigen::Dynamic,Eigen::Dynamic> " 1618 ?
"Eigen::Matrix<T__,Eigen::Dynamic,Eigen::Dynamic> " 1623 size_t num_dims)
const {
1624 for (
size_t i = 0; i < num_dims; ++i)
1627 for (
size_t i = 0; i < num_dims; ++i) {
1628 if (i > 0)
o_ <<
" ";
1634 o_ <<
"(void) " << name <<
"; // dummy to suppress unused var warning";
1641 const std::vector<expression>& ctor_args,
1642 const std::vector<expression>& dims,
1644 if (dim < dims.size()) {
1647 if ((dim + 1 < dims.size()) || ctor_args.size() > 0) {
1650 generate_init_args(type, ctor_args, dims, dim + 1);
1652 }
else if (type ==
"var") {
1653 o_ <<
", DUMMY_VAR__";
1654 }
else if (type ==
"int") {
1656 }
else if (type ==
"double") {
1663 if (ctor_args.size() == 0) {
1664 if (type ==
"int") {
1666 }
else if (type ==
"double") {
1668 }
else if (type ==
"var") {
1669 o_ <<
"(DUMMY_VAR__)";
1673 }
else if (ctor_args.size() == 1) {
1677 }
else if (ctor_args.size() > 1) {
1687 const std::vector<expression>& ctor_args,
1688 const std::string& name,
1689 const std::vector<expression>& dims,
1695 generate_init_args(type, ctor_args, dims, 0);
1697 if (dims.size() == 0) {
1702 if (type ==
"Eigen::Matrix<T__, Eigen::Dynamic, Eigen::Dynamic> " 1703 || type ==
"Eigen::Matrix<T__, 1, Eigen::Dynamic> " 1704 || type ==
"Eigen::Matrix<T__, Eigen::Dynamic, 1> ") {
1706 o_ <<
"stan::math::fill(" << name <<
", DUMMY_VAR__);" <<
EOL;
1714 bool is_var_context,
1715 bool is_fun_return) {
1719 for (
size_t i = 0; i < vs.size(); ++i) {
1720 boost::apply_visitor(vis_decl, vs[i].decl_);
1721 boost::apply_visitor(vis_init, vs[i].decl_);
1722 boost::apply_visitor(vis_filler, vs[i].decl_);
1723 if (vs[i].has_def()) {
1725 o <<
"stan::math::assign(" 1739 bool is_var_context,
1740 bool is_fun_return) {
1742 for (
size_t i = 0; i < vs.size(); ++i) {
1743 boost::apply_visitor(vis, vs[i].decl_);
1750 bool is_var_context,
1754 for (
size_t i = 0; i < vs.size(); ++i) {
1755 if (vs[i].has_def()) {
1757 o <<
"stan::math::assign(" 1775 std::vector<expression> dims(x.
dims_);
1776 validate_array(x.
name_, dims, 0);
1779 std::vector<expression> dims(x.
dims_);
1780 validate_array(x.
name_, dims, 0);
1783 std::vector<expression> dims(x.
dims_);
1784 dims.push_back(x.
M_);
1785 validate_array(x.
name_, dims, 1);
1788 std::vector<expression> dims(x.
dims_);
1789 dims.push_back(x.
K_);
1790 validate_array(x.
name_, dims, 1);
1793 std::vector<expression> dims(x.
dims_);
1794 dims.push_back(x.
K_);
1795 validate_array(x.
name_, dims, 1);
1798 std::vector<expression> dims(x.
dims_);
1799 dims.push_back(x.
K_);
1800 validate_array(x.
name_, dims, 1);
1803 std::vector<expression> dims(x.
dims_);
1804 dims.push_back(x.
K_);
1805 validate_array(x.
name_, dims, 1);
1808 std::vector<expression> dims(x.
dims_);
1809 dims.push_back(x.
N_);
1810 validate_array(x.
name_, dims, 1);
1813 std::vector<expression> dims(x.
dims_);
1814 dims.push_back(x.
M_);
1815 dims.push_back(x.
N_);
1816 validate_array(x.
name_, dims, 2);
1819 std::vector<expression> dims(x.
dims_);
1820 dims.push_back(x.
M_);
1821 dims.push_back(x.
N_);
1822 validate_array(x.
name_, dims, 2);
1825 std::vector<expression> dims(x.
dims_);
1826 dims.push_back(x.
K_);
1827 dims.push_back(x.
K_);
1828 validate_array(x.
name_, dims, 2);
1831 std::vector<expression> dims(x.
dims_);
1832 dims.push_back(x.
K_);
1833 dims.push_back(x.
K_);
1834 validate_array(x.
name_, dims, 2);
1837 std::vector<expression> dims(x.
dims_);
1838 dims.push_back(x.
K_);
1839 dims.push_back(x.
K_);
1840 validate_array(x.
name_, dims, 2);
1843 const std::vector<expression>& dims,
1844 size_t matrix_dims)
const {
1845 size_t non_matrix_dims = dims.size() - matrix_dims;
1847 for (
size_t k = 0; k < dims.size(); ++k) {
1849 o_ <<
"for (int i" << k <<
"__ = 0; i" << k <<
"__ < ";
1851 o_ <<
"; ++i" << k <<
"__) {" <<
EOL;
1855 o_ <<
"if (stan::math::is_uninitialized(" << name;
1856 for (
size_t k = 0; k < non_matrix_dims; ++k)
1857 o_ <<
"[i" << k <<
"__]";
1858 if (matrix_dims > 0) {
1859 o_ <<
"(i" << non_matrix_dims <<
"__";
1860 if (matrix_dims > 1)
1861 o_ <<
",i" << (non_matrix_dims + 1) <<
"__";
1864 o_ <<
")) {" <<
EOL;
1866 o_ <<
"std::stringstream msg__;" <<
EOL;
1868 o_ <<
"msg__ << \"Undefined transformed parameter: " 1870 for (
size_t k = 0; k < dims.size(); ++k) {
1872 o_ <<
" << i" << k <<
"__";
1877 o_ <<
"throw std::runtime_error(msg__.str());" <<
EOL;
1881 for (
size_t k = 0; k < dims.size(); ++k) {
1893 for (
size_t i = 0; i < vs.size(); ++i)
1894 boost::apply_visitor(vis, vs[i].decl_);
1901 o_ <<
"stan::model::index_uni(";
1906 o_ <<
"stan::model::index_multi(";
1911 o_ <<
"stan::model::index_omni()";
1914 o_ <<
"stan::model::index_min(";
1919 o_ <<
"stan::model::index_max(";
1924 o_ <<
"stan::model::index_min_max(";
1934 boost::apply_visitor(vis, i.
idx_);
1939 if (pos == idxs.size()) {
1940 o <<
"stan::model::nil_index_list()";
1942 o <<
"stan::model::cons_list(";
1983 boost::apply_visitor(vis, i.
idx_);
1987 if (idxs.size() == 0)
1990 for (
size_t i = 0; i < idxs.size(); ++i) {
2004 bool include_sampling,
2005 bool is_var_context,
2010 include_sampling_(include_sampling),
2011 is_var_context_(is_var_context),
2012 is_fun_return_(is_fun_return) {
2018 o_ <<
"stan::math::assign(";
2031 o_ <<
"stan::model::assign(";
2045 o_ <<
"stan::model::deep_copy(";
2056 <<
"assigning variable " 2068 if (!include_sampling_)
return;
2071 o_ <<
"lp_accum__.add(" << prob_fun <<
"<propto__>(";
2073 for (
size_t i = 0; i < x.
dist_.
args_.size(); ++i) {
2079 if (is_user_defined)
2080 o_ <<
", pstream__";
2090 o_ <<
") lp_accum__.add(-std::numeric_limits<double>::infinity());" 2100 o_ <<
") lp_accum__.add(-std::numeric_limits<double>::infinity());" 2105 generate_truncation(x, is_user_defined, prob_fun);
2109 const std::string& prob_fun)
const {
2110 std::stringstream sso_lp;
2115 sso_lp <<
"log_diff_exp(";
2118 for (
size_t i = 0; i < x.
dist_.
args_.size(); ++i) {
2122 if (is_user_defined)
2123 sso_lp <<
", pstream__";
2126 for (
size_t i = 0; i < x.
dist_.
args_.size(); ++i) {
2130 if (is_user_defined)
2131 sso_lp <<
", pstream__";
2138 for (
size_t i = 0; i < x.
dist_.
args_.size(); ++i) {
2142 if (is_user_defined)
2143 sso_lp <<
", pstream__";
2150 for (
size_t i = 0; i < x.
dist_.
args_.size(); ++i) {
2154 if (is_user_defined)
2155 sso_lp <<
", pstream__";
2159 o_ <<
"else lp_accum__.add(-";
2162 o_ <<
"log_sum_exp(" << sso_lp.str() <<
", ";
2164 o_ << prob_fun <<
"(";
2166 for (
size_t i = 0; i < x.
dist_.
args_.size(); ++i) {
2170 if (is_user_defined)
o_ <<
", pstream__";
2176 o_ <<
");" << std::endl;
2181 o_ <<
"lp_accum__.add(";
2188 size_t indent = has_local_vars ? (indent_ + 1) : indent_;
2189 if (has_local_vars) {
2193 is_var_context_, is_fun_return_);
2198 is_var_context_, is_fun_return_);
2199 if (has_local_vars) {
2207 o_ <<
"if (pstream__) {" <<
EOL;
2208 for (
size_t i = 0; i < ps.
printables_.size(); ++i) {
2210 o_ <<
"stan_print(pstream__,";
2215 o_ <<
"*pstream__ << std::endl;" <<
EOL;
2221 o_ <<
"std::stringstream errmsg_stream__;" <<
EOL;
2222 for (
size_t i = 0; i < ps.
printables_.size(); ++i) {
2224 o_ <<
"errmsg_stream__ << ";
2229 o_ <<
"throw std::domain_error(errmsg_stream__.str());" <<
EOL;
2236 o_ <<
"stan::math::promote_scalar<fun_return_scalar_t__>(";
2250 is_var_context_, is_fun_return_);
2256 o_ <<
"while (as_bool(";
2258 o_ <<
")) {" <<
EOL;
2260 is_var_context_, is_fun_return_);
2269 for (
size_t i = 0; i < x.
conditions_.size(); ++i) {
2274 o_ <<
"if (as_bool(";
2276 o_ <<
")) {" <<
EOL;
2278 is_var_context_, is_fun_return_);
2283 o_ <<
" else {" <<
EOL;
2285 o_, include_sampling_,
2286 is_var_context_, is_fun_return_);
2322 bool include_sampling,
2323 bool is_var_context,
2324 bool is_fun_return) {
2326 if (boost::apply_visitor(vis_is_numbered, s.
statement_)) {
2328 o <<
"current_statement_begin__ = " << s.
begin_line_ <<
";" 2340 bool include_sampling,
2341 bool is_var_context,
2342 bool is_fun_return) {
2345 for (
size_t i = 0; i < ss.size(); ++i)
2346 boost::apply_visitor(vis, ss[i].statement_);
2359 o <<
"} catch (const std::exception& e) {" 2362 o <<
"stan::lang::rethrow_located(e,current_statement_begin__);" 2367 o <<
"throw std::runtime_error" 2368 <<
"(\"*** IF YOU SEE THIS, PLEASE REPORT A BUG ***\");" 2378 bool include_sampling,
2379 bool is_var_context,
2380 bool is_fun_return) {
2383 is_var_context, is_fun_return);
2390 bool include_sampling,
2391 bool is_var_context,
2392 bool is_fun_return) {
2394 for (
size_t i = 0; i < ss.size(); ++i)
2396 is_var_context, is_fun_return);
2405 o <<
INDENT <<
"template <bool propto__, bool jacobian__, typename T__>" 2407 o <<
INDENT <<
"T__ log_prob(vector<T__>& params_r__," 2409 o <<
INDENT <<
" vector<int>& params_i__," 2411 o <<
INDENT <<
" std::ostream* pstream__ = 0) const {" 2416 <<
"T__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());" 2418 o <<
INDENT2 <<
"(void) DUMMY_VAR__; // suppress unused var warning" 2421 o <<
INDENT2 <<
"T__ lp__(0.0);" 2423 o <<
INDENT2 <<
"stan::math::accumulator<T__> lp_accum__;" 2426 bool is_var_context =
true;
2427 bool is_fun_return =
false;
2438 bool include_sampling =
true;
2440 include_sampling, is_var_context,
2446 <<
"const char* function__ = \"validate transformed params\";" 2449 <<
"(void) function__; // dummy to suppress unused var warning" 2459 is_var_context, is_fun_return);
2463 o <<
INDENT2 <<
"lp_accum__.add(lp__);" <<
EOL;
2464 o <<
INDENT2 <<
"return lp_accum__.sum();" <<
EOL2;
2468 <<
"template <bool propto, bool jacobian, typename T_>" <<
EOL;
2470 <<
"T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r," <<
EOL;
2471 o <<
INDENT <<
" std::ostream* pstream = 0) const {" <<
EOL;
2472 o <<
INDENT <<
" std::vector<T_> vec_params_r;" <<
EOL;
2473 o <<
INDENT <<
" vec_params_r.reserve(params_r.size());" <<
EOL;
2474 o <<
INDENT <<
" for (int i = 0; i < params_r.size(); ++i)" <<
EOL;
2475 o <<
INDENT <<
" vec_params_r.push_back(params_r(i));" <<
EOL;
2476 o <<
INDENT <<
" std::vector<int> vec_params_i;" <<
EOL;
2478 <<
" return log_prob<propto,jacobian,T_>(vec_params_r, " 2479 <<
"vec_params_i, pstream);" <<
EOL;
2490 "data initialization")) {
2494 std::vector<expression> dims = x.
dims_;
2495 var_size_validator_(x);
2498 <<
"vals_i__ = context__.vals_i(\"" << x.
name_ <<
"\");" <<
EOL;
2500 size_t indentation = 1;
2501 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2502 size_t dim = dims.size() - dim_up - 1U;
2505 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2509 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" 2510 << dim <<
"__ < " << x.
name_ <<
"_limit_" << dim
2511 <<
"__; ++i_" << dim <<
"__) {" <<
EOL;
2515 for (
size_t dim = 0; dim < dims.size(); ++dim)
2516 o_ <<
"[i_" << dim <<
"__]";
2517 o_ <<
" = vals_i__[pos__++];" <<
EOL;
2518 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2525 std::vector<expression> dims = x.
dims_;
2526 var_size_validator_(x);
2529 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");" <<
EOL;
2531 size_t indentation = 1;
2532 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2533 size_t dim = dims.size() - dim_up - 1U;
2536 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2540 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < " 2541 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {" 2546 for (
size_t dim = 0; dim < dims.size(); ++dim)
2547 o_ <<
"[i_" << dim <<
"__]";
2548 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2549 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2556 std::vector<expression> dims = x.
dims_;
2558 var_size_validator_(x);
2560 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");" <<
EOL;
2565 o_ <<
INDENT2 <<
"for (size_t " <<
"i_vec__ = 0; " <<
"i_vec__ < " 2566 << x.
name_ <<
"_i_vec_lim__; ++i_vec__) {" <<
EOL;
2567 size_t indentation = 2;
2568 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2569 size_t dim = dims.size() - dim_up - 1U;
2572 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2576 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < " 2577 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {" 2582 for (
size_t dim = 0; dim < dims.size(); ++dim)
2583 o_ <<
"[i_" << dim <<
"__]";
2585 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2586 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2594 std::vector<expression> dims = x.
dims_;
2595 var_size_validator_(x);
2598 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");" <<
EOL;
2603 o_ <<
INDENT2 <<
"for (size_t " <<
"i_vec__ = 0; " <<
"i_vec__ < " 2604 << x.
name_ <<
"_i_vec_lim__; ++i_vec__) {" <<
EOL;
2605 size_t indentation = 2;
2606 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2607 size_t dim = dims.size() - dim_up - 1U;
2610 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2614 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < " 2615 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {" 2620 for (
size_t dim = 0; dim < dims.size(); ++dim)
2621 o_ <<
"[i_" << dim <<
"__]";
2623 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2624 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2632 std::vector<expression> dims = x.
dims_;
2633 var_size_validator_(x);
2636 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");" <<
EOL;
2641 o_ <<
INDENT2 <<
"for (size_t " <<
"i_vec__ = 0; " <<
"i_vec__ < " 2642 << x.
name_ <<
"_i_vec_lim__; ++i_vec__) {" <<
EOL;
2643 size_t indentation = 2;
2644 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2645 size_t dim = dims.size() - dim_up - 1U;
2648 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2652 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < " 2653 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {" 2658 for (
size_t dim = 0; dim < dims.size(); ++dim)
2659 o_ <<
"[i_" << dim <<
"__]";
2661 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2662 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2670 std::vector<expression> dims = x.
dims_;
2671 var_size_validator_(x);
2674 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");" <<
EOL;
2679 o_ <<
INDENT2 <<
"for (size_t " <<
"i_vec__ = 0; " <<
"i_vec__ < " 2680 << x.
name_ <<
"_i_vec_lim__; ++i_vec__) {" <<
EOL;
2681 size_t indentation = 2;
2682 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2683 size_t dim = dims.size() - dim_up - 1U;
2686 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2690 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < " 2691 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {" 2696 for (
size_t dim = 0; dim < dims.size(); ++dim)
2697 o_ <<
"[i_" << dim <<
"__]";
2699 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2700 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2708 std::vector<expression> dims = x.
dims_;
2709 var_size_validator_(x);
2712 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");" <<
EOL;
2717 o_ <<
INDENT2 <<
"for (size_t " <<
"i_vec__ = 0; " <<
"i_vec__ < " 2718 << x.
name_ <<
"_i_vec_lim__; ++i_vec__) {" <<
EOL;
2719 size_t indentation = 2;
2720 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2721 size_t dim = dims.size() - dim_up - 1U;
2724 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2728 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < " 2729 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {" 2734 for (
size_t dim = 0; dim < dims.size(); ++dim)
2735 o_ <<
"[i_" << dim <<
"__]";
2737 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2738 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2746 std::vector<expression> dims = x.
dims_;
2747 var_size_validator_(x);
2750 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");" <<
EOL;
2755 o_ <<
INDENT2 <<
"for (size_t " <<
"i_vec__ = 0; " <<
"i_vec__ < " 2756 << x.
name_ <<
"_i_vec_lim__; ++i_vec__) {" <<
EOL;
2757 size_t indentation = 2;
2758 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2759 size_t dim = dims.size() - dim_up - 1U;
2762 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2766 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < " 2767 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {" 2772 for (
size_t dim = 0; dim < dims.size(); ++dim)
2773 o_ <<
"[i_" << dim <<
"__]";
2775 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2776 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2784 std::vector<expression> dims = x.
dims_;
2785 var_size_validator_(x);
2787 o_ <<
INDENT2 <<
"vals_r__ = context__.vals_r(\"" 2796 o_ <<
INDENT2 <<
"for (size_t " <<
"n_mat__ = 0; " <<
"n_mat__ < " 2797 << x.
name_ <<
"_n_mat_lim__; ++n_mat__) {" <<
EOL;
2798 o_ <<
INDENT3 <<
"for (size_t " <<
"m_mat__ = 0; " <<
"m_mat__ < " 2799 << x.
name_ <<
"_m_mat_lim__; ++m_mat__) {" <<
EOL;
2800 size_t indentation = 3;
2801 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2802 size_t dim = dims.size() - dim_up - 1U;
2805 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2809 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < " 2810 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {" 2815 for (
size_t dim = 0; dim < dims.size(); ++dim)
2816 o_ <<
"[i_" << dim <<
"__]";
2817 o_ <<
"(m_mat__,n_mat__)";
2818 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2819 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2829 std::vector<expression> dims = x.
dims_;
2830 var_size_validator_(x);
2833 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");" <<
EOL;
2839 <<
"for (size_t " <<
"n_mat__ = 0; " <<
"n_mat__ < " << x.
name_ 2840 <<
"_k_mat_lim__; ++n_mat__) {" <<
EOL;
2842 <<
"for (size_t " <<
"m_mat__ = 0; " <<
"m_mat__ < " << x.
name_ 2843 <<
"_k_mat_lim__; ++m_mat__) {" <<
EOL;
2844 size_t indentation = 3;
2845 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2846 size_t dim = dims.size() - dim_up - 1U;
2849 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2853 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < " 2854 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {" 2859 for (
size_t dim = 0; dim < dims.size(); ++dim)
2860 o_ <<
"[i_" << dim <<
"__]";
2861 o_ <<
"(m_mat__,n_mat__)";
2862 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2863 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2872 std::vector<expression> dims = x.
dims_;
2873 var_size_validator_(x);
2875 o_ <<
INDENT2 <<
"vals_r__ = context__.vals_r(\"" 2887 o_ <<
INDENT2 <<
"for (size_t " <<
"n_mat__ = 0; " <<
"n_mat__ < " 2888 << x.
name_ <<
"_n_mat_lim__; ++n_mat__) {" <<
EOL;
2889 o_ <<
INDENT3 <<
"for (size_t " <<
"m_mat__ = 0; " <<
"m_mat__ < " 2890 << x.
name_ <<
"_m_mat_lim__; ++m_mat__) {" <<
EOL;
2892 size_t indentation = 3;
2893 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2894 size_t dim = dims.size() - dim_up - 1U;
2897 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2901 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < " 2902 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {" 2907 for (
size_t dim = 0; dim < dims.size(); ++dim)
2908 o_ <<
"[i_" << dim <<
"__]";
2909 o_ <<
"(m_mat__,n_mat__)";
2910 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2911 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2921 std::vector<expression> dims = x.
dims_;
2922 var_size_validator_(x);
2924 o_ <<
INDENT2 <<
"vals_r__ = context__.vals_r(\"" 2936 o_ <<
INDENT2 <<
"for (size_t " <<
"n_mat__ = 0; " <<
"n_mat__ < " 2937 << x.
name_ <<
"_n_mat_lim__; ++n_mat__) {" <<
EOL;
2938 o_ <<
INDENT3 <<
"for (size_t " <<
"m_mat__ = 0; " <<
"m_mat__ < " 2939 << x.
name_ <<
"_m_mat_lim__; ++m_mat__) {" <<
EOL;
2941 size_t indentation = 3;
2942 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2943 size_t dim = dims.size() - dim_up - 1U;
2946 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2950 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < " 2951 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {" 2956 for (
size_t dim = 0; dim < dims.size(); ++dim)
2957 o_ <<
"[i_" << dim <<
"__]";
2958 o_ <<
"(m_mat__,n_mat__)";
2959 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2960 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2969 std::vector<expression> dims = x.
dims_;
2970 var_size_validator_(x);
2972 o_ <<
INDENT2 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");" 2978 o_ <<
INDENT2 <<
"for (size_t " <<
"n_mat__ = 0; " <<
"n_mat__ < " 2979 << x.
name_ <<
"_k_mat_lim__; ++n_mat__) {" <<
EOL;
2980 o_ <<
INDENT3 <<
"for (size_t " <<
"m_mat__ = 0; " <<
"m_mat__ < " 2981 << x.
name_ <<
"_k_mat_lim__; ++m_mat__) {" <<
EOL;
2982 size_t indentation = 3;
2983 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2984 size_t dim = dims.size() - dim_up - 1U;
2987 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2991 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < " 2992 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {" 2997 for (
size_t dim = 0; dim < dims.size(); ++dim)
2998 o_ <<
"[i_" << dim <<
"__]";
2999 o_ <<
"(m_mat__,n_mat__)";
3000 o_ <<
" = vals_r__[pos__++];" <<
EOL;
3001 for (
size_t dim = 0; dim < dims.size(); ++dim) {
3011 const std::string& var_name,
3013 o << indent <<
"(void) " 3015 <<
" // dummy call to supress warning" 3022 for (
size_t i = 0; i < vs.size(); ++i)
3023 boost::apply_visitor(vis, vs[i].decl_);
3029 <<
INDENT <<
"~" << model_name <<
"() { }" 3040 generate_increment_i(x.
dims_);
3042 for (
size_t i = 0; i < x.
dims_.size(); ++i) {
3044 o_ <<
"for (size_t i_" << i <<
"__ = 0; ";
3045 o_ <<
"i_" << i <<
"__ < ";
3047 o_ <<
"; ++i_" << i <<
"__) {" <<
EOL;
3051 o_ <<
"param_ranges_i__.push_back(std::pair<int, int>(";
3057 for (
size_t i = 0; i < x.
dims_.size(); ++i) {
3063 generate_increment(x.
dims_);
3066 generate_increment(x.
M_, x.
dims_);
3069 generate_increment(x.
N_, x.
dims_);
3072 generate_increment(x.
M_, x.
N_, x.
dims_);
3078 for (
size_t i = 0; i < x.
dims_.size(); ++i) {
3089 for (
size_t i = 0; i < x.
dims_.size(); ++i) {
3096 generate_increment(x.
K_, x.
dims_);
3099 generate_increment(x.
K_, x.
dims_);
3102 o_ <<
INDENT2 <<
"num_params_r__ += ((";
3107 o_ <<
" + 1)) / 2 + (";
3114 for (
size_t i = 0; i < x.
dims_.size(); ++i) {
3122 o_ <<
INDENT2 <<
"num_params_r__ += ((";
3126 o_ <<
" - 1)) / 2)";
3127 for (
size_t i = 0; i < x.
dims_.size(); ++i) {
3135 o_ <<
INDENT2 <<
"num_params_r__ += ((";
3139 o_ <<
" - 1)) / 2 + ";
3142 for (
size_t i = 0; i < x.
dims_.size(); ++i) {
3149 o_ <<
INDENT2 <<
"num_params_r__ += ((";
3153 o_ <<
" - 1)) / 2)";
3154 for (
size_t i = 0; i < x.
dims_.size(); ++i) {
3162 if (dims.size() == 0) {
3167 for (
size_t i = 0; i < dims.size(); ++i) {
3168 if (i > 0)
o_ <<
" * ";
3174 if (dims.size() == 0) {
3179 for (
size_t i = 0; i < dims.size(); ++i) {
3180 if (i > 0)
o_ <<
" * ";
3186 std::vector<expression> dims)
const {
3189 for (
size_t i = 0; i < dims.size(); ++i) {
3196 std::vector<expression> dims)
const {
3201 for (
size_t i = 0; i < dims.size(); ++i) {
3211 o <<
INDENT2 <<
"num_params_r__ = 0U;" <<
EOL;
3212 o <<
INDENT2 <<
"param_ranges_i__.clear();" <<
EOL;
3214 for (
size_t i = 0; i < var_decls.size(); ++i)
3215 boost::apply_visitor(vis, var_decls[i].decl_);
3219 const std::string& model_name,
3223 o <<
INDENT << model_name <<
"(stan::io::var_context& context__," <<
EOL;
3224 o <<
INDENT <<
" std::ostream* pstream__ = 0)" <<
EOL;
3226 o <<
INDENT2 <<
"typedef boost::ecuyer1988 rng_t;" <<
EOL;
3227 o <<
INDENT2 <<
"rng_t base_rng(0); // 0 seed default" <<
EOL;
3228 o <<
INDENT2 <<
"ctor_body(context__, base_rng, pstream__);" <<
EOL;
3232 o <<
INDENT <<
"template <class RNG>" <<
EOL;
3233 o <<
INDENT << model_name <<
"(stan::io::var_context& context__," <<
EOL;
3234 o <<
INDENT <<
" RNG& base_rng__," <<
EOL;
3235 o <<
INDENT <<
" std::ostream* pstream__ = 0)" <<
EOL;
3237 o <<
INDENT2 <<
"ctor_body(context__, base_rng__, pstream__);" <<
EOL;
3241 o <<
INDENT <<
"template <class RNG>" <<
EOL;
3242 o <<
INDENT <<
"void ctor_body(stan::io::var_context& context__," <<
EOL;
3243 o <<
INDENT <<
" RNG& base_rng__," <<
EOL;
3244 o <<
INDENT <<
" std::ostream* pstream__) {" <<
EOL;
3245 o <<
INDENT2 <<
"current_statement_begin__ = -1;" <<
EOL2;
3246 o <<
INDENT2 <<
"static const char* function__ = \"" 3247 << model_name <<
"_namespace::" << model_name <<
"\";" <<
EOL;
3251 o <<
INDENT2 <<
"std::vector<int> vals_i__;" <<
EOL;
3252 o <<
INDENT2 <<
"std::vector<double> vals_r__;" <<
EOL;
3255 <<
"double DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());" 3257 o <<
INDENT2 <<
"(void) DUMMY_VAR__; // suppress unused var warning" 3260 o <<
INDENT2 <<
"// initialize member variables" <<
EOL;
3270 bool include_sampling =
false;
3271 bool is_var_context =
false;
3272 bool is_fun_return =
false;
3276 2, o, include_sampling, is_var_context,
3295 var_size_validator_(o,
"initialization") {
3300 var_size_validator_(x);
3303 generate_write_loop(
"integer(", x.
name_, x.
dims_);
3305 template <
typename D>
3308 std::stringstream ss;
3311 ss <<
"_lub_unconstrain(";
3317 ss <<
"_lb_unconstrain(";
3321 ss <<
"_ub_unconstrain(";
3325 ss <<
"_unconstrain(";
3331 generate_check_double(x.
name_, x.
dims_.size());
3332 var_size_validator_(x);
3337 generate_write_loop(function_args(
"scalar", x),
3341 generate_check_double(x.
name_, x.
dims_.size() + 1);
3342 var_size_validator_(x);
3345 generate_write_loop(function_args(
"vector", x),
3349 generate_check_double(x.
name_, x.
dims_.size() + 1);
3350 var_size_validator_(x);
3354 generate_write_loop(function_args(
"row_vector", x),
3358 generate_check_double(x.
name_, x.
dims_.size() + 2);
3359 var_size_validator_(x);
3362 generate_write_loop(function_args(
"matrix", x),
3366 generate_check_double(x.
name_, x.
dims_.size() + 1);
3367 var_size_validator_(x);
3370 generate_write_loop(
"unit_vector_unconstrain(", x.
name_, x.
dims_);
3373 generate_check_double(x.
name_, x.
dims_.size() + 1);
3374 var_size_validator_(x);
3377 generate_write_loop(
"simplex_unconstrain(", x.
name_, x.
dims_);
3380 generate_check_double(x.
name_, x.
dims_.size() + 1);
3381 var_size_validator_(x);
3384 generate_write_loop(
"ordered_unconstrain(", x.
name_, x.
dims_);
3387 generate_check_double(x.
name_, x.
dims_.size() + 1);
3388 var_size_validator_(x);
3391 generate_write_loop(
"positive_ordered_unconstrain(", x.
name_, x.
dims_);
3394 generate_check_double(x.
name_, x.
dims_.size() + 2);
3395 var_size_validator_(x);
3398 generate_write_loop(
"cholesky_factor_unconstrain(", x.
name_, x.
dims_);
3401 generate_check_double(x.
name_, x.
dims_.size() + 2);
3402 var_size_validator_(x);
3405 generate_write_loop(
"cholesky_corr_unconstrain(", x.
name_, x.
dims_);
3408 generate_check_double(x.
name_, x.
dims_.size() + 2);
3409 var_size_validator_(x);
3412 generate_write_loop(
"cov_matrix_unconstrain(", x.
name_, x.
dims_);
3415 generate_check_double(x.
name_, x.
dims_.size() + 2);
3416 var_size_validator_(x);
3419 generate_write_loop(
"corr_matrix_unconstrain(", x.
name_, x.
dims_);
3422 const std::string& var_name,
3423 const std::vector<expression>& dims)
const {
3424 generate_dims_loop_fwd(dims);
3428 <<
"writer__." << write_method_name;
3429 generate_name_dims(var_name, dims.size());
3433 <<
"} catch (const std::exception& e) { " 3436 <<
"throw std::runtime_error(" 3437 <<
"std::string(\"Error transforming variable " 3438 << var_name <<
": \") + e.what());" 3445 size_t num_dims)
const {
3447 for (
size_t i = 0; i < num_dims; ++i)
3448 o_ <<
"[i" << i <<
"__]";
3451 const std::string& base_type,
3452 const std::vector<expression>& dims,
3457 o_ <<
INDENT2 <<
"// generate_declaration " << name << std::endl;
3464 const std::vector<expression>& dims,
3472 const std::string& name,
3473 const std::vector<expression>& dims,
3476 int indent = 2U)
const {
3477 size_t size = dims.size();
3480 int extra_indent = is_matrix ? 2U : is_vector ? 1U : 0U;
3483 o_ <<
"for (int j2__ = 0U; j2__ < ";
3485 o_ <<
"; ++j2__)" <<
EOL;
3488 o_ <<
"for (int j1__ = 0U; j1__ < ";
3490 o_ <<
"; ++j1__)" <<
EOL;
3491 }
else if (is_vector) {
3493 o_ <<
"for (int j1__ = 0U; j1__ < ";
3495 o_ <<
"; ++j1__)" <<
EOL;
3497 for (
size_t i = 0; i < size; ++i) {
3498 size_t idx = size - i - 1;
3500 o_ <<
"for (int i" << idx <<
"__ = 0U; i" << idx <<
"__ < ";
3502 o_ <<
"; ++i" << idx <<
"__)" <<
EOL;
3504 generate_indent_num_dims(2U, dims, dim1, dim2);
3506 for (
size_t i = 0; i < dims.size(); ++i)
3507 o_ <<
"[i" << i <<
"__]";
3509 o_ <<
"(j1__,j2__)";
3512 o_ <<
" = vals_" << base_type <<
"__[pos__++];" <<
EOL;
3515 int indent = 2U)
const {
3516 size_t size = dims.size();
3517 for (
size_t i = 0; i < size; ++i) {
3519 o_ <<
"for (int i" << i <<
"__ = 0U; i" << i <<
"__ < ";
3521 o_ <<
"; ++i" << i <<
"__)" <<
EOL;
3527 <<
"if (!(context__.contains_i(\"" << name <<
"\")))" 3529 <<
"throw std::runtime_error(\"variable " << name <<
" missing\");" 3531 o_ <<
INDENT2 <<
"vals_i__ = context__.vals_i(\"" << name <<
"\");" 3537 <<
"if (!(context__.contains_r(\"" << name <<
"\")))" 3539 <<
"throw std::runtime_error(\"variable " << name <<
" missing\");" 3542 <<
"vals_r__ = context__.vals_r(\"" << name <<
"\");" <<
EOL;
3552 <<
"void transform_inits(const stan::io::var_context& context__," 3554 o <<
INDENT <<
" std::vector<int>& params_i__," 3556 o <<
INDENT <<
" std::vector<double>& params_r__," 3558 o <<
INDENT <<
" std::ostream* pstream__) const {" 3560 o <<
INDENT2 <<
"stan::io::writer<double> " 3561 <<
"writer__(params_r__,params_i__);" 3564 o <<
INDENT2 <<
"(void) pos__; // dummy call to supress warning" <<
EOL;
3565 o <<
INDENT2 <<
"std::vector<double> vals_r__;" <<
EOL;
3566 o <<
INDENT2 <<
"std::vector<int> vals_i__;" 3569 for (
size_t i = 0; i < vs.size(); ++i)
3570 boost::apply_visitor(vis, vs[i].decl_);
3573 <<
INDENT2 <<
"params_r__ = writer__.data_r();" <<
EOL;
3574 o <<
INDENT2 <<
"params_i__ = writer__.data_i();" <<
EOL;
3578 <<
"void transform_inits(const stan::io::var_context& context," <<
EOL;
3581 <<
"Eigen::Matrix<double,Eigen::Dynamic,1>& params_r," <<
EOL;
3583 <<
" std::ostream* pstream__) const {" <<
EOL;
3584 o <<
INDENT <<
" std::vector<double> params_r_vec;" <<
EOL;
3585 o <<
INDENT <<
" std::vector<int> params_i_vec;" <<
EOL;
3587 <<
" transform_inits(context, params_i_vec, params_r_vec, pstream__);" 3589 o <<
INDENT <<
" params_r.resize(params_r_vec.size());" <<
EOL;
3590 o <<
INDENT <<
" for (int i = 0; i < params_r.size(); ++i)" <<
EOL;
3591 o <<
INDENT <<
" params_r(i) = params_r_vec[i];" <<
EOL;
3601 generate_dims_array(EMPTY_EXP_VECTOR, x.
dims_);
3604 generate_dims_array(EMPTY_EXP_VECTOR, x.
dims_);
3607 std::vector<expression> matrix_args;
3608 matrix_args.push_back(x.
M_);
3609 generate_dims_array(matrix_args, x.
dims_);
3612 std::vector<expression> matrix_args;
3613 matrix_args.push_back(x.
N_);
3614 generate_dims_array(matrix_args, x.
dims_);
3617 std::vector<expression> matrix_args;
3618 matrix_args.push_back(x.
M_);
3619 matrix_args.push_back(x.
N_);
3620 generate_dims_array(matrix_args, x.
dims_);
3623 std::vector<expression> matrix_args;
3624 matrix_args.push_back(x.
K_);
3625 generate_dims_array(matrix_args, x.
dims_);
3628 std::vector<expression> matrix_args;
3629 matrix_args.push_back(x.
K_);
3630 generate_dims_array(matrix_args, x.
dims_);
3633 std::vector<expression> matrix_args;
3634 matrix_args.push_back(x.
K_);
3635 generate_dims_array(matrix_args, x.
dims_);
3638 std::vector<expression> matrix_args;
3639 matrix_args.push_back(x.
K_);
3640 generate_dims_array(matrix_args, x.
dims_);
3643 std::vector<expression> matrix_args;
3644 matrix_args.push_back(x.
M_);
3645 matrix_args.push_back(x.
N_);
3646 generate_dims_array(matrix_args, x.
dims_);
3649 std::vector<expression> matrix_args;
3650 matrix_args.push_back(x.
K_);
3651 matrix_args.push_back(x.
K_);
3652 generate_dims_array(matrix_args, x.
dims_);
3655 std::vector<expression> matrix_args;
3656 matrix_args.push_back(x.
K_);
3657 matrix_args.push_back(x.
K_);
3658 generate_dims_array(matrix_args, x.
dims_);
3661 std::vector<expression> matrix_args;
3662 matrix_args.push_back(x.
K_);
3663 matrix_args.push_back(x.
K_);
3664 generate_dims_array(matrix_args, x.
dims_);
3668 const std::vector<expression>& array_dims_exprs)
3671 for (
size_t i = 0; i < array_dims_exprs.size(); ++i) {
3677 for (
size_t i = 0; i < matrix_dims_exprs.size(); ++i) {
3690 <<
"void get_dims(std::vector<std::vector<size_t> >& dimss__) const {" 3694 o <<
INDENT2 <<
"std::vector<size_t> dims__;" <<
EOL;
3701 for (
size_t i = 0; i < prog.
derived_decl_.first.size(); ++i) {
3702 boost::apply_visitor(vis, prog.
derived_decl_.first[i].decl_);
3719 generate_param_names(x.
name_);
3722 generate_param_names(x.
name_);
3725 generate_param_names(x.
name_);
3728 generate_param_names(x.
name_);
3731 generate_param_names(x.
name_);
3734 generate_param_names(x.
name_);
3737 generate_param_names(x.
name_);
3740 generate_param_names(x.
name_);
3743 generate_param_names(x.
name_);
3746 generate_param_names(x.
name_);
3749 generate_param_names(x.
name_);
3752 generate_param_names(x.
name_);
3755 generate_param_names(x.
name_);
3760 <<
"names__.push_back(\"" << name <<
"\");" 3770 <<
"void get_param_names(std::vector<std::string>& names__) const {" 3774 <<
"names__.resize(0);" 3782 for (
size_t i = 0; i < prog.
derived_decl_.first.size(); ++i) {
3783 boost::apply_visitor(vis, prog.
derived_decl_.first[i].decl_);
3801 generate_param_names_array(EMPTY_EXP_VECTOR, x.
name_, x.
dims_);
3804 generate_param_names_array(EMPTY_EXP_VECTOR, x.
name_, x.
dims_);
3807 std::vector<expression> matrix_args;
3808 matrix_args.push_back(x.
M_);
3809 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3812 std::vector<expression> matrix_args;
3813 matrix_args.push_back(x.
N_);
3814 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3817 std::vector<expression> matrix_args;
3818 matrix_args.push_back(x.
M_);
3819 matrix_args.push_back(x.
N_);
3820 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3823 std::vector<expression> matrix_args;
3824 matrix_args.push_back(x.
K_);
3825 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3828 std::vector<expression> matrix_args;
3829 matrix_args.push_back(x.
K_);
3830 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3833 std::vector<expression> matrix_args;
3834 matrix_args.push_back(x.
K_);
3835 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3838 std::vector<expression> matrix_args;
3839 matrix_args.push_back(x.
K_);
3840 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3843 std::vector<expression> matrix_args;
3844 matrix_args.push_back(x.
M_);
3845 matrix_args.push_back(x.
N_);
3846 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3849 std::vector<expression> matrix_args;
3850 matrix_args.push_back(x.
K_);
3851 matrix_args.push_back(x.
K_);
3852 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3855 std::vector<expression> matrix_args;
3856 matrix_args.push_back(x.
K_);
3857 matrix_args.push_back(x.
K_);
3858 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3861 std::vector<expression> matrix_args;
3862 matrix_args.push_back(x.
K_);
3863 matrix_args.push_back(x.
K_);
3864 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3868 const std::string& name,
3869 const std::vector<expression>& dims)
const {
3871 std::vector<expression> combo_dims(dims);
3872 for (
size_t i = 0; i < matrix_dims.size(); ++i)
3873 combo_dims.push_back(matrix_dims[i]);
3875 for (
size_t i = combo_dims.size(); i-- > 0; ) {
3877 o_ <<
"for (int k_" << i <<
"__ = 1;" 3878 <<
" k_" << i <<
"__ <= ";
3880 o_ <<
"; ++k_" << i <<
"__) {" <<
EOL;
3884 o_ <<
"param_name_stream__.str(std::string());" <<
EOL;
3887 o_ <<
"param_name_stream__ << \"" << name <<
'"';
3889 for (
size_t i = 0; i < combo_dims.size(); ++i)
3890 o_ <<
" << '.' << k_" << i <<
"__";
3894 o_ <<
"param_names__.push_back(param_name_stream__.str());" <<
EOL;
3897 for (
size_t i = 0; i < combo_dims.size(); ++i) {
3908 <<
"void constrained_param_names(" 3909 <<
"std::vector<std::string>& param_names__," 3911 <<
" bool include_tparams__ = true," 3913 <<
" bool include_gqs__ = true) const {" 3915 <<
"std::stringstream param_name_stream__;" <<
EOL;
3924 <<
"if (!include_gqs__ && !include_tparams__) return;" 3928 for (
size_t i = 0; i < prog.
derived_decl_.first.size(); ++i) {
3929 boost::apply_visitor(vis, prog.
derived_decl_.first[i].decl_);
3933 <<
"if (!include_gqs__) return;" 3950 generate_param_names_array(EMPTY_EXP_VECTOR, x.
name_, x.
dims_);
3953 generate_param_names_array(EMPTY_EXP_VECTOR, x.
name_, x.
dims_);
3956 std::vector<expression> matrix_args;
3957 matrix_args.push_back(x.
M_);
3958 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3961 std::vector<expression> matrix_args;
3962 matrix_args.push_back(x.
N_);
3963 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3966 std::vector<expression> matrix_args;
3967 matrix_args.push_back(x.
M_);
3968 matrix_args.push_back(x.
N_);
3969 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3972 std::vector<expression> matrix_args;
3973 matrix_args.push_back(x.
K_);
3974 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3977 std::vector<expression> matrix_args;
3979 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3982 std::vector<expression> matrix_args;
3983 matrix_args.push_back(x.
K_);
3984 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3987 std::vector<expression> matrix_args;
3988 matrix_args.push_back(x.
K_);
3989 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
3993 std::vector<expression> matrix_args;
4008 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
4012 std::vector<expression> matrix_args;
4021 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
4024 std::vector<expression> matrix_args;
4034 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
4037 std::vector<expression> matrix_args;
4045 generate_param_names_array(matrix_args, x.
name_, x.
dims_);
4050 const std::string& name,
4051 const std::vector<expression>& dims)
const {
4053 std::vector<expression> combo_dims(dims);
4054 for (
size_t i = 0; i < matrix_dims.size(); ++i)
4055 combo_dims.push_back(matrix_dims[i]);
4057 for (
size_t i = combo_dims.size(); i-- > 0; ) {
4059 o_ <<
"for (int k_" << i <<
"__ = 1;" 4060 <<
" k_" << i <<
"__ <= ";
4062 o_ <<
"; ++k_" << i <<
"__) {" <<
EOL;
4066 o_ <<
"param_name_stream__.str(std::string());" <<
EOL;
4069 o_ <<
"param_name_stream__ << \"" << name <<
'"';
4071 for (
size_t i = 0; i < combo_dims.size(); ++i)
4072 o_ <<
" << '.' << k_" << i <<
"__";
4076 o_ <<
"param_names__.push_back(param_name_stream__.str());" <<
EOL;
4079 for (
size_t i = 0; i < combo_dims.size(); ++i) {
4090 <<
"void unconstrained_param_names(" 4091 <<
"std::vector<std::string>& param_names__," 4093 <<
" bool include_tparams__ = true," 4095 <<
" bool include_gqs__ = true) const {" 4097 <<
"std::stringstream param_name_stream__;" <<
EOL;
4106 <<
"if (!include_gqs__ && !include_tparams__) return;" 4110 for (
size_t i = 0; i < prog.
derived_decl_.first.size(); ++i) {
4111 boost::apply_visitor(vis, prog.
derived_decl_.first[i].decl_);
4115 <<
"if (!include_gqs__) return;" 4134 generate_initialize_array(
"int",
"integer", EMPTY_EXP_VECTOR,
4138 template <
typename D>
4140 const std::string& base_type,
4141 const std::string& read_fun_prefix,
4142 const std::vector<expression>& dim_args)
const {
4143 std::vector<expression> read_args;
4144 std::string read_fun(read_fun_prefix);
4147 read_args.push_back(x.range_.low_);
4148 read_args.push_back(x.range_.high_);
4151 read_args.push_back(x.range_.low_);
4154 read_args.push_back(x.range_.high_);
4156 for (
size_t i = 0; i < dim_args.size(); ++i)
4157 read_args.push_back(dim_args[i]);
4158 generate_initialize_array(base_type, read_fun, read_args,
4163 std::vector<expression> read_args;
4164 generate_initialize_array_bounded(x,
"double",
"scalar", read_args);
4167 std::vector<expression> read_args;
4168 read_args.push_back(x.
M_);
4169 generate_initialize_array_bounded(x,
"vector_d",
"vector", read_args);
4172 std::vector<expression> read_args;
4173 read_args.push_back(x.
N_);
4174 generate_initialize_array_bounded(x,
"row_vector_d",
"row_vector",
4178 std::vector<expression> read_args;
4179 read_args.push_back(x.
M_);
4180 read_args.push_back(x.
N_);
4181 generate_initialize_array_bounded(x,
"matrix_d",
"matrix", read_args);
4184 std::vector<expression> read_args;
4185 read_args.push_back(x.
K_);
4186 generate_initialize_array(
"vector_d",
"unit_vector", read_args,
4190 std::vector<expression> read_args;
4191 read_args.push_back(x.
K_);
4192 generate_initialize_array(
"vector_d",
"simplex", read_args,
4196 std::vector<expression> read_args;
4197 read_args.push_back(x.
K_);
4198 generate_initialize_array(
"vector_d",
"ordered", read_args,
4202 std::vector<expression> read_args;
4203 read_args.push_back(x.
K_);
4204 generate_initialize_array(
"vector_d",
"positive_ordered", read_args,
4208 std::vector<expression> read_args;
4209 read_args.push_back(x.
M_);
4210 read_args.push_back(x.
N_);
4211 generate_initialize_array(
"matrix_d",
"cholesky_factor", read_args,
4215 std::vector<expression> read_args;
4216 read_args.push_back(x.
K_);
4217 generate_initialize_array(
"matrix_d",
"cholesky_corr", read_args,
4221 std::vector<expression> read_args;
4222 read_args.push_back(x.
K_);
4223 generate_initialize_array(
"matrix_d",
"cov_matrix", read_args,
4227 std::vector<expression> read_args;
4228 read_args.push_back(x.
K_);
4229 generate_initialize_array(
"matrix_d",
"corr_matrix", read_args,
4233 const std::string& read_type,
4234 const std::vector<expression>& read_args,
4235 const std::string& name,
4236 const std::vector<expression>& dims)
const{
4237 if (dims.size() == 0) {
4239 o_ << var_type <<
" ";
4240 o_ << name <<
" = in__." << read_type <<
"_constrain(";
4241 for (
size_t j = 0; j < read_args.size(); ++j) {
4242 if (j > 0)
o_ <<
",";
4249 for (
size_t i = 0; i < dims.size(); ++i)
o_ <<
"vector<";
4251 for (
size_t i = 0; i < dims.size(); ++i)
o_ <<
"> ";
4252 o_ << name <<
";" <<
EOL;
4253 std::string name_dims(name);
4254 for (
size_t i = 0; i < dims.size(); ++i) {
4256 o_ <<
"size_t dim_" << name <<
"_" << i <<
"__ = ";
4259 if (i < dims.size() - 1) {
4261 o_ << name_dims <<
".resize(dim_" << name <<
"_" << i <<
"__);" 4263 name_dims.append(
"[k_").append(
to_string(i)).append(
"__]");
4266 o_ <<
"for (size_t k_" << i <<
"__ = 0;" 4267 <<
" k_" << i <<
"__ < dim_" << name <<
"_" << i <<
"__;" 4268 <<
" ++k_" << i <<
"__) {" <<
EOL;
4269 if (i == dims.size() - 1) {
4271 o_ << name_dims <<
".push_back(in__." << read_type <<
"_constrain(";
4272 for (
size_t j = 0; j < read_args.size(); ++j) {
4273 if (j > 0)
o_ <<
",";
4280 for (
size_t i = dims.size(); i > 0; --i) {
4297 write_array(x.
name_, x.
dims_, EMPTY_EXP_VECTOR);
4300 write_array(x.
name_, x.
dims_, EMPTY_EXP_VECTOR);
4303 std::vector<expression> dims(x.
dims_);
4304 dims.push_back(x.
M_);
4305 write_array(x.
name_, dims, EMPTY_EXP_VECTOR);
4308 std::vector<expression> dims(x.
dims_);
4309 dims.push_back(x.
N_);
4310 write_array(x.
name_, dims, EMPTY_EXP_VECTOR);
4313 std::vector<expression> matdims;
4314 matdims.push_back(x.
M_);
4315 matdims.push_back(x.
N_);
4319 std::vector<expression> dims(x.
dims_);
4320 dims.push_back(x.
K_);
4321 write_array(x.
name_, dims, EMPTY_EXP_VECTOR);
4324 std::vector<expression> dims(x.
dims_);
4325 dims.push_back(x.
K_);
4326 write_array(x.
name_, dims, EMPTY_EXP_VECTOR);
4329 std::vector<expression> dims(x.
dims_);
4330 dims.push_back(x.
K_);
4331 write_array(x.
name_, dims, EMPTY_EXP_VECTOR);
4334 std::vector<expression> dims(x.
dims_);
4335 dims.push_back(x.
K_);
4336 write_array(x.
name_, dims, EMPTY_EXP_VECTOR);
4339 std::vector<expression> matdims;
4340 matdims.push_back(x.
M_);
4341 matdims.push_back(x.
N_);
4345 std::vector<expression> matdims;
4346 matdims.push_back(x.
K_);
4347 matdims.push_back(x.
K_);
4351 std::vector<expression> matdims;
4352 matdims.push_back(x.
K_);
4353 matdims.push_back(x.
K_);
4357 std::vector<expression> matdims;
4358 matdims.push_back(x.
K_);
4359 matdims.push_back(x.
K_);
4363 const std::vector<expression>& arraydims,
4364 const std::vector<expression>& matdims)
const {
4365 std::vector<expression> dims(arraydims);
4366 for (
size_t i = 0; i < matdims.size(); ++i)
4367 dims.push_back(matdims[i]);
4369 if (dims.size() == 0) {
4370 o_ <<
INDENT2 <<
"vars__.push_back(" << name <<
");" <<
EOL;
4375 for (
size_t i = dims.size(); i > 0; ) {
4378 o_ <<
"for (int k_" << i <<
"__ = 0;" 4379 <<
" k_" << i <<
"__ < ";
4381 o_ <<
"; ++k_" << i <<
"__) {" <<
EOL;
4385 o_ <<
"vars__.push_back(" << name;
4386 if (arraydims.size() > 0) {
4388 for (
size_t i = 0; i < arraydims.size(); ++i) {
4389 if (i > 0)
o_ <<
"][";
4390 o_ <<
"k_" << i <<
"__";
4394 if (matdims.size() > 0) {
4395 o_ <<
"(k_" << arraydims.size() <<
"__";
4396 if (matdims.size() > 1)
4397 o_ <<
", k_" << (arraydims.size() + 1) <<
"__";
4402 for (
size_t i = dims.size(); i > 0; --i) {
4411 const std::string& model_name,
4413 o <<
INDENT <<
"template <typename RNG>" <<
EOL;
4414 o <<
INDENT <<
"void write_array(RNG& base_rng__," <<
EOL;
4415 o <<
INDENT <<
" std::vector<double>& params_r__," <<
EOL;
4416 o <<
INDENT <<
" std::vector<int>& params_i__," <<
EOL;
4417 o <<
INDENT <<
" std::vector<double>& vars__," <<
EOL;
4418 o <<
INDENT <<
" bool include_tparams__ = true," <<
EOL;
4419 o <<
INDENT <<
" bool include_gqs__ = true," <<
EOL;
4421 <<
" std::ostream* pstream__ = 0) const {" <<
EOL;
4424 <<
"stan::io::reader<double> in__(params_r__,params_i__);"<<
EOL;
4425 o <<
INDENT2 <<
"static const char* function__ = \"" 4426 << model_name <<
"_namespace::write_array\";" <<
EOL;
4443 o <<
INDENT2 <<
"if (!include_tparams__) return;" 4448 o <<
INDENT2 <<
"stan::math::accumulator<double> lp_accum__;" <<
EOL2;
4451 <<
"double DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());" 4453 o <<
INDENT2 <<
"(void) DUMMY_VAR__; // suppress unused var warning" 4456 bool is_var_context =
false;
4457 bool is_fun_return =
false;
4461 bool include_sampling =
false;
4463 include_sampling, is_var_context,
4472 for (
size_t i = 0; i < prog.
derived_decl_.first.size(); ++i)
4473 boost::apply_visitor(vis_writer, prog.
derived_decl_.first[i].decl_);
4476 o <<
INDENT2 <<
"if (!include_gqs__) return;" 4480 is_var_context, is_fun_return);
4484 include_sampling, is_var_context,
4494 boost::apply_visitor(vis_writer, prog.
generated_decl_.first[i].decl_);
4500 o <<
INDENT <<
"template <typename RNG>" <<
EOL;
4501 o <<
INDENT <<
"void write_array(RNG& base_rng," <<
EOL;
4503 <<
" Eigen::Matrix<double,Eigen::Dynamic,1>& params_r," 4506 <<
" Eigen::Matrix<double,Eigen::Dynamic,1>& vars," 4508 o <<
INDENT <<
" bool include_tparams = true," <<
EOL;
4509 o <<
INDENT <<
" bool include_gqs = true," <<
EOL;
4511 <<
" std::ostream* pstream = 0) const {" <<
EOL;
4513 <<
" std::vector<double> params_r_vec(params_r.size());" <<
EOL;
4514 o <<
INDENT <<
" for (int i = 0; i < params_r.size(); ++i)" <<
EOL;
4515 o <<
INDENT <<
" params_r_vec[i] = params_r(i);" <<
EOL;
4516 o <<
INDENT <<
" std::vector<double> vars_vec;" <<
EOL;
4517 o <<
INDENT <<
" std::vector<int> params_i_vec;" <<
EOL;
4519 <<
" write_array(base_rng,params_r_vec,params_i_vec," 4520 <<
"vars_vec,include_tparams,include_gqs,pstream);" <<
EOL;
4521 o <<
INDENT <<
" vars.resize(vars_vec.size());" <<
EOL;
4522 o <<
INDENT <<
" for (int i = 0; i < vars.size(); ++i)" <<
EOL;
4523 o <<
INDENT <<
" vars(i) = vars_vec[i];" <<
EOL;
4528 std::ostream& out) {
4529 out <<
INDENT <<
"static std::string model_name() {" <<
EOL 4530 <<
INDENT2 <<
"return \"" << model_name <<
"\";" <<
EOL 4535 std::ostream& out) {
4536 out <<
"typedef " << model_name <<
"_namespace::" << model_name
4537 <<
" stan_model;" <<
EOL2;
4541 const std::string& scalar_t_name,
4542 std::ostream& out) {
4543 for (
size_t d = 0; d < t.
num_dims_; ++d)
4544 out <<
"std::vector<";
4546 bool is_template_type =
false;
4550 is_template_type =
false;
4553 out << scalar_t_name;
4554 is_template_type =
false;
4557 out <<
"Eigen::Matrix<" 4559 <<
", Eigen::Dynamic,1>";
4560 is_template_type =
true;
4563 out <<
"Eigen::Matrix<" 4565 <<
", 1,Eigen::Dynamic>";
4566 is_template_type =
true;
4569 out <<
"Eigen::Matrix<" 4571 <<
", Eigen::Dynamic,Eigen::Dynamic>";
4572 is_template_type =
true;
4578 out <<
"UNKNOWN TYPE";
4581 for (
size_t d = 0; d < t.
num_dims_; ++d) {
4582 if (d > 0 || is_template_type)
4591 const std::string& scalar_t_name,
4592 std::ostream& out) {
4598 out <<
" " << decl.
name_;
4602 for (
size_t i = 0; i < fun.
arg_decls_.size(); ++i)
4616 std::stringstream ss;
4617 ss <<
"typename boost::math::tools::promote_args<";
4618 int num_open_brackets = 1;
4619 int num_generated_params = 0;
4620 for (
size_t i = 0; i < num_args; ++i) {
4623 if (num_generated_params > 0)
4625 if (num_generated_params == 4) {
4626 ss <<
"typename boost::math::tools::promote_args<";
4627 num_generated_params = 0;
4628 ++num_open_brackets;
4630 ss <<
"T" << i <<
"__";
4631 ++num_generated_params;
4635 if (num_generated_params > 0)
4640 for (
int i = 0; i < num_open_brackets; ++i)
4648 for (
size_t i = 0; i < fun.
arg_decls_.size(); ++i) {
4661 std::ostream& out) {
4663 out <<
"template <";
4664 bool continuing_tps =
false;
4666 out <<
"bool propto";
4667 continuing_tps =
true;
4669 for (
size_t i = 0; i < fun.
arg_decls_.size(); ++i) {
4674 out <<
"typename T" << i <<
"__";
4675 continuing_tps =
true;
4682 continuing_tps =
true;
4686 out <<
"typename T_lp__, typename T_lp_accum__";
4687 continuing_tps =
true;
4693 out <<
"template <class RNG>" <<
EOL;
4695 out <<
"template <typename T_lp__, typename T_lp_accum__>" 4697 }
else if (is_log) {
4698 out <<
"template <bool propto>" 4705 const std::string& scalar_t_name,
4707 std::ostream& out) {
4714 std::ostream& out) {
4723 std::ostream& out) {
4726 for (
size_t i = 0; i < fun.
arg_decls_.size(); ++i) {
4727 std::string template_type_i
4728 =
"T" + boost::lexical_cast<std::string>(i) +
"__";
4732 for (
size_t i = 0; i <= fun.
name_.size(); ++i)
4736 if ((is_rng || is_lp) && fun.
arg_decls_.size() > 0)
4739 out <<
"RNG& base_rng__";
4741 out <<
"T_lp__& lp__, T_lp_accum__& lp_accum__";
4742 if (is_rng || is_lp || fun.
arg_decls_.size() > 0)
4744 out <<
"std::ostream* pstream__";
4752 std::ostream& out) {
4755 for (
size_t i = 0; i < fun.
arg_decls_.size(); ++i) {
4760 if ((is_rng || is_lp) && fun.
arg_decls_.size() > 0)
4763 out <<
"base_rng__";
4765 out <<
"lp__, lp_accum__";
4766 if (is_rng || is_lp || fun.
arg_decls_.size() > 0)
4775 const std::string& scalar_t_name,
4776 std::ostream& out) {
4784 <<
"typedef " << scalar_t_name <<
" fun_scalar_t__;" 4789 ?
"int" :
"fun_scalar_t__")
4790 <<
" fun_return_scalar_t__;" 4793 <<
"const static bool propto__ = true;" 4796 <<
"(void) propto__;" 4800 <<
"fun_scalar_t__ " 4801 <<
"DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());" 4803 out <<
INDENT2 <<
"(void) DUMMY_VAR__; // suppress unused var warning" 4805 bool is_var_context =
false;
4806 bool is_fun_return =
true;
4807 bool include_sampling =
true;
4809 <<
"int current_statement_begin__ = -1;" 4813 include_sampling, is_var_context,
4820 std::ostream& out) {
4822 out <<
INDENT <<
"return ";
4823 out << fun.
name_ <<
"<false>(";
4824 for (
size_t i = 0; i < fun.
arg_decls_.size(); ++i) {
4837 const std::string& scalar_t_name,
4838 std::ostream& out) {
4858 std::ostream& out) {
4880 std::ostream& out) {
4890 out <<
EOL <<
"struct ";
4892 out <<
"_functor__ {" <<
EOL;
4900 out << INDENT <<
"operator()";
4902 out <<
" const {" <<
EOL;
4908 out << INDENT <<
"}" <<
EOL;
4909 out <<
"};" <<
EOL2;
4914 std::ostream& out) {
4915 for (
size_t i = 0; i < funs.size(); ++i) {
4922 std::ostream& out) {
4928 out <<
"static int current_statement_begin__;" 4934 const std::string& model_name,
4935 std::ostream& out) {
void operator()(const return_statement &rs) const
void operator()(const positive_ordered_var_decl &x) const
An integer variable declaration and optional definition.
expression high_
Upper bound of range with nil value if only upper bound.
void declare_array(const std::string &type, const std::string &name, size_t size) const
void operator()(const matrix_var_decl &x) const
void operator()(const cholesky_corr_var_decl &x) const
void operator()(const vector_var_decl &x) const
void operator()(const unit_vector_var_decl &x) const
void operator()(const nil &) const
variable_dims var_dims_
Variable plus indexes.
write_dims_visgen(std::ostream &o)
void operator()(const cholesky_corr_var_decl &x) const
void operator()(const simplex_var_decl &x) const
void operator()(const uni_idx &i) const
void operator()(const cholesky_corr_var_decl &x) const
AST node for print statements.
void operator()(const cholesky_factor_var_decl &x) const
void operator()(const double_var_decl &x) const
AST structure to hold a single array or matrix/vector index.
void operator()(const ordered_var_decl &x) const
void operator()(const simplex_var_decl &x) const
std::string generate_
Text to generate, "break" or "continue".
void operator()(const positive_ordered_var_decl &x) const
Structure to hold the declaration of a positive ordered vector.
void operator()(const cholesky_corr_var_decl &x) const
void operator()(const cholesky_factor_var_decl &x) const
void nonbasic_validate(const T &x, const std::string &type_name) const
Structure to wrap the variant type of statements.
bool is_ill_formed() const
Return true if the base type of this type is ill formed.
void operator()(const ordered_var_decl &x) const
std::string family_
The name of the distribution.
void operator()(const ordered_var_decl &x) const
void operator()(const cholesky_factor_var_decl &x) const
void operator()(const cholesky_factor_var_decl &x) const
var_resizing_visgen var_resizer_
void generate_function(const function_decl_def &fun, std::ostream &out)
Generate the specified function and optionally its default for propto=false for functions ending in _...
void operator()(const cov_matrix_var_decl &x) const
void operator()(const cholesky_factor_var_decl &x) const
expression lb_
Lower bound.
void operator()(const matrix_var_decl &x) const
void operator()(const nil &) const
void operator()(const vector_var_decl &x) const
void declare_array(const std::string &type, const std::vector< expression > &ctor_args, const std::string &name, const std::vector< expression > &dims, const expression &definition=expression()) const
bool is_no_op_statement() const
Return true if the basic statement held by the variant type in this wrapper is the no-op statement...
void generate_idx_user(const idx &i, std::ostream &o)
void operator()(const no_op_statement &) const
Holder for local variable declarations and a sequence of statements.
const int ROW_VECTOR_T
Row vector type; scalar type is real.
void operator()(const corr_matrix_var_decl &x) const
AST node for the type delclaration for function arguments.
std::string to_string(T i)
bool operator()(const sample &st) const
range range_
Range constraint on values with optional lower and upper bounds.
Structure to hold a row vector variable declaration.
void operator()(const print_statement &ps) const
bool operator()(const return_statement &st) const
void operator()(const positive_ordered_var_decl &x) const
AST node for assignment to variable with multi-indexing.
void operator()(const simplex_var_decl &x) const
void operator()(const int_var_decl &x) const
void operator()(const cov_matrix_var_decl &x) const
void operator()(const double_var_decl &x) const
range range_
The range of values for the loop variable.
void generate_private_decl(std::ostream &o)
expression K_
Ordered vector size.
std::string name_
Name of variable.
void operator()(const ordered_var_decl &x) const
void operator()(const matrix_var_decl &x) const
void generate_comment(const std::string &msg, int indent, std::ostream &o)
std::vector< statement > statements_
Sequence of statements.
expression K_
Number of rows and columns.
distribution dist_
Distribution of the variable.
std::vector< expression > dims_
Dimension sizes for variable.
void operator()(const vector_var_decl &x) const
expr_type return_type_
Tyep of value returned by function.
void operator()(const assgn &y) const
void generate_increment(expression K, std::vector< expression > dims) const
expression ub_
Upper bound.
void generate_local_var_inits(std::vector< var_decl > vs, bool is_var_context, bool declare_vars, std::ostream &o)
range truncation_
The truncation range for the distribution.
void generate_declaration(const std::string &name, const std::string &base_type, const std::vector< expression > &dims, const expression &type_arg1=expression(), const expression &type_arg2=expression(), const expression &definition=expression()) const
std::size_t num_dims_
The number of array dimensions.
void operator()(const nil &) const
expression K_
Unit vector size.
void operator()(const double_var_decl &x) const
bool has_low() const
Return true if the lower bound is non-nil.
void operator()(const double_var_decl &x) const
statement statement_
Model block.
void operator()(const unit_vector_var_decl &x) const
bool operator()(const statements &st) const
void operator()(const lb_idx &i) const
AST node for the increment log prob (deprecated) and target increment statements. ...
void operator()(const corr_matrix_var_decl &x) const
void operator()(const unit_vector_var_decl &x) const
Probability, optimization and sampling library.
void operator()(const double_var_decl &x) const
AST node for the reject statement.
void generate_write_loop(const std::string &write_method_name, const std::string &var_name, const std::vector< expression > &dims) const
void operator()(const int_var_decl &x) const
void operator()(const positive_ordered_var_decl &x) const
void operator()(const nil &) const
void generate_check_int(const std::string &name, size_t) const
validate_var_decl_visgen(int indents, std::ostream &o)
void generate_loop_var(const std::string &name, size_t dims_size) const
idx_visgen(std::ostream &o)
void operator()(const cholesky_corr_var_decl &x) const
std::string get_prob_fun(const std::string &dist_name)
Return the probability function (density or mass) for the specified distribution name.
std::vector< var_decl > data_decl_
Data block.
void operator()(const cholesky_factor_var_decl &x) const
expression K_
Number of rows and columns.
void operator()(const int_var_decl &x) const
void operator()(const cholesky_corr_var_decl &x) const
void generate_unconstrained_param_names_method(const program &prog, std::ostream &o)
AST structure for break and continue statements.
void operator()(const cholesky_corr_var_decl &x) const
void operator()(const int_var_decl &x) const
void operator()(const unit_vector_var_decl &x) const
void generate_void_statement(const std::string &name, const size_t indent, std::ostream &o)
void operator()(const double_var_decl &x) const
void operator()(const matrix_var_decl &x) const
expression idxs_
Multiple indexes (array of integers).
var_resizing_visgen(std::ostream &o)
void operator()(const positive_ordered_var_decl &x) const
void operator()(const positive_ordered_var_decl &x) const
void operator()(const cov_matrix_var_decl &x) const
void operator()(const sample &x) const
std::vector< var_decl > local_decl_
Sequence of variable declarations.
void operator()(const unit_vector_var_decl &x) const
void operator()(const vector_var_decl &x) const
void operator()(const ordered_var_decl &x) const
bool operator()(const no_op_statement &st) const
statement_visgen(size_t indent, bool include_sampling, bool is_var_context, bool is_fun_return, std::ostream &o)
static void print_string_literal(std::ostream &o, const std::string &s)
std::string get_cdf(const std::string &dist_name)
Return the name of the CDF for the specified distribution name.
void generate_propto_default_function(const function_decl_def &fun, const std::string &scalar_t_name, std::ostream &out)
void generate_initialization(std::ostream &o, const std::string &var_name, const std::string &base_type, const std::vector< expression > &dims, const expression &type_arg1=expression(), const expression &type_arg2=expression())
void generate_model_typedef(const std::string &model_name, std::ostream &out)
void generate_end_for_dims(size_t dims_size) const
void operator()(const cov_matrix_var_decl &x) const
std::vector< statement > bodies_
The sequence of bodies to execute.
void operator()(const corr_matrix_var_decl &x) const
const int DOUBLE_T
Real scalar type.
void operator()(const vector_var_decl &x) const
void operator()(const cholesky_factor_var_decl &x) const
Structure to hold a covariance matrix variable declaration.
void operator()(const nil &) const
std::vector< printable > printables_
Sequence of printable objects.
void operator()(const uni_idx &i) const
void operator()(const nil &) const
void operator()(const row_vector_var_decl &x) const
int base_expr_type
The type of a base expression.
Structure for function application.
void operator()(const vector_var_decl &x) const
void operator()(const cov_matrix_var_decl &x) const
void operator()(const int_var_decl &x) const
member_var_decl_visgen(int indents, std::ostream &o)
void operator()(const positive_ordered_var_decl &x) const
statement_t statement_
The statement variant type held by this wrapper.
void operator()(const simplex_var_decl &x) const
bool operator()(const nil &st) const
void generate_idx(const idx &i, std::ostream &o)
void operator()(const ordered_var_decl &x) const
Structure of the type of an expression, which consists of a base type and a number of dimensions...
void operator()(const row_vector_var_decl &x) const
bool operator()(const assignment &st) const
AST node for sampling statements.
void operator()(const ordered_var_decl &x) const
var_size_validating_visgen var_size_validator_
void operator()(const cov_matrix_var_decl &x) const
void generate_indent(size_t indent, std::ostream &o)
void operator()(const ordered_var_decl &x) const
void operator()(const cholesky_corr_var_decl &x) const
void operator()(const simplex_var_decl &x) const
void operator()(const cholesky_factor_var_decl &x) const
void operator()(const double_var_decl &x) const
void operator()(const matrix_var_decl &x) const
void operator()(const corr_matrix_var_decl &x) const
bool has_high() const
Return true if the upper bound is non-nil.
void operator()(const nil &) const
Structure to hold the declaration of a simplex.
void generate_member_var_inits(const std::vector< var_decl > &vs, std::ostream &o)
void operator()(const cholesky_factor_var_decl &x) const
void operator()(const positive_ordered_var_decl &x) const
void operator()(const matrix_var_decl &x) const
void operator()(const simplex_var_decl &x) const
void operator()(const int_var_decl &x) const
void generate_member_var_decls(const std::vector< var_decl > &vs, int indent, std::ostream &o)
void generate_globals(std::ostream &out)
void operator()(const matrix_var_decl &x) const
void generate_idxs_user(const std::vector< idx > &idxs, std::ostream &o)
void generate_param_names(const std::string &name) const
expr_type expression_type() const
base_var_decl var_type_
Type of the left hand side variable before indexing.
std::string fun_scalar_type(const function_decl_def &fun, bool is_lp)
Structure to hold a Cholesky factor for a correlation matrix variable declaration.
void operator()(const cholesky_corr_var_decl &x) const
void generate_dims_method(const program &prog, std::ostream &o)
generate_init_visgen(std::ostream &o)
void generate_param_names_method(const program &prog, std::ostream &o)
void generate_indent_num_dims(size_t base_indent, const std::vector< expression > &dims, const expression &dim1, const expression &dim2) const
printable_visgen(std::ostream &o)
void basic_validate(const T &x) const
void generate_increment_i(std::vector< expression > dims) const
void operator()(const simplex_var_decl &x) const
void operator()(const std::string &s) const
expression N_
Number of columns in the row vector (its size).
expression ub_
Upper bound.
void generate_usings(std::ostream &o)
void generate_statements(const std::vector< statement > &ss, int indent, std::ostream &o, bool include_sampling, bool is_var_context, bool is_fun_return)
std::string variable_
The loop variable.
void generate_cpp(const program &prog, const std::string &model_name, std::ostream &out)
std::string get_ccdf(const std::string &dist_name)
Return the CCDF for the specified distribution.
void generate_define_vars(const std::vector< var_decl > &vs, int indent, bool is_var_context, std::ostream &o)
void operator()(const simplex_var_decl &x) const
void generate_log_prob(const program &p, std::ostream &o)
bool has_only_int_args(const function_decl_def &fun)
void operator()(const ordered_var_decl &x) const
void generate_write_array_method(const program &prog, const std::string &model_name, std::ostream &o)
const std::string INDENT3(" ")
std::string function_args(const std::string &fun_prefix, const D &x) const
std::vector< function_decl_def > function_decl_defs_
Functions block.
void operator()(const double_var_decl &x) const
void generate_init_vars(const std::vector< var_decl > &vs, int indent, std::ostream &o)
bool needs_template_params(const function_decl_def &fun)
void generate_typedef(const std::string &type, const std::string &abbrev, std::ostream &o)
void generate_validate_context_size(std::ostream &o, const std::string &stage, const std::string &var_name, const std::string &base_type, const std::vector< expression > &dims, const expression &type_arg1=expression(), const expression &type_arg2=expression())
void operator()(const statements &x) const
void operator()(const conditional_statement &x) const
void operator()(const int_var_decl &x) const
void operator()(const int_var_decl &x) const
AST structure for lower and upper bounds.
void generate_set_param_ranges(const std::vector< var_decl > &var_decls, std::ostream &o)
void operator()(const matrix_var_decl &x) const
void generate_model_name_method(const std::string &model_name, std::ostream &out)
void operator()(const ordered_var_decl &x) const
void operator()(const vector_var_decl &x) const
void operator()(const row_vector_var_decl &x) const
const std::string INDENT(" ")
const bool is_var_context_
bool operator()(const print_statement &st) const
bool operator()(const while_statement &st) const
void operator()(const nil &) const
void operator()(const cov_matrix_var_decl &x) const
void generate_using_namespace(const std::string &ns, std::ostream &o)
void generate_function_body(const function_decl_def &fun, const std::string &scalar_t_name, std::ostream &out)
void operator()(const break_continue_statement &st) const
void generate_validate_var_decls(const std::vector< var_decl > decls, int indent, std::ostream &o)
void operator()(const int_var_decl &x) const
var_size_validating_visgen var_size_validator_
void operator()(const unit_vector_var_decl &x) const
void operator()(const matrix_var_decl &x) const
void operator()(const vector_var_decl &x) const
void operator()(const positive_ordered_var_decl &x) const
void operator()(const simplex_var_decl &x) const
bool is_nil(const expression &e)
Return true if the specified expression is nil.
void generate_validate_transformed_params(const std::vector< var_decl > &vs, int indent, std::ostream &o)
void operator()(const nil &) const
bool operator()(const assgn &st) const
void operator()(const positive_ordered_var_decl &x) const
var_decl_t decl_
The variable declaration variant type.
void operator()(const simplex_var_decl &x) const
void generate_constrained_param_names_method(const program &prog, std::ostream &o)
void operator()(const positive_ordered_var_decl &x) const
const std::string MINOR_VERSION
Minor version number for Stan package.
void generate_init(const T &x) const
void operator()(const unit_vector_var_decl &x) const
void generate_validate_var_decl(const var_decl &decl, int indent, std::ostream &o)
void operator()(const int_var_decl &x) const
void operator()(const corr_matrix_var_decl &x) const
std::pair< std::vector< var_decl >, std::vector< statement > > derived_data_decl_
Transformed data block.
void operator()(const vector_var_decl &x) const
bool is_discrete() const
Return true if the distribution is discrete.
void operator()(const matrix_var_decl &x) const
void operator()(const row_vector_var_decl &x) const
void operator()(const unit_vector_var_decl &x) const
AST structure for holding an upper-bound index.
Structure to hold the declaration of a unit vector.
void generate_printable(const printable &p, std::ostream &o)
AST structure for representing all legal indexes.
std::pair< std::vector< var_decl >, std::vector< statement > > generated_decl_
Generated quantities block.
void operator()(const cholesky_corr_var_decl &x) const
void generate_typedefs(std::ostream &o)
void operator()(const unit_vector_var_decl &x) const
void operator()(const corr_matrix_var_decl &x) const
void generate_indexed_expr_user(const std::string &expr, const std::vector< expression > indexes, base_expr_type base_type, std::ostream &o)
void operator()(const double_var_decl &x) const
write_array_visgen(std::ostream &o)
bool ends_with(const std::string &suffix, const std::string &s)
Returns true if the specified suffix appears at the end of the specified string.
void generate_truncation(const sample &x, bool is_user_defined, const std::string &prob_fun) const
void operator()(const multi_idx &i) const
void operator()(const unit_vector_var_decl &x) const
void operator()(const ordered_var_decl &x) const
void operator()(const int_var_decl &x) const
bool operator()(const increment_log_prob_statement &t) const
void generate_functions(const std::vector< function_decl_def > &funs, std::ostream &out)
void operator()(const int_var_decl &x) const
void operator()(const cholesky_factor_var_decl &x) const
const std::string EOL2("\")
bool is_user_defined_prob_function(const std::string &name, const expression &variate, const std::vector< expression > ¶ms)
Return true if a probability function with the specified name, random variate and parameters is user ...
void operator()(const ordered_var_decl &x) const
bool lhs_var_occurs_on_rhs() const
Return true if the variable being assigned is a subexpression of the value expression.
void operator()(const row_vector_var_decl &x) const
void operator()(const omni_idx &i) const
std::vector< idx > idxs_
Position(s) in variable being assigned.
void generate_quoted_string(const std::string &s, std::ostream &o)
Print a the specified string to the specified output stream, wrapping in double quotes (") and replac...
void operator()(const lb_idx &i) const
void generate_version_comment(std::ostream &o)
void operator()(const unit_vector_var_decl &x) const
void operator()(const simplex_var_decl &x) const
void operator()(const vector_var_decl &x) const
std::vector< expression > args_
The sequence of parameters for the distribution.
AST variant structure for indexes, holding any of a unary, multi, omni, lower-bound, upper-bound, or lower- and upper-bound index.
const int VOID_T
Void type.
void operator()(const expression &e) const
void operator()(const int_var_decl &x) const
std::size_t begin_line_
The line in the source code where the statement begins.
void operator()(const cov_matrix_var_decl &x) const
void generate_param_names_array(const std::vector< expression > &matrix_dims, const std::string &name, const std::vector< expression > &dims) const
void operator()(const double_var_decl &x) const
void operator()(const cov_matrix_var_decl &x) const
void operator()(const simplex_var_decl &x) const
static void print_quoted_expression(std::ostream &o, const expression &e)
void operator()(const simplex_var_decl &x) const
void suppress_warning(const std::string &indent, const std::string &var_name, std::ostream &o)
void generate_constructor(const program &prog, const std::string &model_name, std::ostream &o)
void operator()(const cov_matrix_var_decl &x) const
unconstrained_param_names_visgen(std::ostream &o)
std::string name_
Name of the variable.
void operator()(const vector_var_decl &x) const
const std::string EOL("\)
Structure to hold a matrix variable declaration.
void operator()(const for_statement &x) const
void operator()(const positive_ordered_var_decl &x) const
void operator()(const cholesky_factor_var_decl &x) const
void generate_using(const std::string &type, std::ostream &o)
void generate_begin_for_dims(const std::vector< expression > &dims) const
void generate_expression(const expression &e, std::ostream &o)
Write the code generated by the specified expression to the specified output stream.
void operator()(const matrix_var_decl &x) const
expression N_
Number of columns.
void generate_statement(const statement &s, int indent, std::ostream &o, bool include_sampling, bool is_var_context, bool is_fun_return)
base_expr_type base_type_
Base type for variable.
expression return_value_
The value returned.
void operator()(const cholesky_factor_var_decl &x) const
void generate_type(const std::string &type, size_t num_dims) const
void operator()(const simplex_var_decl &x) const
void generate_init_method(const std::vector< var_decl > &vs, std::ostream &o)
Structure to hold a Cholesky factor variable declaration.
void operator()(const int_var_decl &x) const
std::pair< std::vector< var_decl >, std::vector< statement > > derived_decl_
Transformed parameters block.
void operator()(const lub_idx &i) const
void operator()(const corr_matrix_var_decl &x) const
expression K_
Simplex size.
void operator()(const ub_idx &i) const
expression rhs_
Value being assigned to left hand side variable at indexing position.
void generate_located_statements(const std::vector< statement > &ss, int indent, std::ostream &o, bool include_sampling, bool is_var_context, bool is_fun_return)
void operator()(const assignment &x) const
void operator()(const vector_var_decl &x) const
void operator()(const double_var_decl &x) const
bool operator()(const expression &st) const
void generate_end_class_decl(std::ostream &o)
void operator()(const corr_matrix_var_decl &x) const
expression lb_
Lower bound.
idx_user_visgen(std::ostream &o)
void operator()(const double_var_decl &x) const
void generate_initialize_array_bounded(const D &x, const std::string &base_type, const std::string &read_fun_prefix, const std::vector< expression > &dim_args) const
void operator()(const unit_vector_var_decl &x) const
base_expr_type base_type_
The base expression type.
AST structure for holding a lower-bound index.
printable_t printable_
The stored printable object.
void generate_includes(std::ostream &o)
bool operator()(const for_statement &st) const
void operator()(const nil &) const
const int INT_T
Integer type.
Structure to hold a column vector variable declaration.
void operator()(const cholesky_corr_var_decl &x) const
expression N_
Number of columns.
std::string name_
Name of the argument variable.
std::vector< expression > conditions_
The sequence of conditions (parallel with bodies).
void operator()(const row_vector_var_decl &x) const
void operator()(const double_var_decl &x) const
void operator()(const positive_ordered_var_decl &x) const
void operator()(const cholesky_factor_var_decl &x) const
void generate_function_arguments(const function_decl_def &fun, bool is_rng, bool is_lp, bool is_log, std::ostream &out)
void operator()(const vector_var_decl &x) const
void operator()(const row_vector_var_decl &x) const
std::vector< arg_decl > arg_decls_
Sequence of argument declarations.
statement statement_
The body of the for loop.
void generate_functor_arguments(const function_decl_def &fun, bool is_rng, bool is_lp, bool is_log, std::ostream &out)
void operator()(const simplex_var_decl &x) const
void operator()(const matrix_var_decl &x) const
The variant structure to hold a variable declaration.
void operator()(const cov_matrix_var_decl &x) const
variable lhs_var_
The variable being assigned.
void generate_increment(expression M, expression N, std::vector< expression > dims) const
void operator()(const row_vector_var_decl &x) const
void operator()(const double_var_decl &x) const
expression M_
Number of rows in the column vector (its size).
void operator()(const cholesky_factor_var_decl &x) const
void operator()(const positive_ordered_var_decl &x) const
void generate_try(int indent, std::ostream &o)
Structure to hold a correlation matrix variable declaration.
bool operator()(const reject_statement &st) const
void operator()(const row_vector_var_decl &x) const
AST node for representing while statements.
void operator()(const matrix_var_decl &x) const
void operator()(const simplex_var_decl &x) const
void operator()(const corr_matrix_var_decl &x) const
expression expr_
The random variable.
void operator()(const matrix_var_decl &x) const
void operator()(const row_vector_var_decl &x) const
generate_init_vars_visgen(int indent, std::ostream &o)
void operator()(const nil &) const
void operator()(const positive_ordered_var_decl &x) const
void operator()(const matrix_var_decl &x) const
void generate_function_functor(const function_decl_def &fun, std::ostream &out)
void operator()(const row_vector_var_decl &x) const
void operator()(const nil &) const
void generate_name_dims(const std::string name, size_t num_dims) const
void operator()(const nil &) const
void generate_initialize_array(const std::string &var_type, const std::string &read_type, const std::vector< expression > &read_args, const std::string &name, const std::vector< expression > &dims) const
void operator()(const ordered_var_decl &x) const
std::vector< expression > dims_
Sequence of expressions for dimensions.
void operator()(const multi_idx &i) const
void generate_indexed_expr(const std::string &expr, const std::vector< expression > indexes, base_expr_type base_type, size_t e_num_dims, bool user_facing, std::ostream &o)
void generate_eigen_index_expression(const expression &e, std::ostream &o)
A printable object is either an expression or a string.
expression low_
Lower bound of range with nil value if only upper bound.
void operator()(const row_vector_var_decl &x) const
std::string name_
Name of the variable.
void operator()(const corr_matrix_var_decl &x) const
void generate_buffer_loop(const std::string &base_type, const std::string &name, const std::vector< expression > &dims, const expression &dim1=expression(), const expression &dim2=expression(), int indent=2U) const
void generate_function_name(const function_decl_def &fun, std::ostream &out)
void generate_initialize_array_bounded(const D &x, const std::string &base_type, const std::string &read_fun_prefix, const std::vector< expression > &dim_args) const
void generate_dims_array(const std::vector< expression > &matrix_dims_exprs, const std::vector< expression > &array_dims_exprs) const
AST node for the no-operation statement.
void operator()(const corr_matrix_var_decl &x) const
void generate_check_double(const std::string &name, size_t) const
void operator()(const unit_vector_var_decl &x) const
void operator()(const cholesky_corr_var_decl &x) const
void operator()(const cholesky_corr_var_decl &x) const
void generate_end_namespace(std::ostream &o)
void operator()(const vector_var_decl &x) const
void operator()(const cholesky_corr_var_decl &x) const
expression expr_
Value being assigned, which appears on the right hand side of the assignment.
bool operator()(const break_continue_statement &st) const
void operator()(const nil &) const
An integer variable declaration and optional definition.
void operator()(const double_var_decl &x) const
constrained_param_names_visgen(std::ostream &o)
void generate_function_inline_return_type(const function_decl_def &fun, const std::string &scalar_t_name, int indent, std::ostream &out)
void operator()(const cholesky_corr_var_decl &x) const
void operator()(const vector_var_decl &x) const
const int VECTOR_T
Column vector type; scalar type is real.
void operator()(const increment_log_prob_statement &x) const
void generate_idxs(const std::vector< idx > &idxs, std::ostream &o)
void generate_initializer(std::ostream &o, const std::string &base_type, const std::vector< expression > &dims, const expression &type_arg1=expression(), const expression &type_arg2=expression())
void generate_type(const std::string &base_type, const std::vector< expression > &, size_t end, std::ostream &o)
void operator()(const ordered_var_decl &x) const
void write_array(const std::string &name, const std::vector< expression > &arraydims, const std::vector< expression > &matdims) const
Structure to hold the declaration of an ordered vector.
void operator()(const cov_matrix_var_decl &x) const
void generate_local_var_decls(const std::vector< var_decl > &vs, int indent, std::ostream &o, bool is_var_context, bool is_fun_return)
dump_member_var_visgen(std::ostream &o)
void operator()(const cholesky_corr_var_decl &x) const
expression def_
Definition for variable (nil if undefined).
void operator()(const double_var_decl &x) const
void generate_destructor(const std::string &model_name, std::ostream &o)
idx_t idx_
The index variant object.
void operator()(const nil &) const
void generate_member_var_decls_all(const program &prog, std::ostream &out)
void generate_catch_throw_located(int indent, std::ostream &o)
void operator()(const unit_vector_var_decl &x) const
void operator()(const int_var_decl &x) const
void operator()(const cov_matrix_var_decl &x) const
write_param_names_visgen(std::ostream &o)
bool operator()(const conditional_statement &st) const
void operator()(const cholesky_factor_var_decl &x) const
void operator()(const corr_matrix_var_decl &x) const
void generate_init_args(const std::string &type, const std::vector< expression > &ctor_args, const std::vector< expression > &dims, size_t dim) const
expression K_
Positive rdered vector size.
std::string name_
Name of the function.
AST node for the return statement.
void generate_local_var_init_nan(const std::vector< var_decl > &vs, int indent, std::ostream &o, bool is_var_context, bool is_fun_return)
void operator()(const row_vector_var_decl &x) const
void operator()(const omni_idx &i) const
void operator()(const row_vector_var_decl &x) const
generic visitor with output for extension
void operator()(const nil &) const
void operator()(const corr_matrix_var_decl &x) const
void operator()(const matrix_var_decl &x) const
bool is_void() const
Return true if this type is void.
void operator()(const cov_matrix_var_decl &x) const
void operator()(const expression &x) const
void operator()(const unit_vector_var_decl &x) const
void operator()(const lub_idx &i) const
void operator()(const cov_matrix_var_decl &x) const
void operator()(const corr_matrix_var_decl &x) const
void generate_propto_default_function_body(const function_decl_def &fun, std::ostream &out)
void operator()(const vector_var_decl &x) const
void operator()(const corr_matrix_var_decl &x) const
void operator()(const corr_matrix_var_decl &x) const
void generate_initialize_array(const std::string &var_type, const std::string &read_type, const std::vector< expression > &read_args, const std::string &name, const std::vector< expression > &dims) const
AST node for a complete Stan program.
generate_local_var_init_nan_visgen(bool is_var_context, int indent, std::ostream &o)
void operator()(const positive_ordered_var_decl &x) const
expr_type arg_type_
Type of the argument variable.
var_size_validating_visgen(std::ostream &o, const std::string &stage)
const std::string MAJOR_VERSION
Major version number for Stan package.
void operator()(const cholesky_factor_var_decl &x) const
void operator()(const int_var_decl &x) const
expression log_prob_
Expression for the quantity with which to increment the target log density.
void generate_var_resizing(const std::vector< var_decl > &vs, std::ostream &o)
AST node for a function declaration and definition including return type name, arguments, and body.
void operator()(const matrix_var_decl &x) const
void operator()(const ordered_var_decl &x) const
statement body_
The loop body.
expression M_
Number of rows.
void operator()(const row_vector_var_decl &x) const
Node for storing binary operations consisting of an operation and left and right arguments.
const bool is_var_context_
void operator()(const nil &) const
void generate_public_decl(std::ostream &o)
void operator()(const cov_matrix_var_decl &x) const
void operator()(const corr_matrix_var_decl &x) const
The nil structure used as a placeholder for undefined or empty values in several structures.
AST node for representing a for statement.
const std::string INDENT2(" ")
void operator()(const nil &) const
void operator()(const positive_ordered_var_decl &x) const
set_param_ranges_visgen(std::ostream &o)
const int MATRIX_T
Matrix type; scalar type is real.
void generate_include(const std::string &lib_name, std::ostream &o)
void operator()(const vector_var_decl &x) const
const std::vector< expression > EMPTY_EXP_VECTOR(0)
void generate_arg_decl(bool gen_const, bool gen_ref, const arg_decl &decl, const std::string &scalar_t_name, std::ostream &out)
void generate_dims_loop_fwd(const std::vector< expression > &dims, int indent=2U) const
void generate_located_statement(const statement &s, int indent, std::ostream &o, bool include_sampling, bool is_var_context, bool is_fun_return)
void operator()(const reject_statement &ps) const
void operator()(const unit_vector_var_decl &x) const
void generate_start_namespace(std::string name, std::ostream &o)
expression M_
Number of rows.
void operator()(const unit_vector_var_decl &x) const
void generate_bare_type(const expr_type &t, const std::string &scalar_t_name, std::ostream &out)
void generate_increment(std::vector< expression > dims) const
void operator()(const double_var_decl &x) const
init_local_var_visgen(bool declare_vars, bool is_var_context, std::ostream &o)
void generate_void_statement(const std::string &name) const
void operator()(const simplex_var_decl &x) const
void operator()(const cov_matrix_var_decl &x) const
void operator()(const ordered_var_decl &x) const
void operator()(const cholesky_corr_var_decl &x) const
void operator()(const row_vector_var_decl &x) const
expression K_
Number of rows and columns.
void generate_param_names_array(const std::vector< expression > &matrix_dims, const std::string &name, const std::vector< expression > &dims) const
AST node for conditional statements.
std::vector< printable > printables_
Sequence of objects to print in output message.
write_array_vars_visgen(std::ostream &o)
bool is_user_defined(const fun &fx)
Return true if the specified function was declared in the functions block.
statement body_
Body of the function.
void operator()(const ub_idx &i) const
AST node for assignment statements.
expression condition_
The loop condition.
local_var_decl_visgen(int indents, bool is_var_context, bool is_fun_return, std::ostream &o)
std::vector< var_decl > parameter_decl_
Parameters block.
void operator()(const int_var_decl &x) const
void generate_class_decl(const std::string &model_name, std::ostream &o)
void operator()(const while_statement &x) const
void operator()(const cholesky_factor_var_decl &x) const
void generate_function_template_parameters(const function_decl_def &fun, bool is_rng, bool is_lp, bool is_log, std::ostream &out)
void generate_validate_positive(const std::string &var_name, const expression &expr, std::ostream &o)
void operator()(const ordered_var_decl &x) const
void operator()(const row_vector_var_decl &x) const