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>
31 const std::string& scalar_t_name,
35 const std::string
EOL(
"\n");
36 const std::string
EOL2(
"\n\n");
37 const std::string
INDENT(
" ");
43 return !
is_nil(x.range_.low_.expr_) && !
is_nil(x.range_.high_.expr_);
47 return is_nil(x.range_.low_.expr_) && !
is_nil(x.range_.high_.expr_);
51 return !
is_nil(x.range_.low_.expr_) &&
is_nil(x.range_.high_.expr_);
62 for (
size_t k = 0; k < indent; ++k)
70 o <<
"(void) " << name <<
"; // dummy to suppress unused var warning";
78 explicit visgen(std::ostream& o) : o_(o) { }
83 o <<
"namespace " << name <<
"_namespace {" <<
EOL2;
87 o <<
"} // namespace" <<
EOL2;
93 o <<
"// " << msg <<
EOL;
109 for (
size_t i = 0; i < s.size(); ++i) {
110 o << ((s[i] ==
'"') ?
'\'' : s[i]);
116 const std::vector<expression> indexes,
119 static const bool user_facing =
true;
121 if (indexes.size() == 0)
return;
123 for (
size_t i = 0; i < indexes.size(); ++i) {
124 if (i > 0) o <<
", ";
130 template <
bool isLHS>
132 const std::vector<expression> indexes,
141 size_t ai_size = indexes.size();
147 if (ai_size <= (e_num_dims + 1) || base_type !=
MATRIX_T) {
148 for (
size_t n = 0; n < ai_size; ++n)
149 o << (isLHS ?
"get_base1_lhs(" :
"get_base1(");
151 for (
size_t n = 0; n < ai_size; ++n) {
156 o <<
',' << (n+1) <<
')';
159 for (
size_t n = 0; n < ai_size - 1; ++n)
160 o << (isLHS ?
"get_base1_lhs(" :
"get_base1(");
162 for (
size_t n = 0; n < ai_size - 2; ++n) {
167 o <<
',' << (n+1) <<
')';
175 o <<
',' << (ai_size-1U) <<
')';
180 const std::vector<expression>& ,
183 for (
size_t i = 0; i < end; ++i) o <<
"std::vector<";
185 for (
size_t i = 0; i < end; ++i) {
191 void generate_idxs(const std::vector<idx>& idxs,
193 void generate_idxs_user(const std::vector<idx>& idxs,
196 struct expression_visgen : public visgen {
197 const bool user_facing_;
199 explicit expression_visgen(std::ostream& o, bool user_facing, bool is_var)
201 user_facing_(user_facing),
204 void operator()(nil const& /*x*/) const {
207 void operator()(const int_literal& n) const { o_ << n.val_; }
208 void operator()(const double_literal& x) const {
209 std::string num_str = boost::lexical_cast<std::string>(x.val_);
211 if (num_str.find_first_of("eE.") == std::string::npos)
212 o_ << ".0"; // trailing 0 to ensure C++ makes it a double
214 void operator()(const array_literal& x) const {
215 o_ << "stan::math::new_array<";
216 generate_type("foobar",
221 for (size_t i = 0; i < x.args_.size(); ++i) {
223 generate_expression(x.args_[i], o_);
228 void operator()(const variable& v) const { o_ << v.name_; }
229 void operator()(int n) const { // NOLINT
230 o_ << static_cast<long>(n); // NOLINT
232 void operator()(double x) const { o_ << x; }
233 void operator()(const std::string& x) const { o_ << x; } // identifiers
234 void operator()(const index_op& x) const {
235 std::stringstream expr_o;
236 generate_expression(x.expr_, expr_o);
237 std::string expr_string = expr_o.str();
238 std::vector<expression> indexes;
239 size_t e_num_dims = x.expr_.expression_type().num_dims_;
240 base_expr_type base_type = x.expr_.expression_type().base_type_;
241 for (size_t i = 0; i < x.dimss_.size(); ++i)
242 for (size_t j = 0; j < x.dimss_[i].size(); ++j)
243 indexes.push_back(x.dimss_[i][j]); // wasteful copy, could use refs
244 generate_indexed_expr<false>(expr_string, indexes, base_type,
245 e_num_dims, user_facing_, o_);
247 void operator()(const index_op_sliced& x) const {
248 if (x.idxs_.size() == 0) {
249 generate_expression(x.expr_, user_facing_, o_);
253 generate_expression(x.expr_, user_facing_, o_);
254 generate_idxs_user(x.idxs_, o_);
257 o_ << "stan::model::rvalue(";
258 generate_expression(x.expr_, o_);
260 generate_idxs(x.idxs_, o_);
263 bool user_facing = true;
264 generate_expression(x.expr_, user_facing, o_);
268 void operator()(const integrate_ode& fx) const {
269 o_ << (fx.integration_function_name_ == "integrate_ode"
270 ? "integrate_ode_rk45"
271 : fx.integration_function_name_)
273 << fx.system_function_name_
276 generate_expression(fx.y0_, o_);
279 generate_expression(fx.t0_, o_);
282 generate_expression(fx.ts_, o_);
285 generate_expression(fx.theta_, o_);
288 generate_expression(fx.x_, o_);
291 generate_expression(fx.x_int_, o_);
292 o_ << ", pstream__)";
294 void operator()(const integrate_ode_control& fx) const {
295 o_ << fx.integration_function_name_
297 << fx.system_function_name_
300 generate_expression(fx.y0_, o_);
303 generate_expression(fx.t0_, o_);
306 generate_expression(fx.ts_, o_);
309 generate_expression(fx.theta_, o_);
312 generate_expression(fx.x_, o_);
315 generate_expression(fx.x_int_, o_);
316 o_ << ", pstream__, ";
318 generate_expression(fx.rel_tol_, o_);
321 generate_expression(fx.abs_tol_, o_);
324 generate_expression(fx.max_num_steps_, o_);
327 void operator()(const fun& fx) const {
328 // first test if short-circuit op (binary && and || applied to
329 // primitives; overloads are eager, not short-circuiting)
330 if (fx.name_ == "logical_or" || fx.name_ == "logical_and") {
331 o_ << "(primitive_value(";
332 boost::apply_visitor(*this, fx.args_[0].expr_);
333 o_ << ") " << ((fx.name_ == "logical_or") ? "||" : "&&")
334 << " primitive_value(";
335 boost::apply_visitor(*this, fx.args_[1].expr_);
339 o_ << fx.name_ << '(
';
340 for (size_t i = 0; i < fx.args_.size(); ++i) {
341 if (i > 0) o_ << ',
';
342 boost::apply_visitor(*this, fx.args_[i].expr_);
344 if (fx.args_.size() > 0
345 && (has_rng_suffix(fx.name_) || has_lp_suffix(fx.name_)))
347 if (has_rng_suffix(fx.name_))
349 if (has_lp_suffix(fx.name_))
350 o_ << "lp__, lp_accum__";
351 if (is_user_defined(fx)) {
352 if (fx.args_.size() > 0
353 || has_rng_suffix(fx.name_)
354 || has_lp_suffix(fx.name_))
362 void operator()(const conditional_op& expr) const {
363 bool types_prim_match = (expr.type_.is_primitive()
364 && expr.type_.base_type_ == INT_T)
365 || (expr.type_.is_primitive()
366 && (expr.true_val_.expression_type()
367 == expr.false_val_.expression_type()));
368 bool types_prim_mismatch = !types_prim_match
369 && expr.type_.is_primitive();
371 boost::apply_visitor(*this, expr.cond_.expr_);
373 if (types_prim_match) {
374 boost::apply_visitor(*this, expr.true_val_.expr_);
375 } else if (types_prim_mismatch) {
377 boost::apply_visitor(*this, expr.true_val_.expr_);
380 o_ << "stan::math::promote_scalar<"
381 << (is_var_ ? "T__" : "double")
383 boost::apply_visitor(*this, expr.true_val_.expr_);
387 if (types_prim_match) {
388 boost::apply_visitor(*this, expr.false_val_.expr_);
389 } else if (types_prim_mismatch) {
391 boost::apply_visitor(*this, expr.false_val_.expr_);
394 o_ << "stan::math::promote_scalar<"
395 << (is_var_ ? "T__" : "double")
397 boost::apply_visitor(*this, expr.false_val_.expr_);
403 void operator()(const binary_op& expr) const {
405 boost::apply_visitor(*this, expr.left.expr_);
406 o_ << ' ' << expr.op << ' ';
407 boost::apply_visitor(*this, expr.right.expr_);
410 void operator()(const unary_op& expr) const {
411 o_ << expr.op << '(
';
412 boost::apply_visitor(*this, expr.subject.expr_);
415 }; // close struct expression_visgen
417 void generate_expression(const expression& e,
421 expression_visgen vis(o, user_facing, is_var);
422 boost::apply_visitor(vis, e.expr_);
425 void generate_expression(const expression& e,
428 static const bool is_var = false; // default value
429 expression_visgen vis(o, user_facing, is_var);
430 boost::apply_visitor(vis, e.expr_);
433 void generate_expression(const expression& e, std::ostream& o) {
434 static const bool user_facing = false; // default value
435 static const bool is_var = false; // default value
436 generate_expression(e, user_facing, is_var, o);
439 static void print_string_literal(std::ostream& o,
440 const std::string& s) {
442 for (size_t i = 0; i < s.size(); ++i) {
443 if (s[i] == '"' || s[i] == '\\
' || s[i] == '\
'' )
452 std::stringstream ss;
473 o <<
"using " << type <<
";" <<
EOL;
477 o <<
"using namespace " << ns <<
";" <<
EOL;
494 const std::string& abbrev,
496 o <<
"typedef" <<
" " << type <<
" " << abbrev <<
";" <<
EOL;
510 o <<
"#include" <<
" " <<
"<" << lib_name <<
">" <<
EOL;
519 o <<
"// Code generated by Stan version "
525 o <<
"class " << model_name <<
" : public prob_grad {" <<
EOL;
529 o <<
"}; // model" <<
EOL2;
535 o <<
"static_cast<Eigen::VectorXd::Index>(";
541 const std::string& base_type,
542 const std::vector<expression>& dims,
545 for (
size_t i = 0; i < dims.size(); ++i) {
559 }
else if (!
is_nil(type_arg2.expr_)) {
566 for (
size_t i = 0; i < dims.size(); ++i)
573 const std::string& stage,
574 const std::string& var_name,
575 const std::string& base_type,
576 const std::vector<expression>& dims,
582 <<
"context__.validate_dims("
583 <<
'"' << stage <<
'"'
584 <<
", " <<
'"' << var_name <<
'"'
585 <<
", " <<
'"' << base_type <<
'"'
586 <<
", context__.to_vec(";
587 for (
size_t i = 0; i < dims.size(); ++i) {
592 if (dims.size() > 0) o <<
",";
667 o <<
"validate_non_negative_index(\"" << var_name <<
"\", ";
675 const std::string& var_name,
676 const std::string& base_type,
677 const std::vector<expression>& dims,
681 for (
size_t i = 0; i < dims.size(); ++i)
690 << var_name <<
" = ";
744 for (
size_t i = 0; i < vs.size(); ++i)
745 boost::apply_visitor(vis, vs[i].decl_);
757 declare_vars_(declare_vars),
760 template <
typename D>
762 const std::string& base_type,
763 const std::string& read_fun_prefix,
764 const std::vector<expression>& dim_args)
const {
765 std::vector<expression> read_args;
766 std::string read_fun(read_fun_prefix);
769 read_args.push_back(x.range_.low_);
770 read_args.push_back(x.range_.high_);
773 read_args.push_back(x.range_.low_);
776 read_args.push_back(x.range_.high_);
778 for (
size_t i = 0; i < dim_args.size(); ++i)
779 read_args.push_back(dim_args[i]);
789 std::vector<expression> read_args;
791 is_var_ ?
"T__" :
"double",
792 "scalar", read_args);
795 std::vector<expression> read_args;
796 read_args.push_back(x.
M_);
800 "<T__,Eigen::Dynamic,1> "
802 "vector", read_args);
805 std::vector<expression> read_args;
806 read_args.push_back(x.
N_);
810 "<T__,1,Eigen::Dynamic> "
812 "row_vector", read_args);
815 std::vector<expression> read_args;
816 read_args.push_back(x.
M_);
817 read_args.push_back(x.
N_);
821 "<T__,Eigen::Dynamic,Eigen::Dynamic> "
823 "matrix", read_args);
826 std::vector<expression> read_args;
827 read_args.push_back(x.
K_);
830 "<T__,Eigen::Dynamic,1> "
835 std::vector<expression> read_args;
836 read_args.push_back(x.
K_);
839 "<T__,Eigen::Dynamic,1> "
844 std::vector<expression> read_args;
845 read_args.push_back(x.
K_);
848 "<T__,Eigen::Dynamic,1> "
853 std::vector<expression> read_args;
854 read_args.push_back(x.
K_);
857 "<T__,Eigen::Dynamic,1> "
859 "positive_ordered", read_args,
863 std::vector<expression> read_args;
864 read_args.push_back(x.
M_);
865 read_args.push_back(x.
N_);
868 "<T__,Eigen::Dynamic,Eigen::Dynamic> "
870 "cholesky_factor", read_args,
874 std::vector<expression> read_args;
875 read_args.push_back(x.
K_);
878 "<T__,Eigen::Dynamic,Eigen::Dynamic> "
880 "cholesky_corr", read_args, x.
name_, x.
dims_);
884 std::vector<expression> read_args;
885 read_args.push_back(x.
K_);
888 "<T__,Eigen::Dynamic,Eigen::Dynamic> "
893 std::vector<expression> read_args;
894 read_args.push_back(x.
K_);
897 "<T__,Eigen::Dynamic,Eigen::Dynamic> "
902 const std::string& read_type,
903 const std::vector<expression>& read_args,
904 const std::string& name,
905 const std::vector<expression>& dims)
909 for (
size_t i = 0; i < dims.size(); ++i)
o_ <<
"vector<";
911 for (
size_t i = 0; i < dims.size(); ++i)
o_ <<
"> ";
912 if (dims.size() == 0)
o_ <<
" ";
913 o_ << name <<
";" <<
EOL;
916 if (dims.size() == 0) {
922 o_ << name <<
" = in__." << read_type <<
"_constrain(";
923 for (
size_t j = 0; j < read_args.size(); ++j) {
924 if (j > 0)
o_ <<
",";
927 if (read_args.size() > 0)
936 o_ << name <<
" = in__." << read_type <<
"_constrain(";
937 for (
size_t j = 0; j < read_args.size(); ++j) {
938 if (j > 0)
o_ <<
",";
945 std::string name_dims(name);
946 for (
size_t i = 0; i < dims.size(); ++i) {
948 o_ <<
"size_t dim_" << name <<
"_" << i <<
"__ = ";
952 if (i < dims.size() - 1) {
954 o_ << name_dims <<
".resize(dim" <<
"_"
955 << name <<
"_" << i <<
"__);"
957 name_dims.append(
"[k_").append(
to_string(i)).append(
"__]");
961 if (i == dims.size() - 1) {
962 o_ << name_dims <<
".reserve(dim_" << name
963 <<
"_" << i <<
"__);" <<
EOL;
967 o_ <<
"for (size_t k_" << i <<
"__ = 0;"
968 <<
" k_" << i <<
"__ < dim_" << name <<
"_" << i <<
"__;"
969 <<
" ++k_" << i <<
"__) {" <<
EOL;
972 if (i == dims.size() - 1) {
974 o_ <<
"if (jacobian__)" <<
EOL;
978 o_ << name_dims <<
".push_back(in__."
979 << read_type <<
"_constrain(";
980 for (
size_t j = 0; j < read_args.size(); ++j) {
981 if (j > 0)
o_ <<
",";
984 if (read_args.size() > 0)
994 o_ << name_dims <<
".push_back(in__."
995 << read_type <<
"_constrain(";
996 for (
size_t j = 0; j < read_args.size(); ++j) {
997 if (j > 0)
o_ <<
",";
1004 for (
size_t i = dims.size(); i > 0; --i) {
1018 <<
"stan::io::reader<"
1019 << (is_var ?
"T__" :
"double")
1020 <<
"> in__(params_r__,params_i__);" <<
EOL2;
1022 for (
size_t i = 0; i < vs.size(); ++i)
1023 boost::apply_visitor(vis, vs[i].decl_);
1030 o <<
"public:" <<
EOL;
1034 o <<
"private:" <<
EOL;
1047 for (
size_t i = 0; i < dims.size(); ++i) {
1049 o_ <<
"for (int k" << i <<
"__ = 0;"
1050 <<
" k" << i <<
"__ < ";
1053 o_ <<
" ++k" << i <<
"__) {" <<
EOL;
1057 for (
size_t i = 0; i < dims_size; ++i) {
1064 size_t dims_size)
const {
1066 for (
size_t i = 0; i < dims_size; ++i)
1067 o_ <<
"[k" << i <<
"__]";
1070 template <
typename T>
1072 if (!(x.range_.has_low() || x.range_.has_high()))
1075 if (x.range_.has_low()) {
1077 o_ <<
"check_greater_or_equal(function__,";
1086 if (x.range_.has_high()) {
1088 o_ <<
"check_less_or_equal(function__,";
1114 template <
typename T>
1116 const std::string& type_name)
const {
1119 o_ <<
"stan::math::check_" << type_name <<
"(function__,";
1159 boost::apply_visitor(vis, decl.
decl_);
1165 for (
size_t i = 0; i < decls.size(); ++i)
1218 size_t size)
const {
1221 for (
size_t i = 0; i < size; ++i) {
1228 for (
size_t i = 1; i < size; ++i) {
1231 o_ <<
" " << name <<
";" <<
EOL;
1239 for (
size_t i = 0; i < vs.size(); ++i)
1240 boost::apply_visitor(vis, vs[i].decl_);
1258 is_fun_return_(is_fun_return) {
1262 std::vector<expression> ctor_args;
1266 std::vector<expression> ctor_args;
1269 : (is_var_ ?
"T__" :
"double"),
1273 std::vector<expression> ctor_args;
1274 ctor_args.push_back(x.
M_);
1276 ?
"Eigen::Matrix<fun_scalar_t__,Eigen::Dynamic,1> "
1278 ?
"Eigen::Matrix<T__,Eigen::Dynamic,1> " :
"vector_d"),
1282 std::vector<expression> ctor_args;
1283 ctor_args.push_back(x.
N_);
1285 ?
"Eigen::Matrix<fun_scalar_t__,1,Eigen::Dynamic> "
1287 ?
"Eigen::Matrix<T__,1,Eigen::Dynamic> "
1292 std::vector<expression> ctor_args;
1293 ctor_args.push_back(x.
M_);
1294 ctor_args.push_back(x.
N_);
1296 ?
"Eigen::Matrix<fun_scalar_t__,"
1297 "Eigen::Dynamic,Eigen::Dynamic> "
1299 ?
"Eigen::Matrix<T__,Eigen::Dynamic,Eigen::Dynamic> "
1304 std::vector<expression> ctor_args;
1305 ctor_args.push_back(x.
K_);
1307 ?
"Eigen::Matrix<fun_scalar_t__,Eigen::Dynamic,1> "
1309 ?
"Eigen::Matrix<T__,Eigen::Dynamic,1> " :
"vector_d"),
1313 std::vector<expression> ctor_args;
1314 ctor_args.push_back(x.
K_);
1316 ?
"Eigen::Matrix<fun_scalar_t__,Eigen::Dynamic,1> "
1318 ?
"Eigen::Matrix<T__,Eigen::Dynamic,1> " :
"vector_d"),
1322 std::vector<expression> ctor_args;
1323 ctor_args.push_back(x.
K_);
1325 ?
"Eigen::Matrix<fun_scalar_t__,Eigen::Dynamic,1> "
1327 ?
"Eigen::Matrix<T__,Eigen::Dynamic,1> " :
"vector_d"),
1331 std::vector<expression> ctor_args;
1332 ctor_args.push_back(x.
K_);
1334 ?
"Eigen::Matrix<fun_scalar_t__,Eigen::Dynamic,1> "
1336 ?
"Eigen::Matrix<T__,Eigen::Dynamic,1> " :
"vector_d"),
1340 std::vector<expression> ctor_args;
1341 ctor_args.push_back(x.
M_);
1342 ctor_args.push_back(x.
N_);
1344 ?
"Eigen::Matrix<fun_scalar_t__,"
1345 "Eigen::Dynamic,Eigen::Dynamic> "
1347 ?
"Eigen::Matrix<T__,Eigen::Dynamic,Eigen::Dynamic> "
1352 std::vector<expression> ctor_args;
1353 ctor_args.push_back(x.
K_);
1354 ctor_args.push_back(x.
K_);
1356 ?
"Eigen::Matrix<T__,Eigen::Dynamic,Eigen::Dynamic> "
1361 std::vector<expression> ctor_args;
1362 ctor_args.push_back(x.
K_);
1363 ctor_args.push_back(x.
K_);
1365 ?
"Eigen::Matrix<fun_scalar_t__,"
1366 "Eigen::Dynamic,Eigen::Dynamic> "
1368 ?
"Eigen::Matrix<T__,Eigen::Dynamic,Eigen::Dynamic> "
1373 std::vector<expression> ctor_args;
1374 ctor_args.push_back(x.
K_);
1375 ctor_args.push_back(x.
K_);
1377 ?
"Eigen::Matrix<fun_scalar_t__,"
1378 "Eigen::Dynamic,Eigen::Dynamic> "
1380 ?
"Eigen::Matrix<T__,Eigen::Dynamic,Eigen::Dynamic> "
1385 size_t num_dims)
const {
1386 for (
size_t i = 0; i < num_dims; ++i)
1389 for (
size_t i = 0; i < num_dims; ++i) {
1390 if (i > 0)
o_ <<
" ";
1396 o_ <<
"(void) " << name <<
"; // dummy to suppress unused var warning";
1403 const std::vector<expression>& ctor_args,
1404 const std::vector<expression>& dims,
1406 if (dim < dims.size()) {
1409 if ((dim + 1 < dims.size()) || ctor_args.size() > 0) {
1414 }
else if (type ==
"var") {
1415 o_ <<
", DUMMY_VAR__";
1416 }
else if (type ==
"int") {
1418 }
else if (type ==
"double") {
1425 if (ctor_args.size() == 0) {
1426 if (type ==
"int") {
1428 }
else if (type ==
"double") {
1430 }
else if (type ==
"var") {
1431 o_ <<
"(DUMMY_VAR__)";
1435 }
else if (ctor_args.size() == 1) {
1439 }
else if (ctor_args.size() > 1) {
1449 const std::vector<expression>& ctor_args,
1450 const std::string& name,
1451 const std::vector<expression>& dims)
const {
1458 if (dims.size() == 0) {
1463 if (type ==
"Eigen::Matrix<T__, Eigen::Dynamic, Eigen::Dynamic> "
1464 || type ==
"Eigen::Matrix<T__, 1, Eigen::Dynamic> "
1465 || type ==
"Eigen::Matrix<T__, Eigen::Dynamic, 1> ") {
1467 o_ <<
"stan::math::fill(" << name <<
", DUMMY_VAR__);" <<
EOL;
1476 bool is_fun_return) {
1478 for (
size_t i = 0; i < vs.size(); ++i)
1479 boost::apply_visitor(vis, vs[i].decl_);
1495 declare_vars_(declare_vars),
1497 is_fun_return_(is_fun_return),
1542 template <
typename T>
1545 o_ <<
"stan::math::initialize(" << x.name_ <<
", "
1548 :
"std::numeric_limits<double>::quiet_NaN()")
1558 bool is_fun_return) {
1561 for (
size_t i = 0; i < vs.size(); ++i)
1562 boost::apply_visitor(vis, vs[i].decl_);
1577 o_ <<
"stan::math::fill(" << x.
name_
1578 <<
", std::numeric_limits<int>::min());"
1583 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
1587 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
1591 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
1595 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
1599 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
1603 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
1607 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
1611 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
1615 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
1619 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
1623 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
1627 o_ <<
"stan::math::fill(" << x.
name_ <<
",DUMMY_VAR__);" <<
EOL;
1637 " avoid seg fault on val access",
1639 for (
size_t i = 0; i < vs.size(); ++i)
1640 boost::apply_visitor(vis, vs[i].decl_);
1653 std::vector<expression> dims(x.
dims_);
1657 std::vector<expression> dims(x.
dims_);
1661 std::vector<expression> dims(x.
dims_);
1662 dims.push_back(x.
M_);
1666 std::vector<expression> dims(x.
dims_);
1667 dims.push_back(x.
K_);
1671 std::vector<expression> dims(x.
dims_);
1672 dims.push_back(x.
K_);
1676 std::vector<expression> dims(x.
dims_);
1677 dims.push_back(x.
K_);
1681 std::vector<expression> dims(x.
dims_);
1682 dims.push_back(x.
K_);
1686 std::vector<expression> dims(x.
dims_);
1687 dims.push_back(x.
N_);
1691 std::vector<expression> dims(x.
dims_);
1692 dims.push_back(x.
M_);
1693 dims.push_back(x.
N_);
1697 std::vector<expression> dims(x.
dims_);
1698 dims.push_back(x.
M_);
1699 dims.push_back(x.
N_);
1703 std::vector<expression> dims(x.
dims_);
1704 dims.push_back(x.
K_);
1705 dims.push_back(x.
K_);
1709 std::vector<expression> dims(x.
dims_);
1710 dims.push_back(x.
K_);
1711 dims.push_back(x.
K_);
1715 std::vector<expression> dims(x.
dims_);
1716 dims.push_back(x.
K_);
1717 dims.push_back(x.
K_);
1721 const std::vector<expression>& dims,
1722 size_t matrix_dims)
const {
1723 size_t non_matrix_dims = dims.size() - matrix_dims;
1725 for (
size_t k = 0; k < dims.size(); ++k) {
1727 o_ <<
"for (int i" << k <<
"__ = 0; i" << k <<
"__ < ";
1729 o_ <<
"; ++i" << k <<
"__) {" <<
EOL;
1733 o_ <<
"if (stan::math::is_uninitialized(" << name;
1734 for (
size_t k = 0; k < non_matrix_dims; ++k)
1735 o_ <<
"[i" << k <<
"__]";
1736 if (matrix_dims > 0) {
1737 o_ <<
"(i" << non_matrix_dims <<
"__";
1738 if (matrix_dims > 1)
1739 o_ <<
",i" << (non_matrix_dims + 1) <<
"__";
1742 o_ <<
")) {" <<
EOL;
1744 o_ <<
"std::stringstream msg__;" <<
EOL;
1746 o_ <<
"msg__ << \"Undefined transformed parameter: "
1748 for (
size_t k = 0; k < dims.size(); ++k) {
1750 o_ <<
" << i" << k <<
"__";
1755 o_ <<
"throw std::runtime_error(msg__.str());" <<
EOL;
1759 for (
size_t k = 0; k < dims.size(); ++k) {
1771 for (
size_t i = 0; i < vs.size(); ++i)
1772 boost::apply_visitor(vis, vs[i].decl_);
1779 o_ <<
"stan::model::index_uni(";
1784 o_ <<
"stan::model::index_multi(";
1789 o_ <<
"stan::model::index_omni()";
1792 o_ <<
"stan::model::index_min(";
1797 o_ <<
"stan::model::index_max(";
1802 o_ <<
"stan::model::index_min_max(";
1812 boost::apply_visitor(vis, i.
idx_);
1817 if (pos == idxs.size()) {
1818 o <<
"stan::model::nil_index_list()";
1820 o <<
"stan::model::cons_list(";
1861 boost::apply_visitor(vis, i.
idx_);
1865 if (idxs.size() == 0)
1868 for (
size_t i = 0; i < idxs.size(); ++i) {
1877 bool include_sampling,
bool is_var,
1878 bool is_fun_return);
1886 bool include_sampling,
1892 include_sampling_(include_sampling),
1894 is_fun_return_(is_fun_return) {
1900 o_ <<
"stan::math::assign(";
1913 o_ <<
"stan::model::assign(";
1927 o_ <<
"stan::model::deep_copy(";
1938 <<
"assigning variable "
1951 if (!include_sampling_)
return;
1954 o_ <<
"lp_accum__.add(" << prob_fun <<
"<propto__>(";
1956 for (
size_t i = 0; i < x.
dist_.
args_.size(); ++i) {
1962 if (is_user_defined)
1963 o_ <<
", pstream__";
1973 o_ <<
") lp_accum__.add(-std::numeric_limits<double>::infinity());"
1983 o_ <<
") lp_accum__.add(-std::numeric_limits<double>::infinity());"
1995 o_ <<
"lp_accum__.add(-log_diff_exp(";
1998 for (
size_t i = 0; i < x.
dist_.
args_.size(); ++i) {
2002 if (is_user_defined)
2003 o_ <<
", pstream__";
2006 for (
size_t i = 0; i < x.
dist_.
args_.size(); ++i) {
2010 if (is_user_defined)
2011 o_ <<
", pstream__";
2012 o_ <<
")));" <<
EOL;
2015 o_ <<
"lp_accum__.add(-";
2018 for (
size_t i = 0; i < x.
dist_.
args_.size(); ++i) {
2022 if (is_user_defined)
2023 o_ <<
", pstream__";
2027 o_ <<
"lp_accum__.add(-";
2030 for (
size_t i = 0; i < x.
dist_.
args_.size(); ++i) {
2034 if (is_user_defined)
2035 o_ <<
", pstream__";
2041 o_ <<
"lp_accum__.add(";
2047 size_t indent = has_local_vars ? (indent_ + 1) : indent_;
2048 if (has_local_vars) {
2052 is_var_, is_fun_return_);
2054 is_var_, is_fun_return_);
2059 is_var_, is_fun_return_);
2060 if (has_local_vars) {
2067 o_ <<
"if (pstream__) {" <<
EOL;
2068 for (
size_t i = 0; i < ps.
printables_.size(); ++i) {
2070 o_ <<
"stan_print(pstream__,";
2075 o_ <<
"*pstream__ << std::endl;" <<
EOL;
2081 o_ <<
"std::stringstream errmsg_stream__;" <<
EOL;
2082 for (
size_t i = 0; i < ps.
printables_.size(); ++i) {
2084 o_ <<
"errmsg_stream__ << ";
2089 o_ <<
"throw std::domain_error(errmsg_stream__.str());" <<
EOL;
2096 o_ <<
"stan::math::promote_scalar<fun_return_scalar_t__>(";
2110 is_var_, is_fun_return_);
2116 o_ <<
"while (as_bool(";
2118 o_ <<
")) {" <<
EOL;
2120 is_var_, is_fun_return_);
2125 for (
size_t i = 0; i < x.
conditions_.size(); ++i) {
2130 o_ <<
"if (as_bool(";
2132 o_ <<
")) {" <<
EOL;
2134 is_var_, is_fun_return_);
2139 o_ <<
" else {" <<
EOL;
2177 bool include_sampling,
2179 bool is_fun_return) {
2181 if (boost::apply_visitor(vis_is_numbered, s.
statement_)) {
2183 o <<
"current_statement_begin__ = " << s.
begin_line_ <<
";"
2194 bool include_sampling,
2196 bool is_fun_return) {
2198 for (
size_t i = 0; i < ss.size(); ++i)
2199 boost::apply_visitor(vis, ss[i].statement_);
2212 o <<
"} catch (const std::exception& e) {"
2215 o <<
"stan::lang::rethrow_located(e,current_statement_begin__);"
2220 o <<
"throw std::runtime_error"
2221 <<
"(\"*** IF YOU SEE THIS, PLEASE REPORT A BUG ***\");"
2231 bool include_sampling,
2233 bool is_fun_return) {
2236 is_var, is_fun_return);
2243 bool include_sampling,
2245 bool is_fun_return) {
2247 for (
size_t i = 0; i < ss.size(); ++i)
2249 is_var, is_fun_return);
2258 o <<
INDENT <<
"template <bool propto__, bool jacobian__, typename T__>"
2260 o <<
INDENT <<
"T__ log_prob(vector<T__>& params_r__,"
2262 o <<
INDENT <<
" vector<int>& params_i__,"
2264 o <<
INDENT <<
" std::ostream* pstream__ = 0) const {"
2269 <<
"T__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());"
2271 o <<
INDENT2 <<
"(void) DUMMY_VAR__; // suppress unused var warning"
2274 o <<
INDENT2 <<
"T__ lp__(0.0);"
2276 o <<
INDENT2 <<
"stan::math::accumulator<T__> lp_accum__;"
2280 bool is_fun_return =
false;
2293 bool include_sampling =
true;
2295 include_sampling, is_var, is_fun_return);
2300 <<
"const char* function__ = \"validate transformed params\";"
2303 <<
"(void) function__; // dummy to suppress unused var warning"
2313 is_var, is_fun_return);
2317 o <<
INDENT2 <<
"lp_accum__.add(lp__);" <<
EOL;
2318 o <<
INDENT2 <<
"return lp_accum__.sum();" <<
EOL2;
2322 <<
"template <bool propto, bool jacobian, typename T_>" <<
EOL;
2324 <<
"T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r," <<
EOL;
2325 o <<
INDENT <<
" std::ostream* pstream = 0) const {" <<
EOL;
2326 o <<
INDENT <<
" std::vector<T_> vec_params_r;" <<
EOL;
2327 o <<
INDENT <<
" vec_params_r.reserve(params_r.size());" <<
EOL;
2328 o <<
INDENT <<
" for (int i = 0; i < params_r.size(); ++i)" <<
EOL;
2329 o <<
INDENT <<
" vec_params_r.push_back(params_r(i));" <<
EOL;
2330 o <<
INDENT <<
" std::vector<int> vec_params_i;" <<
EOL;
2332 <<
" return log_prob<propto,jacobian,T_>(vec_params_r, "
2333 <<
"vec_params_i, pstream);" <<
EOL;
2344 "data initialization")) {
2348 std::vector<expression> dims = x.
dims_;
2352 <<
"vals_i__ = context__.vals_i(\"" << x.
name_ <<
"\");" <<
EOL;
2354 size_t indentation = 1;
2355 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2356 size_t dim = dims.size() - dim_up - 1U;
2359 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2363 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_"
2364 << dim <<
"__ < " << x.
name_ <<
"_limit_" << dim
2365 <<
"__; ++i_" << dim <<
"__) {" <<
EOL;
2369 for (
size_t dim = 0; dim < dims.size(); ++dim)
2370 o_ <<
"[i_" << dim <<
"__]";
2371 o_ <<
" = vals_i__[pos__++];" <<
EOL;
2372 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2379 std::vector<expression> dims = x.
dims_;
2383 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");" <<
EOL;
2385 size_t indentation = 1;
2386 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2387 size_t dim = dims.size() - dim_up - 1U;
2390 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2394 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < "
2395 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {"
2400 for (
size_t dim = 0; dim < dims.size(); ++dim)
2401 o_ <<
"[i_" << dim <<
"__]";
2402 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2403 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2410 std::vector<expression> dims = x.
dims_;
2414 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");" <<
EOL;
2419 o_ <<
INDENT2 <<
"for (size_t " <<
"i_vec__ = 0; " <<
"i_vec__ < "
2420 << x.
name_ <<
"_i_vec_lim__; ++i_vec__) {" <<
EOL;
2421 size_t indentation = 2;
2422 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2423 size_t dim = dims.size() - dim_up - 1U;
2426 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2430 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < "
2431 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {"
2436 for (
size_t dim = 0; dim < dims.size(); ++dim)
2437 o_ <<
"[i_" << dim <<
"__]";
2439 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2440 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2448 std::vector<expression> dims = x.
dims_;
2452 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");" <<
EOL;
2457 o_ <<
INDENT2 <<
"for (size_t " <<
"i_vec__ = 0; " <<
"i_vec__ < "
2458 << x.
name_ <<
"_i_vec_lim__; ++i_vec__) {" <<
EOL;
2459 size_t indentation = 2;
2460 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2461 size_t dim = dims.size() - dim_up - 1U;
2464 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2468 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < "
2469 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {"
2474 for (
size_t dim = 0; dim < dims.size(); ++dim)
2475 o_ <<
"[i_" << dim <<
"__]";
2477 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2478 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2486 std::vector<expression> dims = x.
dims_;
2490 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");" <<
EOL;
2495 o_ <<
INDENT2 <<
"for (size_t " <<
"i_vec__ = 0; " <<
"i_vec__ < "
2496 << x.
name_ <<
"_i_vec_lim__; ++i_vec__) {" <<
EOL;
2497 size_t indentation = 2;
2498 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2499 size_t dim = dims.size() - dim_up - 1U;
2502 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2506 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < "
2507 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {"
2512 for (
size_t dim = 0; dim < dims.size(); ++dim)
2513 o_ <<
"[i_" << dim <<
"__]";
2515 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2516 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2524 std::vector<expression> dims = x.
dims_;
2528 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");" <<
EOL;
2533 o_ <<
INDENT2 <<
"for (size_t " <<
"i_vec__ = 0; " <<
"i_vec__ < "
2534 << x.
name_ <<
"_i_vec_lim__; ++i_vec__) {" <<
EOL;
2535 size_t indentation = 2;
2536 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2537 size_t dim = dims.size() - dim_up - 1U;
2540 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2544 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < "
2545 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {"
2550 for (
size_t dim = 0; dim < dims.size(); ++dim)
2551 o_ <<
"[i_" << dim <<
"__]";
2553 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2554 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2562 std::vector<expression> dims = x.
dims_;
2566 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");" <<
EOL;
2571 o_ <<
INDENT2 <<
"for (size_t " <<
"i_vec__ = 0; " <<
"i_vec__ < "
2572 << x.
name_ <<
"_i_vec_lim__; ++i_vec__) {" <<
EOL;
2573 size_t indentation = 2;
2574 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2575 size_t dim = dims.size() - dim_up - 1U;
2578 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2582 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < "
2583 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {"
2588 for (
size_t dim = 0; dim < dims.size(); ++dim)
2589 o_ <<
"[i_" << dim <<
"__]";
2591 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2592 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2600 std::vector<expression> dims = x.
dims_;
2604 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");" <<
EOL;
2609 o_ <<
INDENT2 <<
"for (size_t " <<
"i_vec__ = 0; " <<
"i_vec__ < "
2610 << x.
name_ <<
"_i_vec_lim__; ++i_vec__) {" <<
EOL;
2611 size_t indentation = 2;
2612 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2613 size_t dim = dims.size() - dim_up - 1U;
2616 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2620 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < "
2621 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {"
2626 for (
size_t dim = 0; dim < dims.size(); ++dim)
2627 o_ <<
"[i_" << dim <<
"__]";
2629 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2630 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2638 std::vector<expression> dims = x.
dims_;
2641 o_ <<
INDENT2 <<
"vals_r__ = context__.vals_r(\""
2650 o_ <<
INDENT2 <<
"for (size_t " <<
"n_mat__ = 0; " <<
"n_mat__ < "
2651 << x.
name_ <<
"_n_mat_lim__; ++n_mat__) {" <<
EOL;
2652 o_ <<
INDENT3 <<
"for (size_t " <<
"m_mat__ = 0; " <<
"m_mat__ < "
2653 << x.
name_ <<
"_m_mat_lim__; ++m_mat__) {" <<
EOL;
2654 size_t indentation = 3;
2655 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2656 size_t dim = dims.size() - dim_up - 1U;
2659 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2663 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < "
2664 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {"
2669 for (
size_t dim = 0; dim < dims.size(); ++dim)
2670 o_ <<
"[i_" << dim <<
"__]";
2671 o_ <<
"(m_mat__,n_mat__)";
2672 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2673 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2683 std::vector<expression> dims = x.
dims_;
2687 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");" <<
EOL;
2693 <<
"for (size_t " <<
"n_mat__ = 0; " <<
"n_mat__ < " << x.
name_
2694 <<
"_k_mat_lim__; ++n_mat__) {" <<
EOL;
2696 <<
"for (size_t " <<
"m_mat__ = 0; " <<
"m_mat__ < " << x.
name_
2697 <<
"_k_mat_lim__; ++m_mat__) {" <<
EOL;
2698 size_t indentation = 3;
2699 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2700 size_t dim = dims.size() - dim_up - 1U;
2703 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2707 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < "
2708 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {"
2713 for (
size_t dim = 0; dim < dims.size(); ++dim)
2714 o_ <<
"[i_" << dim <<
"__]";
2715 o_ <<
"(m_mat__,n_mat__)";
2716 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2717 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2726 std::vector<expression> dims = x.
dims_;
2729 o_ <<
INDENT2 <<
"vals_r__ = context__.vals_r(\""
2741 o_ <<
INDENT2 <<
"for (size_t " <<
"n_mat__ = 0; " <<
"n_mat__ < "
2742 << x.
name_ <<
"_n_mat_lim__; ++n_mat__) {" <<
EOL;
2743 o_ <<
INDENT3 <<
"for (size_t " <<
"m_mat__ = 0; " <<
"m_mat__ < "
2744 << x.
name_ <<
"_m_mat_lim__; ++m_mat__) {" <<
EOL;
2746 size_t indentation = 3;
2747 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2748 size_t dim = dims.size() - dim_up - 1U;
2751 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2755 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < "
2756 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {"
2761 for (
size_t dim = 0; dim < dims.size(); ++dim)
2762 o_ <<
"[i_" << dim <<
"__]";
2763 o_ <<
"(m_mat__,n_mat__)";
2764 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2765 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2775 std::vector<expression> dims = x.
dims_;
2778 o_ <<
INDENT2 <<
"vals_r__ = context__.vals_r(\""
2790 o_ <<
INDENT2 <<
"for (size_t " <<
"n_mat__ = 0; " <<
"n_mat__ < "
2791 << x.
name_ <<
"_n_mat_lim__; ++n_mat__) {" <<
EOL;
2792 o_ <<
INDENT3 <<
"for (size_t " <<
"m_mat__ = 0; " <<
"m_mat__ < "
2793 << x.
name_ <<
"_m_mat_lim__; ++m_mat__) {" <<
EOL;
2795 size_t indentation = 3;
2796 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2797 size_t dim = dims.size() - dim_up - 1U;
2800 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2804 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < "
2805 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {"
2810 for (
size_t dim = 0; dim < dims.size(); ++dim)
2811 o_ <<
"[i_" << dim <<
"__]";
2812 o_ <<
"(m_mat__,n_mat__)";
2813 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2814 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2823 std::vector<expression> dims = x.
dims_;
2826 o_ <<
INDENT2 <<
"vals_r__ = context__.vals_r(\"" << x.
name_ <<
"\");"
2832 o_ <<
INDENT2 <<
"for (size_t " <<
"n_mat__ = 0; " <<
"n_mat__ < "
2833 << x.
name_ <<
"_k_mat_lim__; ++n_mat__) {" <<
EOL;
2834 o_ <<
INDENT3 <<
"for (size_t " <<
"m_mat__ = 0; " <<
"m_mat__ < "
2835 << x.
name_ <<
"_k_mat_lim__; ++m_mat__) {" <<
EOL;
2836 size_t indentation = 3;
2837 for (
size_t dim_up = 0U; dim_up < dims.size(); ++dim_up) {
2838 size_t dim = dims.size() - dim_up - 1U;
2841 o_ <<
"size_t " << x.
name_ <<
"_limit_" << dim <<
"__ = ";
2845 o_ <<
"for (size_t i_" << dim <<
"__ = 0; i_" << dim <<
"__ < "
2846 << x.
name_ <<
"_limit_" << dim <<
"__; ++i_" << dim <<
"__) {"
2851 for (
size_t dim = 0; dim < dims.size(); ++dim)
2852 o_ <<
"[i_" << dim <<
"__]";
2853 o_ <<
"(m_mat__,n_mat__)";
2854 o_ <<
" = vals_r__[pos__++];" <<
EOL;
2855 for (
size_t dim = 0; dim < dims.size(); ++dim) {
2865 const std::string& var_name,
2867 o << indent <<
"(void) "
2869 <<
" // dummy call to supress warning"
2876 for (
size_t i = 0; i < vs.size(); ++i)
2877 boost::apply_visitor(vis, vs[i].decl_);
2883 <<
INDENT <<
"~" << model_name <<
"() { }"
2896 for (
size_t i = 0; i < x.
dims_.size(); ++i) {
2898 o_ <<
"for (size_t i_" << i <<
"__ = 0; ";
2899 o_ <<
"i_" << i <<
"__ < ";
2901 o_ <<
"; ++i_" << i <<
"__) {" <<
EOL;
2905 o_ <<
"param_ranges_i__.push_back(std::pair<int, int>(";
2911 for (
size_t i = 0; i < x.
dims_.size(); ++i) {
2932 for (
size_t i = 0; i < x.
dims_.size(); ++i) {
2943 for (
size_t i = 0; i < x.
dims_.size(); ++i) {
2956 o_ <<
INDENT2 <<
"num_params_r__ += ((";
2961 o_ <<
" + 1)) / 2 + (";
2968 for (
size_t i = 0; i < x.
dims_.size(); ++i) {
2976 o_ <<
INDENT2 <<
"num_params_r__ += ((";
2980 o_ <<
" - 1)) / 2)";
2981 for (
size_t i = 0; i < x.
dims_.size(); ++i) {
2989 o_ <<
INDENT2 <<
"num_params_r__ += ((";
2993 o_ <<
" - 1)) / 2 + ";
2996 for (
size_t i = 0; i < x.
dims_.size(); ++i) {
3003 o_ <<
INDENT2 <<
"num_params_r__ += ((";
3007 o_ <<
" - 1)) / 2)";
3008 for (
size_t i = 0; i < x.
dims_.size(); ++i) {
3016 if (dims.size() == 0) {
3021 for (
size_t i = 0; i < dims.size(); ++i) {
3022 if (i > 0)
o_ <<
" * ";
3028 if (dims.size() == 0) {
3033 for (
size_t i = 0; i < dims.size(); ++i) {
3034 if (i > 0)
o_ <<
" * ";
3040 std::vector<expression> dims)
const {
3043 for (
size_t i = 0; i < dims.size(); ++i) {
3050 std::vector<expression> dims)
const {
3055 for (
size_t i = 0; i < dims.size(); ++i) {
3065 o <<
INDENT2 <<
"num_params_r__ = 0U;" <<
EOL;
3066 o <<
INDENT2 <<
"param_ranges_i__.clear();" <<
EOL;
3068 for (
size_t i = 0; i < var_decls.size(); ++i)
3069 boost::apply_visitor(vis, var_decls[i].decl_);
3073 const std::string& model_name,
3075 o <<
INDENT << model_name <<
"(stan::io::var_context& context__," <<
EOL;
3076 o <<
INDENT <<
" std::ostream* pstream__ = 0)"
3078 o <<
INDENT2 <<
": prob_grad(0) {"
3080 o <<
INDENT2 <<
"current_statement_begin__ = -1;"
3082 o <<
INDENT2 <<
"static const char* function__ = \""
3083 << model_name <<
"_namespace::" << model_name <<
"\";" <<
EOL;
3087 o <<
INDENT2 <<
"std::vector<int> vals_i__;" <<
EOL;
3088 o <<
INDENT2 <<
"std::vector<double> vals_r__;" <<
EOL;
3100 <<
"double DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());"
3103 <<
"(void) DUMMY_VAR__; // suppress unused var warning" <<
EOL2;
3107 bool include_sampling =
false;
3108 bool is_var =
false;
3109 bool is_fun_return =
false;
3111 2, o, include_sampling, is_var,
3130 var_size_validator_(o,
"initialization") {
3140 template <
typename D>
3143 std::stringstream ss;
3146 ss <<
"_lub_unconstrain(";
3152 ss <<
"_lb_unconstrain(";
3156 ss <<
"_ub_unconstrain(";
3160 ss <<
"_unconstrain(";
3254 const std::string& var_name,
3255 const std::vector<expression>& dims)
const {
3260 <<
"writer__." << write_method_name;
3265 <<
"} catch (const std::exception& e) { "
3268 <<
"throw std::runtime_error("
3269 <<
"std::string(\"Error transforming variable "
3270 << var_name <<
": \") + e.what());"
3277 size_t num_dims)
const {
3279 for (
size_t i = 0; i < num_dims; ++i)
3280 o_ <<
"[i" << i <<
"__]";
3283 const std::string& base_type,
3284 const std::vector<expression>& dims,
3295 const std::vector<expression>& dims,
3303 const std::string& name,
3304 const std::vector<expression>& dims,
3307 int indent = 2U)
const {
3308 size_t size = dims.size();
3311 int extra_indent = is_matrix ? 2U : is_vector ? 1U : 0U;
3314 o_ <<
"for (int j2__ = 0U; j2__ < ";
3316 o_ <<
"; ++j2__)" <<
EOL;
3319 o_ <<
"for (int j1__ = 0U; j1__ < ";
3321 o_ <<
"; ++j1__)" <<
EOL;
3322 }
else if (is_vector) {
3324 o_ <<
"for (int j1__ = 0U; j1__ < ";
3326 o_ <<
"; ++j1__)" <<
EOL;
3328 for (
size_t i = 0; i < size; ++i) {
3329 size_t idx = size - i - 1;
3331 o_ <<
"for (int i" << idx <<
"__ = 0U; i" << idx <<
"__ < ";
3333 o_ <<
"; ++i" << idx <<
"__)" <<
EOL;
3337 for (
size_t i = 0; i < dims.size(); ++i)
3338 o_ <<
"[i" << i <<
"__]";
3340 o_ <<
"(j1__,j2__)";
3343 o_ <<
" = vals_" << base_type <<
"__[pos__++];" <<
EOL;
3346 int indent = 2U)
const {
3347 size_t size = dims.size();
3348 for (
size_t i = 0; i < size; ++i) {
3350 o_ <<
"for (int i" << i <<
"__ = 0U; i" << i <<
"__ < ";
3352 o_ <<
"; ++i" << i <<
"__)" <<
EOL;
3358 <<
"if (!(context__.contains_i(\"" << name <<
"\")))"
3360 <<
"throw std::runtime_error(\"variable " << name <<
" missing\");"
3362 o_ <<
INDENT2 <<
"vals_i__ = context__.vals_i(\"" << name <<
"\");"
3368 <<
"if (!(context__.contains_r(\"" << name <<
"\")))"
3370 <<
"throw std::runtime_error(\"variable " << name <<
" missing\");"
3373 <<
"vals_r__ = context__.vals_r(\"" << name <<
"\");" <<
EOL;
3383 <<
"void transform_inits(const stan::io::var_context& context__,"
3385 o <<
INDENT <<
" std::vector<int>& params_i__,"
3387 o <<
INDENT <<
" std::vector<double>& params_r__,"
3389 o <<
INDENT <<
" std::ostream* pstream__) const {"
3391 o <<
INDENT2 <<
"stan::io::writer<double> "
3392 <<
"writer__(params_r__,params_i__);"
3395 o <<
INDENT2 <<
"(void) pos__; // dummy call to supress warning" <<
EOL;
3396 o <<
INDENT2 <<
"std::vector<double> vals_r__;" <<
EOL;
3397 o <<
INDENT2 <<
"std::vector<int> vals_i__;"
3400 for (
size_t i = 0; i < vs.size(); ++i)
3401 boost::apply_visitor(vis, vs[i].decl_);
3404 <<
INDENT2 <<
"params_r__ = writer__.data_r();" <<
EOL;
3405 o <<
INDENT2 <<
"params_i__ = writer__.data_i();" <<
EOL;
3409 <<
"void transform_inits(const stan::io::var_context& context," <<
EOL;
3412 <<
"Eigen::Matrix<double,Eigen::Dynamic,1>& params_r," <<
EOL;
3414 <<
" std::ostream* pstream__) const {" <<
EOL;
3415 o <<
INDENT <<
" std::vector<double> params_r_vec;" <<
EOL;
3416 o <<
INDENT <<
" std::vector<int> params_i_vec;" <<
EOL;
3418 <<
" transform_inits(context, params_i_vec, params_r_vec, pstream__);"
3420 o <<
INDENT <<
" params_r.resize(params_r_vec.size());" <<
EOL;
3421 o <<
INDENT <<
" for (int i = 0; i < params_r.size(); ++i)" <<
EOL;
3422 o <<
INDENT <<
" params_r(i) = params_r_vec[i];" <<
EOL;
3438 std::vector<expression> matrix_args;
3439 matrix_args.push_back(x.
M_);
3443 std::vector<expression> matrix_args;
3444 matrix_args.push_back(x.
N_);
3448 std::vector<expression> matrix_args;
3449 matrix_args.push_back(x.
M_);
3450 matrix_args.push_back(x.
N_);
3454 std::vector<expression> matrix_args;
3455 matrix_args.push_back(x.
K_);
3459 std::vector<expression> matrix_args;
3460 matrix_args.push_back(x.
K_);
3464 std::vector<expression> matrix_args;
3465 matrix_args.push_back(x.
K_);
3469 std::vector<expression> matrix_args;
3470 matrix_args.push_back(x.
K_);
3474 std::vector<expression> matrix_args;
3475 matrix_args.push_back(x.
M_);
3476 matrix_args.push_back(x.
N_);
3480 std::vector<expression> matrix_args;
3481 matrix_args.push_back(x.
K_);
3482 matrix_args.push_back(x.
K_);
3486 std::vector<expression> matrix_args;
3487 matrix_args.push_back(x.
K_);
3488 matrix_args.push_back(x.
K_);
3492 std::vector<expression> matrix_args;
3493 matrix_args.push_back(x.
K_);
3494 matrix_args.push_back(x.
K_);
3499 const std::vector<expression>& array_dims_exprs)
3502 for (
size_t i = 0; i < array_dims_exprs.size(); ++i) {
3508 for (
size_t i = 0; i < matrix_dims_exprs.size(); ++i) {
3521 <<
"void get_dims(std::vector<std::vector<size_t> >& dimss__) const {"
3525 o <<
INDENT2 <<
"std::vector<size_t> dims__;" <<
EOL;
3532 for (
size_t i = 0; i < prog.
derived_decl_.first.size(); ++i) {
3533 boost::apply_visitor(vis, prog.
derived_decl_.first[i].decl_);
3591 <<
"names__.push_back(\"" << name <<
"\");"
3601 <<
"void get_param_names(std::vector<std::string>& names__) const {"
3605 <<
"names__.resize(0);"
3613 for (
size_t i = 0; i < prog.
derived_decl_.first.size(); ++i) {
3614 boost::apply_visitor(vis, prog.
derived_decl_.first[i].decl_);
3638 std::vector<expression> matrix_args;
3639 matrix_args.push_back(x.
M_);
3643 std::vector<expression> matrix_args;
3644 matrix_args.push_back(x.
N_);
3648 std::vector<expression> matrix_args;
3649 matrix_args.push_back(x.
M_);
3650 matrix_args.push_back(x.
N_);
3654 std::vector<expression> matrix_args;
3655 matrix_args.push_back(x.
K_);
3659 std::vector<expression> matrix_args;
3660 matrix_args.push_back(x.
K_);
3664 std::vector<expression> matrix_args;
3665 matrix_args.push_back(x.
K_);
3669 std::vector<expression> matrix_args;
3670 matrix_args.push_back(x.
K_);
3674 std::vector<expression> matrix_args;
3675 matrix_args.push_back(x.
M_);
3676 matrix_args.push_back(x.
N_);
3680 std::vector<expression> matrix_args;
3681 matrix_args.push_back(x.
K_);
3682 matrix_args.push_back(x.
K_);
3686 std::vector<expression> matrix_args;
3687 matrix_args.push_back(x.
K_);
3688 matrix_args.push_back(x.
K_);
3692 std::vector<expression> matrix_args;
3693 matrix_args.push_back(x.
K_);
3694 matrix_args.push_back(x.
K_);
3699 const std::string& name,
3700 const std::vector<expression>& dims)
const {
3702 std::vector<expression> combo_dims(dims);
3703 for (
size_t i = 0; i < matrix_dims.size(); ++i)
3704 combo_dims.push_back(matrix_dims[i]);
3706 for (
size_t i = combo_dims.size(); i-- > 0; ) {
3708 o_ <<
"for (int k_" << i <<
"__ = 1;"
3709 <<
" k_" << i <<
"__ <= ";
3711 o_ <<
"; ++k_" << i <<
"__) {" <<
EOL;
3715 o_ <<
"param_name_stream__.str(std::string());" <<
EOL;
3718 o_ <<
"param_name_stream__ << \"" << name <<
'"';
3720 for (
size_t i = 0; i < combo_dims.size(); ++i)
3721 o_ <<
" << '.' << k_" << i <<
"__";
3725 o_ <<
"param_names__.push_back(param_name_stream__.str());" <<
EOL;
3728 for (
size_t i = 0; i < combo_dims.size(); ++i) {
3739 <<
"void constrained_param_names("
3740 <<
"std::vector<std::string>& param_names__,"
3742 <<
" bool include_tparams__ = true,"
3744 <<
" bool include_gqs__ = true) const {"
3746 <<
"std::stringstream param_name_stream__;" <<
EOL;
3755 <<
"if (!include_gqs__ && !include_tparams__) return;"
3759 for (
size_t i = 0; i < prog.
derived_decl_.first.size(); ++i) {
3760 boost::apply_visitor(vis, prog.
derived_decl_.first[i].decl_);
3764 <<
"if (!include_gqs__) return;"
3787 std::vector<expression> matrix_args;
3788 matrix_args.push_back(x.
M_);
3792 std::vector<expression> matrix_args;
3793 matrix_args.push_back(x.
N_);
3797 std::vector<expression> matrix_args;
3798 matrix_args.push_back(x.
M_);
3799 matrix_args.push_back(x.
N_);
3803 std::vector<expression> matrix_args;
3804 matrix_args.push_back(x.
K_);
3808 std::vector<expression> matrix_args;
3813 std::vector<expression> matrix_args;
3814 matrix_args.push_back(x.
K_);
3818 std::vector<expression> matrix_args;
3819 matrix_args.push_back(x.
K_);
3824 std::vector<expression> matrix_args;
3843 std::vector<expression> matrix_args;
3855 std::vector<expression> matrix_args;
3868 std::vector<expression> matrix_args;
3881 const std::string& name,
3882 const std::vector<expression>& dims)
const {
3884 std::vector<expression> combo_dims(dims);
3885 for (
size_t i = 0; i < matrix_dims.size(); ++i)
3886 combo_dims.push_back(matrix_dims[i]);
3888 for (
size_t i = combo_dims.size(); i-- > 0; ) {
3890 o_ <<
"for (int k_" << i <<
"__ = 1;"
3891 <<
" k_" << i <<
"__ <= ";
3893 o_ <<
"; ++k_" << i <<
"__) {" <<
EOL;
3897 o_ <<
"param_name_stream__.str(std::string());" <<
EOL;
3900 o_ <<
"param_name_stream__ << \"" << name <<
'"';
3902 for (
size_t i = 0; i < combo_dims.size(); ++i)
3903 o_ <<
" << '.' << k_" << i <<
"__";
3907 o_ <<
"param_names__.push_back(param_name_stream__.str());" <<
EOL;
3910 for (
size_t i = 0; i < combo_dims.size(); ++i) {
3921 <<
"void unconstrained_param_names("
3922 <<
"std::vector<std::string>& param_names__,"
3924 <<
" bool include_tparams__ = true,"
3926 <<
" bool include_gqs__ = true) const {"
3928 <<
"std::stringstream param_name_stream__;" <<
EOL;
3937 <<
"if (!include_gqs__ && !include_tparams__) return;"
3941 for (
size_t i = 0; i < prog.
derived_decl_.first.size(); ++i) {
3942 boost::apply_visitor(vis, prog.
derived_decl_.first[i].decl_);
3946 <<
"if (!include_gqs__) return;"
3969 template <
typename D>
3971 const std::string& base_type,
3972 const std::string& read_fun_prefix,
3973 const std::vector<expression>& dim_args)
const {
3974 std::vector<expression> read_args;
3975 std::string read_fun(read_fun_prefix);
3978 read_args.push_back(x.range_.low_);
3979 read_args.push_back(x.range_.high_);
3982 read_args.push_back(x.range_.low_);
3985 read_args.push_back(x.range_.high_);
3987 for (
size_t i = 0; i < dim_args.size(); ++i)
3988 read_args.push_back(dim_args[i]);
3994 std::vector<expression> read_args;
3998 std::vector<expression> read_args;
3999 read_args.push_back(x.
M_);
4003 std::vector<expression> read_args;
4004 read_args.push_back(x.
N_);
4009 std::vector<expression> read_args;
4010 read_args.push_back(x.
M_);
4011 read_args.push_back(x.
N_);
4015 std::vector<expression> read_args;
4016 read_args.push_back(x.
K_);
4021 std::vector<expression> read_args;
4022 read_args.push_back(x.
K_);
4027 std::vector<expression> read_args;
4028 read_args.push_back(x.
K_);
4033 std::vector<expression> read_args;
4034 read_args.push_back(x.
K_);
4039 std::vector<expression> read_args;
4040 read_args.push_back(x.
M_);
4041 read_args.push_back(x.
N_);
4046 std::vector<expression> read_args;
4047 read_args.push_back(x.
K_);
4052 std::vector<expression> read_args;
4053 read_args.push_back(x.
K_);
4058 std::vector<expression> read_args;
4059 read_args.push_back(x.
K_);
4064 const std::string& read_type,
4065 const std::vector<expression>& read_args,
4066 const std::string& name,
4067 const std::vector<expression>& dims)
const{
4068 if (dims.size() == 0) {
4070 o_ << var_type <<
" ";
4071 o_ << name <<
" = in__." << read_type <<
"_constrain(";
4072 for (
size_t j = 0; j < read_args.size(); ++j) {
4073 if (j > 0)
o_ <<
",";
4080 for (
size_t i = 0; i < dims.size(); ++i)
o_ <<
"vector<";
4082 for (
size_t i = 0; i < dims.size(); ++i)
o_ <<
"> ";
4083 o_ << name <<
";" <<
EOL;
4084 std::string name_dims(name);
4085 for (
size_t i = 0; i < dims.size(); ++i) {
4087 o_ <<
"size_t dim_" << name <<
"_" << i <<
"__ = ";
4090 if (i < dims.size() - 1) {
4092 o_ << name_dims <<
".resize(dim_" << name <<
"_" << i <<
"__);"
4094 name_dims.append(
"[k_").append(
to_string(i)).append(
"__]");
4097 o_ <<
"for (size_t k_" << i <<
"__ = 0;"
4098 <<
" k_" << i <<
"__ < dim_" << name <<
"_" << i <<
"__;"
4099 <<
" ++k_" << i <<
"__) {" <<
EOL;
4100 if (i == dims.size() - 1) {
4102 o_ << name_dims <<
".push_back(in__." << read_type <<
"_constrain(";
4103 for (
size_t j = 0; j < read_args.size(); ++j) {
4104 if (j > 0)
o_ <<
",";
4111 for (
size_t i = dims.size(); i > 0; --i) {
4134 std::vector<expression> dims(x.
dims_);
4135 dims.push_back(x.
M_);
4139 std::vector<expression> dims(x.
dims_);
4140 dims.push_back(x.
N_);
4144 std::vector<expression> matdims;
4145 matdims.push_back(x.
M_);
4146 matdims.push_back(x.
N_);
4150 std::vector<expression> dims(x.
dims_);
4151 dims.push_back(x.
K_);
4155 std::vector<expression> dims(x.
dims_);
4156 dims.push_back(x.
K_);
4160 std::vector<expression> dims(x.
dims_);
4161 dims.push_back(x.
K_);
4165 std::vector<expression> dims(x.
dims_);
4166 dims.push_back(x.
K_);
4170 std::vector<expression> matdims;
4171 matdims.push_back(x.
M_);
4172 matdims.push_back(x.
N_);
4176 std::vector<expression> matdims;
4177 matdims.push_back(x.
K_);
4178 matdims.push_back(x.
K_);
4182 std::vector<expression> matdims;
4183 matdims.push_back(x.
K_);
4184 matdims.push_back(x.
K_);
4188 std::vector<expression> matdims;
4189 matdims.push_back(x.
K_);
4190 matdims.push_back(x.
K_);
4194 const std::vector<expression>& arraydims,
4195 const std::vector<expression>& matdims)
const {
4196 std::vector<expression> dims(arraydims);
4197 for (
size_t i = 0; i < matdims.size(); ++i)
4198 dims.push_back(matdims[i]);
4200 if (dims.size() == 0) {
4201 o_ <<
INDENT2 <<
"vars__.push_back(" << name <<
");" <<
EOL;
4206 for (
size_t i = dims.size(); i > 0; ) {
4209 o_ <<
"for (int k_" << i <<
"__ = 0;"
4210 <<
" k_" << i <<
"__ < ";
4212 o_ <<
"; ++k_" << i <<
"__) {" <<
EOL;
4216 o_ <<
"vars__.push_back(" << name;
4217 if (arraydims.size() > 0) {
4219 for (
size_t i = 0; i < arraydims.size(); ++i) {
4220 if (i > 0)
o_ <<
"][";
4221 o_ <<
"k_" << i <<
"__";
4225 if (matdims.size() > 0) {
4226 o_ <<
"(k_" << arraydims.size() <<
"__";
4227 if (matdims.size() > 1)
4228 o_ <<
", k_" << (arraydims.size() + 1) <<
"__";
4233 for (
size_t i = dims.size(); i > 0; --i) {
4242 const std::string& model_name,
4244 o <<
INDENT <<
"template <typename RNG>" <<
EOL;
4245 o <<
INDENT <<
"void write_array(RNG& base_rng__," <<
EOL;
4246 o <<
INDENT <<
" std::vector<double>& params_r__," <<
EOL;
4247 o <<
INDENT <<
" std::vector<int>& params_i__," <<
EOL;
4248 o <<
INDENT <<
" std::vector<double>& vars__," <<
EOL;
4249 o <<
INDENT <<
" bool include_tparams__ = true," <<
EOL;
4250 o <<
INDENT <<
" bool include_gqs__ = true," <<
EOL;
4252 <<
" std::ostream* pstream__ = 0) const {" <<
EOL;
4255 <<
"stan::io::reader<double> in__(params_r__,params_i__);"<<
EOL;
4256 o <<
INDENT2 <<
"static const char* function__ = \""
4257 << model_name <<
"_namespace::write_array\";" <<
EOL;
4274 o <<
INDENT2 <<
"if (!include_tparams__) return;"
4279 o <<
INDENT2 <<
"stan::math::accumulator<double> lp_accum__;" <<
EOL2;
4280 bool is_var =
false;
4281 bool is_fun_return =
false;
4285 bool include_sampling =
false;
4287 include_sampling, is_var, is_fun_return);
4295 for (
size_t i = 0; i < prog.
derived_decl_.first.size(); ++i)
4296 boost::apply_visitor(vis_writer, prog.
derived_decl_.first[i].decl_);
4299 o <<
INDENT2 <<
"if (!include_gqs__) return;"
4303 is_var, is_fun_return);
4307 <<
"double DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());"
4309 o <<
INDENT2 <<
"(void) DUMMY_VAR__; // suppress unused var warning"
4315 include_sampling, is_var, is_fun_return);
4324 boost::apply_visitor(vis_writer, prog.
generated_decl_.first[i].decl_);
4330 o <<
INDENT <<
"template <typename RNG>" <<
EOL;
4331 o <<
INDENT <<
"void write_array(RNG& base_rng," <<
EOL;
4333 <<
" Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,"
4336 <<
" Eigen::Matrix<double,Eigen::Dynamic,1>& vars,"
4338 o <<
INDENT <<
" bool include_tparams = true," <<
EOL;
4339 o <<
INDENT <<
" bool include_gqs = true," <<
EOL;
4341 <<
" std::ostream* pstream = 0) const {" <<
EOL;
4343 <<
" std::vector<double> params_r_vec(params_r.size());" <<
EOL;
4344 o <<
INDENT <<
" for (int i = 0; i < params_r.size(); ++i)" <<
EOL;
4345 o <<
INDENT <<
" params_r_vec[i] = params_r(i);" <<
EOL;
4346 o <<
INDENT <<
" std::vector<double> vars_vec;" <<
EOL;
4347 o <<
INDENT <<
" std::vector<int> params_i_vec;" <<
EOL;
4349 <<
" write_array(base_rng,params_r_vec,params_i_vec,"
4350 <<
"vars_vec,include_tparams,include_gqs,pstream);" <<
EOL;
4351 o <<
INDENT <<
" vars.resize(vars_vec.size());" <<
EOL;
4352 o <<
INDENT <<
" for (int i = 0; i < vars.size(); ++i)" <<
EOL;
4353 o <<
INDENT <<
" vars(i) = vars_vec[i];" <<
EOL;
4358 std::ostream& out) {
4359 out <<
INDENT <<
"static std::string model_name() {" <<
EOL
4360 <<
INDENT2 <<
"return \"" << model_name <<
"\";" <<
EOL
4365 std::ostream& out) {
4366 out <<
"typedef " << model_name <<
"_namespace::" << model_name
4367 <<
" stan_model;" <<
EOL2;
4371 const std::string& scalar_t_name,
4372 std::ostream& out) {
4373 for (
size_t d = 0; d < t.
num_dims_; ++d)
4374 out <<
"std::vector<";
4376 bool is_template_type =
false;
4380 is_template_type =
false;
4383 out << scalar_t_name;
4384 is_template_type =
false;
4387 out <<
"Eigen::Matrix<"
4389 <<
", Eigen::Dynamic,1>";
4390 is_template_type =
true;
4393 out <<
"Eigen::Matrix<"
4395 <<
", 1,Eigen::Dynamic>";
4396 is_template_type =
true;
4399 out <<
"Eigen::Matrix<"
4401 <<
", Eigen::Dynamic,Eigen::Dynamic>";
4402 is_template_type =
true;
4408 out <<
"UNKNOWN TYPE";
4411 for (
size_t d = 0; d < t.
num_dims_; ++d) {
4412 if (d > 0 || is_template_type)
4421 const std::string& scalar_t_name,
4422 std::ostream& out) {
4428 out <<
" " << decl.
name_;
4432 for (
size_t i = 0; i < fun.
arg_decls_.size(); ++i)
4440 std::stringstream ss;
4453 std::stringstream ss;
4454 ss <<
"typename boost::math::tools::promote_args<";
4455 int num_open_brackets = 1;
4456 int num_generated_params = 0;
4457 for (
size_t i = 0; i < num_args; ++i) {
4460 if (num_generated_params > 0)
4462 if (num_generated_params == 4) {
4463 ss <<
"typename boost::math::tools::promote_args<";
4464 num_generated_params = 0;
4465 ++num_open_brackets;
4467 ss <<
"T" << i <<
"__";
4468 ++num_generated_params;
4472 if (num_generated_params > 0)
4477 for (
int i = 0; i < num_open_brackets; ++i)
4485 for (
size_t i = 0; i < fun.
arg_decls_.size(); ++i) {
4498 std::ostream& out) {
4500 out <<
"template <";
4501 bool continuing_tps =
false;
4503 out <<
"bool propto";
4504 continuing_tps =
true;
4506 for (
size_t i = 0; i < fun.
arg_decls_.size(); ++i) {
4511 out <<
"typename T" << i <<
"__";
4512 continuing_tps =
true;
4519 continuing_tps =
true;
4523 out <<
"typename T_lp__, typename T_lp_accum__";
4524 continuing_tps =
true;
4530 out <<
"template <class RNG>" <<
EOL;
4532 out <<
"template <typename T_lp__, typename T_lp_accum__>"
4534 }
else if (is_log) {
4535 out <<
"template <bool propto>"
4542 const std::string& scalar_t_name,
4544 std::ostream& out) {
4553 std::ostream& out) {
4562 std::ostream& out) {
4565 for (
size_t i = 0; i < fun.
arg_decls_.size(); ++i) {
4566 std::string template_type_i
4567 =
"T" + boost::lexical_cast<std::string>(i) +
"__";
4571 for (
size_t i = 0; i <= fun.
name_.size(); ++i)
4575 if ((is_rng || is_lp) && fun.
arg_decls_.size() > 0)
4578 out <<
"RNG& base_rng__";
4580 out <<
"T_lp__& lp__, T_lp_accum__& lp_accum__";
4581 if (is_rng || is_lp || fun.
arg_decls_.size() > 0)
4583 out <<
"std::ostream* pstream__";
4591 std::ostream& out) {
4594 for (
size_t i = 0; i < fun.
arg_decls_.size(); ++i) {
4599 if ((is_rng || is_lp) && fun.
arg_decls_.size() > 0)
4602 out <<
"base_rng__";
4604 out <<
"lp__, lp_accum__";
4605 if (is_rng || is_lp || fun.
arg_decls_.size() > 0)
4614 const std::string& scalar_t_name,
4615 std::ostream& out) {
4623 <<
"typedef " << scalar_t_name <<
" fun_scalar_t__;"
4628 ?
"int" :
"fun_scalar_t__")
4629 <<
" fun_return_scalar_t__;"
4632 <<
"const static bool propto__ = true;"
4635 <<
"(void) propto__;"
4637 bool is_var =
false;
4638 bool is_fun_return =
true;
4639 bool include_sampling =
true;
4641 <<
"int current_statement_begin__ = -1;"
4645 include_sampling, is_var, is_fun_return);
4651 std::ostream& out) {
4653 out <<
INDENT <<
"return ";
4654 out << fun.
name_ <<
"<false>(";
4655 for (
size_t i = 0; i < fun.
arg_decls_.size(); ++i) {
4668 const std::string& scalar_t_name,
4669 std::ostream& out) {
4689 std::ostream& out) {
4711 std::ostream& out) {
4721 out <<
EOL <<
"struct ";
4723 out <<
"_functor__ {" <<
EOL;
4731 out << INDENT <<
"operator()";
4733 out <<
" const {" <<
EOL;
4739 out << INDENT <<
"}" <<
EOL;
4740 out <<
"};" <<
EOL2;
4745 std::ostream& out) {
4746 for (
size_t i = 0; i < funs.size(); ++i) {
4753 std::ostream& out) {
4759 out <<
"static int current_statement_begin__;"
4765 const std::string& model_name,
4766 std::ostream& out) {
void operator()(const vector_var_decl &x) const
void operator()(corr_matrix_var_decl const &x) const
void operator()(const matrix_var_decl &x) const
void operator()(cov_matrix_var_decl const &x) const
void operator()(int_var_decl const &x) const
void operator()(cholesky_factor_var_decl const &x) const
write_dims_visgen(std::ostream &o)
void operator()(int_var_decl const &x) const
void operator()(matrix_var_decl const &x) const
void operator()(const simplex_var_decl &x) const
void operator()(const vector_var_decl &x) const
void operator()(row_vector_var_decl const &x) const
void operator()(cholesky_corr_var_decl const &x) const
void operator()(const ordered_var_decl &x) const
void operator()(row_vector_var_decl const &x) const
void operator()(const positive_ordered_var_decl &x) const
void operator()(const nil &) const
void operator()(simplex_var_decl const &x) const
bool lhs_var_occurs_on_rhs() const
void operator()(corr_matrix_var_decl const &x) const
void operator()(const unit_vector_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()(vector_var_decl const &x) const
void generate_dims_array(const std::vector< expression > &matrix_dims_exprs, const std::vector< expression > &array_dims_exprs) const
void operator()(ordered_var_decl const &x) const
void operator()(const omni_idx &i) const
void generate_idx_user(const idx &i, std::ostream &o)
void operator()(cov_matrix_var_decl const &x) const
void operator()(const corr_matrix_var_decl &x) const
std::string to_string(T i)
void operator()(const ordered_var_decl &x) const
statement_visgen(size_t indent, bool include_sampling, bool is_var, bool is_fun_return, std::ostream &o)
void operator()(positive_ordered_var_decl const &x) const
void operator()(nil const &) const
void operator()(row_vector_var_decl const &x) const
void operator()(int_var_decl const &x) const
const std::string EOL2("\n\n")
void operator()(const matrix_var_decl &x) const
void operator()(const cholesky_corr_var_decl &x) const
void basic_validate(T const &x) const
void generate_private_decl(std::ostream &o)
void operator()(const conditional_statement &x) const
local_var_decl_visgen(int indents, bool is_var, bool is_fun_return, std::ostream &o)
void operator()(const unit_vector_var_decl &x) const
std::vector< statement > statements_
void operator()(double_var_decl const &x) const
void operator()(positive_ordered_var_decl const &x) const
void operator()(const simplex_var_decl &x) const
std::vector< expression > dims_
void operator()(sample const &x) const
void operator()(const int_var_decl &x) const
bool operator()(const expression &st) const
void operator()(cholesky_factor_var_decl const &x) const
void operator()(cov_matrix_var_decl const &x) const
const bool is_fun_return_
void operator()(corr_matrix_var_decl const &x) const
void operator()(vector_var_decl const &x) const
void generate_log_prob(program const &p, std::ostream &o)
void operator()(const ordered_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 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()(positive_ordered_var_decl const &x) const
void operator()(const unit_vector_var_decl &x) const
void operator()(const positive_ordered_var_decl &x) const
void operator()(double_var_decl const &x) const
void operator()(const ub_idx &i) const
void operator()(double_var_decl const &x) const
void operator()(vector_var_decl const &x) const
void generate_name_dims(const std::string name, size_t num_dims) const
Probability, optimization and sampling library.
void generate_statements(const std::vector< statement > &ss, int indent, std::ostream &o, bool include_sampling, bool is_var, bool is_fun_return)
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
validate_var_decl_visgen(int indents, std::ostream &o)
void operator()(const matrix_var_decl &x) const
idx_visgen(std::ostream &o)
void operator()(double_var_decl const &x) const
std::string get_prob_fun(const std::string &dist_name)
void operator()(int_var_decl const &x) const
void operator()(positive_ordered_var_decl const &x) const
std::vector< var_decl > data_decl_
void generate_type(const std::string &type, size_t num_dims) const
void operator()(const nil &) const
void generate_unconstrained_param_names_method(const program &prog, std::ostream &o)
void generate_void_statement(const std::string &name, const size_t indent, std::ostream &o)
void operator()(const cov_matrix_var_decl &x) const
var_resizing_visgen(std::ostream &o)
void operator()(const cov_matrix_var_decl &x) const
void operator()(corr_matrix_var_decl const &x) const
void operator()(const positive_ordered_var_decl &x) const
std::vector< var_decl > local_decl_
void operator()(const cov_matrix_var_decl &x) const
void operator()(const positive_ordered_var_decl &x) const
void operator()(const vector_var_decl &x) const
void operator()(const cholesky_corr_var_decl &x) const
void generate_loop_var(const std::string &name, size_t dims_size) const
static void print_string_literal(std::ostream &o, const std::string &s)
std::string get_cdf(const std::string &dist_name)
void operator()(const cholesky_corr_var_decl &x) const
void generate_propto_default_function(const function_decl_def &fun, const std::string &scalar_t_name, std::ostream &out)
void operator()(assignment const &x) const
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 operator()(const simplex_var_decl &x) const
void generate_model_typedef(const std::string &model_name, std::ostream &out)
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
void operator()(const corr_matrix_var_decl &x) const
void operator()(const corr_matrix_var_decl &x) const
void operator()(positive_ordered_var_decl const &x) const
void operator()(const corr_matrix_var_decl &x) const
std::vector< statement > bodies_
void operator()(const row_vector_var_decl &x) const
void generate_local_var_inits(std::vector< var_decl > vs, bool is_var, bool declare_vars, std::ostream &o)
std::vector< printable > printables_
void operator()(const positive_ordered_var_decl &x) const
void operator()(const double_var_decl &x) const
void operator()(const int_var_decl &x) const
void operator()(cov_matrix_var_decl const &x) const
void operator()(cholesky_factor_var_decl const &x) const
member_var_decl_visgen(int indents, std::ostream &o)
void declare_array(const std::string &type, const std::vector< expression > &ctor_args, const std::string &name, const std::vector< expression > &dims) const
void operator()(row_vector_var_decl const &x) const
void operator()(nil const &) const
void operator()(const cov_matrix_var_decl &x) const
void operator()(const cholesky_corr_var_decl &x) const
void generate_end_for_dims(size_t dims_size) const
void generate_idx(const idx &i, std::ostream &o)
void operator()(const nil &) const
void operator()(const matrix_var_decl &x) const
void operator()(const nil &) const
void operator()(const cholesky_corr_var_decl &x) const
var_size_validating_visgen var_size_validator_
bool is_no_op_statement() const
void generate_indent(size_t indent, std::ostream &o)
void operator()(const double_var_decl &x) const
void operator()(simplex_var_decl const &x) const
bool operator()(const for_statement &st) const
void generate_void_statement(const std::string &name) const
void generate_member_var_inits(const std::vector< var_decl > &vs, std::ostream &o)
void operator()(cov_matrix_var_decl const &x) const
void operator()(cholesky_factor_var_decl const &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
void generate_member_var_decls(const std::vector< var_decl > &vs, int indent, std::ostream &o)
void generate_globals(std::ostream &out)
void generate_idxs_user(const std::vector< idx > &idxs, std::ostream &o)
void generate_init_args(const std::string &type, const std::vector< expression > &ctor_args, const std::vector< expression > &dims, size_t dim) const
std::string fun_scalar_type(const function_decl_def &fun, bool is_lp)
void operator()(const simplex_var_decl &x) const
void generate_local_var_init_nan(const std::vector< var_decl > &vs, int indent, std::ostream &o, bool is_var, bool is_fun_return)
void operator()(const unit_vector_var_decl &x) const
void operator()(cholesky_corr_var_decl const &x) const
void operator()(expression const &x) const
void generate_dims_method(const program &prog, std::ostream &o)
generate_init_visgen(std::ostream &o)
void operator()(const std::string &s) const
void write_array(const std::string &name, const std::vector< expression > &arraydims, const std::vector< expression > &matdims) const
void generate_param_names_method(const program &prog, std::ostream &o)
void operator()(const simplex_var_decl &x) const
void operator()(simplex_var_decl const &x) const
void operator()(const cholesky_corr_var_decl &x) const
printable_visgen(std::ostream &o)
void operator()(nil const &) const
void operator()(const corr_matrix_var_decl &x) const
void operator()(const vector_var_decl &x) const
void operator()(const cholesky_factor_var_decl &x) const
void generate_located_statements(const std::vector< statement > &ss, int indent, std::ostream &o, bool include_sampling, bool is_var, bool is_fun_return)
void generate_usings(std::ostream &o)
bool operator()(const increment_log_prob_statement &t) const
void generate_cpp(const program &prog, const std::string &model_name, std::ostream &out)
std::string get_ccdf(const std::string &dist_name)
bool has_only_int_args(const function_decl_def &fun)
void operator()(const cov_matrix_var_decl &x) const
void operator()(const cholesky_corr_var_decl &x) const
void generate_write_array_method(const program &prog, const std::string &model_name, std::ostream &o)
const std::string INDENT3(" ")
void operator()(const ub_idx &i) const
std::vector< function_decl_def > function_decl_defs_
void generate_increment_i(std::vector< expression > dims) const
void operator()(const simplex_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 operator()(matrix_var_decl const &x) const
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 corr_matrix_var_decl &x) const
void generate_set_param_ranges(const std::vector< var_decl > &var_decls, std::ostream &o)
expr_type expression_type() const
void operator()(const uni_idx &i) const
void operator()(const simplex_var_decl &x) const
void generate_model_name_method(const std::string &model_name, std::ostream &out)
void operator()(simplex_var_decl const &x) const
void operator()(nil const &) const
const std::string INDENT(" ")
void operator()(cholesky_factor_var_decl const &x) const
void operator()(double_var_decl const &x) const
void operator()(const vector_var_decl &x) const
void operator()(ordered_var_decl const &x) const
void operator()(nil const &) 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()(vector_var_decl const &x) const
void generate_check_int(const std::string &name, size_t) const
void generate_validate_var_decls(const std::vector< var_decl > decls, int indent, std::ostream &o)
var_size_validating_visgen var_size_validator_
void operator()(const unit_vector_var_decl &x) const
void operator()(const double_var_decl &x) const
void operator()(const int_var_decl &x) const
bool is_nil(const expression &e)
void generate_validate_transformed_params(const std::vector< var_decl > &vs, int indent, std::ostream &o)
void operator()(unit_vector_var_decl const &x) const
void operator()(const cholesky_corr_var_decl &x) const
void operator()(const unit_vector_var_decl &x) const
void operator()(const row_vector_var_decl &x) const
void operator()(row_vector_var_decl const &x) const
void generate_dims_loop_fwd(const std::vector< expression > &dims, int indent=2U) const
void operator()(const ordered_var_decl &x) const
void operator()(matrix_var_decl const &x) const
void operator()(vector_var_decl const &x) const
void generate_constrained_param_names_method(const program &prog, std::ostream &o)
void operator()(matrix_var_decl const &x) const
const std::string MINOR_VERSION
Minor version number for Stan package.
void generate_validate_var_decl(const var_decl &decl, int indent, std::ostream &o)
void operator()(positive_ordered_var_decl const &x) const
std::pair< std::vector< var_decl >, std::vector< statement > > derived_data_decl_
void operator()(vector_var_decl const &x) const
void operator()(const double_var_decl &x) const
void operator()(const unit_vector_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 operator()(const no_op_statement &) const
void generate_printable(const printable &p, std::ostream &o)
void operator()(unit_vector_var_decl const &x) const
void operator()(int_var_decl const &x) const
void operator()(const vector_var_decl &x) const
std::pair< std::vector< var_decl >, std::vector< statement > > generated_decl_
void generate_typedefs(std::ostream &o)
void operator()(double_var_decl const &x) const
void operator()(unit_vector_var_decl const &x) const
void operator()(matrix_var_decl const &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()(cholesky_corr_var_decl const &x) const
void operator()(simplex_var_decl const &x) const
write_array_visgen(std::ostream &o)
bool ends_with(const std::string &suffix, const std::string &s)
void generate_located_statement(const statement &s, int indent, std::ostream &o, bool include_sampling, bool is_var, bool is_fun_return)
void operator()(const positive_ordered_var_decl &x) const
void operator()(cholesky_factor_var_decl const &x) const
void operator()(const matrix_var_decl &x) const
void operator()(matrix_var_decl const &x) const
void generate_functions(const std::vector< function_decl_def > &funs, std::ostream &out)
void operator()(const row_vector_var_decl &x) const
void operator()(const cholesky_corr_var_decl &x) const
bool is_user_defined_prob_function(const std::string &name, const expression &variate, const std::vector< expression > ¶ms)
void operator()(const unit_vector_var_decl &x) const
void operator()(row_vector_var_decl const &x) const
void operator()(const matrix_var_decl &x) const
void operator()(const matrix_var_decl &x) const
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 generate_version_comment(std::ostream &o)
void operator()(const cholesky_factor_var_decl &x) const
void operator()(const cholesky_factor_var_decl &x) const
bool is_ill_formed() const
void operator()(const lb_idx &i) const
std::vector< expression > args_
void operator()(const row_vector_var_decl &x) const
void operator()(const cov_matrix_var_decl &x) const
void operator()(const cholesky_factor_var_decl &x) const
void operator()(const return_statement &rs) const
void operator()(unit_vector_var_decl const &x) const
void operator()(const while_statement &x) const
void operator()(unit_vector_var_decl const &x) const
void operator()(const nil &) const
static void print_quoted_expression(std::ostream &o, const expression &e)
void operator()(const cholesky_factor_var_decl &x) const
void operator()(const cholesky_corr_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 generate_check_double(const std::string &name, size_t) const
void operator()(const ordered_var_decl &x) const
unconstrained_param_names_visgen(std::ostream &o)
void operator()(const row_vector_var_decl &x) const
void operator()(const simplex_var_decl &x) const
void operator()(int_var_decl const &x) const
std::string function_args(const std::string &fun_prefix, const D &x) const
void generate_using(const std::string &type, std::ostream &o)
void generate_expression(const expression &e, std::ostream &o)
void operator()(corr_matrix_var_decl const &x) const
void operator()(const assgn &y) const
base_expr_type base_type_
void operator()(cholesky_corr_var_decl const &x) const
void operator()(const int_var_decl &x) const
void operator()(positive_ordered_var_decl const &x) const
void operator()(const cholesky_factor_var_decl &x) const
void generate_init_method(const std::vector< var_decl > &vs, std::ostream &o)
void operator()(corr_matrix_var_decl const &x) const
void operator()(simplex_var_decl const &x) const
void operator()(const ordered_var_decl &x) const
std::pair< std::vector< var_decl >, std::vector< statement > > derived_decl_
void generate_local_var_decls(const std::vector< var_decl > &vs, int indent, std::ostream &o, bool is_var, bool is_fun_return)
void generate_param_names_array(const std::vector< expression > &matrix_dims, const std::string &name, const std::vector< expression > &dims) const
void operator()(const multi_idx &i) const
void operator()(const increment_log_prob_statement &x) const
void generate_end_class_decl(std::ostream &o)
idx_user_visgen(std::ostream &o)
bool operator()(const sample &st) const
base_expr_type base_type_
void operator()(cholesky_factor_var_decl const &x) const
bool operator()(const return_statement &st) const
void operator()(nil const &) const
void operator()(simplex_var_decl const &x) const
void operator()(const int_var_decl &x) const
void operator()(const omni_idx &i) const
bool operator()(const conditional_statement &st) const
void generate_includes(std::ostream &o)
bool is_data_origin(const var_origin &vo)
void generate_indent_num_dims(size_t base_indent, const std::vector< expression > &dims, const expression &dim1, const expression &dim2) const
std::vector< expression > conditions_
void operator()(const cov_matrix_var_decl &x) const
void generate_comment(std::string const &msg, int indent, std::ostream &o)
void nonbasic_validate(const T &x, const std::string &type_name) const
void operator()(positive_ordered_var_decl const &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 cov_matrix_var_decl &x) const
std::vector< arg_decl > arg_decls_
void operator()(const int_var_decl &x) const
void operator()(const matrix_var_decl &x) const
void generate_functor_arguments(const function_decl_def &fun, bool is_rng, bool is_lp, bool is_log, std::ostream &out)
void operator()(double_var_decl const &x) const
void operator()(cov_matrix_var_decl const &x) const
void operator()(const expression &e) const
void generate_param_names(const std::string &name) const
void operator()(corr_matrix_var_decl const &x) const
void operator()(const row_vector_var_decl &x) const
void operator()(const positive_ordered_var_decl &x) const
void operator()(const double_var_decl &x) const
void operator()(const double_var_decl &x) const
std::string cond_op_scalar_type(const conditional_op &expr, bool is_data_origin)
void operator()(cholesky_corr_var_decl const &x) const
void generate_try(int indent, std::ostream &o)
void operator()(const for_statement &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 statements &x) const
void operator()(const cholesky_factor_var_decl &x) const
generate_init_vars_visgen(int indent, std::ostream &o)
void operator()(const row_vector_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 vector_var_decl &x) const
std::vector< expression > dims_
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)
const std::string EOL("\n")
void generate_eigen_index_expression(const expression &e, std::ostream &o)
void operator()(vector_var_decl const &x) const
void generate_function_name(const function_decl_def &fun, std::ostream &out)
void generate_increment(expression K, std::vector< expression > dims) const
void generate_end_namespace(std::ostream &o)
void operator()(const double_var_decl &x) const
void operator()(const simplex_var_decl &x) const
constrained_param_names_visgen(std::ostream &o)
bool operator()(const no_op_statement &st) const
void generate_function_inline_return_type(const function_decl_def &fun, const std::string &scalar_t_name, int indent, std::ostream &out)
void operator()(ordered_var_decl const &x) const
void operator()(row_vector_var_decl const &x) const
void operator()(simplex_var_decl const &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 operator()(const multi_idx &i) const
void operator()(const positive_ordered_var_decl &x) const
void generate_type(const std::string &base_type, const std::vector< expression > &, size_t end, std::ostream &o)
void operator()(vector_var_decl const &x) const
void generate_begin_for_dims(const std::vector< expression > &dims) const
void operator()(ordered_var_decl const &x) const
dump_member_var_visgen(std::ostream &o)
void generate_destructor(const std::string &model_name, std::ostream &o)
void operator()(const cholesky_factor_var_decl &x) const
void operator()(unit_vector_var_decl const &x) const
void operator()(const reject_statement &ps) 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 uni_idx &i) const
void operator()(cov_matrix_var_decl const &x) const
void operator()(matrix_var_decl const &x) const
write_param_names_visgen(std::ostream &o)
void operator()(int_var_decl const &x) const
void operator()(const lub_idx &i) const
void operator()(matrix_var_decl const &x) const
void operator()(const lb_idx &i) const
void operator()(const matrix_var_decl &x) const
void operator()(unit_vector_var_decl const &x) const
void operator()(nil const &) const
void operator()(const int_var_decl &x) const
generic visitor with output for extension
void operator()(const corr_matrix_var_decl &x) const
void operator()(const int_var_decl &x) const
bool operator()(const reject_statement &st) const
void generate_propto_default_function_body(const function_decl_def &fun, std::ostream &out)
generate_local_var_init_nan_visgen(bool declare_vars, bool is_var, bool is_fun_return, int indent, std::ostream &o)
void operator()(const double_var_decl &x) const
void operator()(ordered_var_decl const &x) const
void operator()(ordered_var_decl const &x) const
bool is_user_defined(const std::string &name, const std::vector< expression > &args)
var_size_validating_visgen(std::ostream &o, const std::string &stage)
void generate_increment(expression M, expression N, std::vector< expression > dims) const
const std::string MAJOR_VERSION
Major version number for Stan package.
void operator()(const lub_idx &i) const
void generate_var_resizing(const std::vector< var_decl > &vs, std::ostream &o)
void operator()(const nil &) const
void operator()(const nil &) const
void operator()(const cov_matrix_var_decl &x) const
void operator()(const ordered_var_decl &x) const
void operator()(double_var_decl const &x) const
bool operator()(const assignment &st) const
void generate_increment(std::vector< expression > dims) const
void operator()(nil const &) const
void operator()(const print_statement &ps) const
bool operator()(const print_statement &st) const
void operator()(ordered_var_decl const &x) const
void generate_public_decl(std::ostream &o)
void operator()(const vector_var_decl &x) const
void operator()(const corr_matrix_var_decl &x) const
bool operator()(const statements &st) const
void operator()(unit_vector_var_decl const &x) const
void operator()(cholesky_factor_var_decl const &x) const
void operator()(nil const &) const
bool operator()(const while_statement &st) const
void operator()(const cholesky_corr_var_decl &x) const
Placeholder struct for boost::variant default ctors.
void declare_array(std::string const &type, std::string const &name, size_t size) const
void operator()(cov_matrix_var_decl const &x) const
const std::string INDENT2(" ")
void operator()(const ordered_var_decl &x) const
set_param_ranges_visgen(std::ostream &o)
void generate_statement(statement const &s, int indent, std::ostream &o, bool include_sampling, bool is_var, bool is_fun_return)
void operator()(const int_var_decl &x) const
void operator()(const cholesky_factor_var_decl &x) const
void generate_include(const std::string &lib_name, std::ostream &o)
const std::vector< expression > EMPTY_EXP_VECTOR(0)
void operator()(const unit_vector_var_decl &x) const
void generate_arg_decl(bool gen_const, bool gen_ref, const arg_decl &decl, const std::string &scalar_t_name, std::ostream &out)
void operator()(const ordered_var_decl &x) const
bool operator()(const assgn &st) const
void generate_start_namespace(std::string name, std::ostream &o)
void operator()(const row_vector_var_decl &x) const
void operator()(int_var_decl const &x) const
void operator()(cholesky_corr_var_decl const &x) const
void generate_bare_type(const expr_type &t, const std::string &scalar_t_name, std::ostream &out)
void operator()(ordered_var_decl const &x) const
void operator()(const nil &) const
void generate_write_loop(const std::string &write_method_name, const std::string &var_name, const std::vector< expression > &dims) const
void operator()(const vector_var_decl &x) const
std::vector< printable > printables_
write_array_vars_visgen(std::ostream &o)
void operator()(const corr_matrix_var_decl &x) const
bool operator()(const nil &st) const
void operator()(const positive_ordered_var_decl &x) const
std::vector< var_decl > parameter_decl_
init_local_var_visgen(bool declare_vars, bool is_var, std::ostream &o)
void operator()(corr_matrix_var_decl const &x) const
void generate_class_decl(const std::string &model_name, std::ostream &o)
void generate_function_template_parameters(const function_decl_def &fun, bool is_rng, bool is_lp, bool is_log, std::ostream &out)
void operator()(const nil &) const
void generate_validate_positive(const std::string &var_name, const expression &expr, std::ostream &o)
void generate_init(const T &x) const
void operator()(const double_var_decl &x) const
void operator()(row_vector_var_decl const &x) const