Classes
struct	add_array_loop_identifier

struct	add_conditional_body

struct	add_conditional_condition

struct	add_expression_dimss

struct	add_fun_var

struct	add_function_signature

struct	add_idxs

struct	add_line_number

struct	add_loop_identifier

struct	add_matrix_loop_identifier

struct	add_params_var

struct	add_var

struct	add_while_body

struct	add_while_condition

struct	addition_expr3

struct	algebra_solver

struct	algebra_solver_control

struct	arg_decl

struct	array_expr

struct	assgn

struct	assign_lhs

struct	bare_type_grammar

struct	base_expr_type

struct	base_var_decl

struct	binary_op

struct	binary_op_expr

struct	break_continue_statement

struct	cholesky_corr_var_decl

struct	cholesky_factor_var_decl

struct	conditional_op

struct	conditional_statement

struct	constrained_param_names_visgen

struct	copy_square_cholesky_dimension_if_necessary

struct	corr_matrix_var_decl

struct	cov_matrix_var_decl

struct	data_only_expression

struct	deprecate_increment_log_prob

struct	deprecate_old_assignment_op

struct	deprecate_pound_comment

struct	deprecated_integrate_ode

struct	distribution

struct	division_expr

struct	double_literal

struct	double_type

struct	double_var_decl

struct	dump_member_var_visgen

struct	elt_division_expr

struct	elt_multiplication_expr

struct	empty_range

struct	exponentiation_expr

struct	expr_type

struct	expression

struct	expression07_grammar

struct	expression_as_statement

struct	expression_grammar

struct	expression_type_vis

struct	expression_visgen

struct	for_array_statement

struct	for_matrix_statement

struct	for_statement

struct	fun

struct	function_arg_type

struct	function_decl_def

struct	function_decl_defs

class	function_signatures

struct	functions_grammar

struct	has_non_param_var_vis

struct	has_var_vis

struct	idx

struct	idx_user_visgen

struct	idx_visgen

struct	ill_formed_type

struct	increment_log_prob_statement

struct	increment_size_t

struct	index_op

struct	index_op_sliced

struct	indexes_grammar

struct	infer_array_expr_type

struct	infer_vec_or_matrix_expr_type

struct	init_local_var_visgen

struct	init_vars_visgen

struct	init_visgen

struct	int_literal

struct	int_type

struct	int_var_decl

struct	integrate_ode

struct	integrate_ode_control

struct	is_multi_index_vis

struct	is_nil_vis

struct	is_no_op_statement_vis

struct	is_numbered_statement_vis

struct	is_prob_fun

struct	lb_idx

struct	left_division_expr

struct	local_var_decl_visgen

struct	local_var_init_nan_visgen

struct	located_exception

struct	logical_negate_expr

struct	lub_idx

struct	map_rect

struct	matrix_expr

struct	matrix_type

struct	matrix_var_decl

struct	member_var_decl_visgen

struct	modulus_expr

struct	multi_idx

struct	multiplication_expr

struct	name_vis

struct	negate_expr

struct	nil

struct	no_op_statement

struct	non_void_expression

struct	non_void_return_msg

struct	omni_idx

struct	ordered_var_decl

struct	phoenix_functor_binary

struct	phoenix_functor_quaternary

struct	phoenix_functor_quinary

struct	phoenix_functor_senary

struct	phoenix_functor_septenary

struct	phoenix_functor_ternary

struct	phoenix_functor_unary

struct	positive_ordered_var_decl

struct	print_statement

struct	printable

struct	printable_visgen

struct	program

struct	program_error

struct	program_grammar

struct	range

struct	reject_statement

struct	remove_loop_identifier

struct	remove_params_var

struct	require_vbar

struct	reset_var_scope

struct	return_statement

struct	returns_type_vis

struct	row_vector_expr

struct	row_vector_type

struct	row_vector_var_decl

struct	sample

class	scope

struct	set_allows_sampling_origin

struct	set_data_origin

struct	set_double_range_lower

struct	set_double_range_upper

struct	set_fun_params_scope

struct	set_fun_type_named

struct	set_int_range_lower

struct	set_int_range_upper

struct	set_lhs_var_assgn

struct	set_no_op

struct	set_omni_idx

struct	set_param_ranges_visgen

struct	set_var_scope

struct	set_var_scope_local

struct	set_var_type

struct	set_void_function

struct	set_void_return

struct	simplex_var_decl

struct	statement

struct	statement_2_grammar

struct	statement_grammar

struct	statement_visgen

struct	statements

struct	store_loop_identifier

struct	subtraction_expr3

struct	term_grammar

struct	trace

struct	transpose_expr

struct	ub_idx

struct	unary_op

struct	unconstrained_param_names_visgen

struct	uni_idx

struct	unit_vector_var_decl

struct	unscope_locals

struct	unscope_variables

struct	validate_algebra_solver

struct	validate_algebra_solver_control

struct	validate_allow_sample

struct	validate_assgn

struct	validate_conditional_op

struct	validate_decl_constraints

struct	validate_declarations

struct	validate_definition

struct	validate_double_expr

struct	validate_expr_type3

struct	validate_identifier

struct	validate_in_loop

struct	validate_int_data_expr

struct	validate_int_expr

struct	validate_int_expr_no_error_msgs

struct	validate_int_expr_silent

struct	validate_int_expression_warn

struct	validate_integrate_ode

struct	validate_integrate_ode_control

struct	validate_ints_expression

struct	validate_lhs_var_assgn

struct	validate_map_rect

struct	validate_no_constraints_vis

struct	validate_non_void_arg_function

struct	validate_non_void_expression

struct	validate_pmf_pdf_variate

struct	validate_prob_fun

struct	validate_return_allowed

struct	validate_return_type

struct	validate_sample

struct	validate_transformed_params_visgen

struct	validate_var_decl_visgen

struct	validate_void_return_allowed

struct	var_decl

struct	var_decl_base_type_vis

struct	var_decl_def_vis

struct	var_decl_dims_vis

struct	var_decl_has_def_vis

struct	var_decls_grammar

struct	var_occurs_vis

struct	var_resizing_visgen

struct	var_size_validating_visgen

struct	variable

struct	variable_dims

struct	variable_map

struct	vector_type

struct	vector_var_decl

struct	visgen

struct	void_type

struct	while_statement

struct	whitespace_grammar

struct	write_array_vars_visgen

struct	write_array_visgen

struct	write_dims_visgen

struct	write_param_names_visgen

Typedefs
typedef int	origin_block

typedef std::pair< expr_type, std::vector< function_arg_type > >	function_signature_t

typedef std::string::const_iterator	input_iterator_t

typedef boost::spirit::line_pos_iterator< input_iterator_t >	pos_iterator_t

Functions
std::ostream &	operator<< (std::ostream &o, const expr_type &et)

bool	ends_with (const std::string &suffix, const std::string &s)

bool	fun_name_exists (const std::string &name)

void	generate_expression (const expression &e, bool user_facing, std::ostream &o)

std::string	get_ccdf (const std::string &dist_name)

std::string	get_cdf (const std::string &dist_name)

std::string	get_prob_fun (const std::string &dist_name)

bool	has_ccdf_suffix (const std::string &name)

bool	has_cdf_suffix (const std::string &name)

bool	has_lp_suffix (const std::string &name)

bool	has_non_param_var (const expression &e, const variable_map &var_map)

bool	is_linear_function (const std::string &name)

bool	has_prob_fun_suffix (const std::string &name)

bool	has_rng_suffix (const std::string &name)

bool	has_var (const expression &e, const variable_map &var_map)

expr_type	indexed_type (const expression &e, const std::vector< idx > &idxs)

expr_type	infer_type_indexing (const base_expr_type &base_type, std::size_t dims, std::size_t num_indexes)

expr_type	infer_type_indexing (const expression &expr, std::size_t num_indexes)

expr_type	infer_type_indexing (const base_expr_type &expr_base_type, size_t num_expr_dims, size_t num_index_dims)

expr_type	infer_type_indexing (const expression &expr, size_t num_index_dims)

bool	is_assignable (const expr_type &l_type, const expr_type &r_type, const std::string &failure_message, std::ostream &error_msgs)

bool	is_multi_index (const idx &idx)

bool	is_nil (const expression &e)

bool	is_nonempty (const std::string &s)

bool	is_space (char c)

bool	is_user_defined (const fun &fx)

bool	is_user_defined (const std::string &name, const std::vector< expression > &args)

bool	is_user_defined_prob_function (const std::string &name, const expression &variate, const std::vector< expression > &params)

std::ostream &	operator<< (std::ostream &o, const function_arg_type &fa_type)

void	print_scope (std::ostream &o, const scope &var_scope)

expr_type	promote_primitive (const expr_type &et)

expr_type	promote_primitive (const expr_type &et1, const expr_type &et2)

bool	returns_type (const expr_type &return_type, const statement &statement, std::ostream &error_msgs)

std::string	strip_ccdf_suffix (const std::string &dist_fun)

std::string	strip_cdf_suffix (const std::string &dist_fun)

std::string	strip_prob_fun_suffix (const std::string &dist_fun)

std::size_t	total_dims (const std::vector< std::vector< expression > > &dimss)

std::ostream &	write_base_expr_type (std::ostream &o, base_expr_type type)

bool	is_binary_operator (const std::string &name)

bool	is_unary_operator (const std::string &name)

bool	is_unary_postfix_operator (const std::string &name)

bool	is_operator (const std::string &name)

std::string	fun_name_to_operator (const std::string &name)

void	print_signature (const std::string &name, const std::vector< expr_type > &arg_types, bool sampling_error_style, std::ostream &msgs)

void	print_signature (const std::string &name, const std::vector< function_arg_type > &arg_types, bool sampling_error_style, std::ostream &msgs)

bool	compile_functions (std::ostream *msgs, std::istream &stan_funcs_in, std::ostream &cpp_out, const std::vector< std::string > &namespaces, const bool allow_undefined=false, const std::string &filename="unknown file name", const std::vector< std::string > &include_paths=std::vector< std::string >())

bool	compile (std::ostream *msgs, std::istream &in, std::ostream &out, const std::string &name, const bool allow_undefined=false, const std::string &filename="unknown file name", const std::vector< std::string > &include_paths=std::vector< std::string >())

const std::string	EOL ("\n")

const std::string	EOL2 ("\n\n")

const std::string	INDENT (" ")

const std::string	INDENT2 (" ")

const std::string	INDENT3 (" ")

const std::vector< expression >	EMPTY_EXP_VECTOR (0)

const bool	USER_FACING (true)

const bool	NOT_USER_FACING (false)

void	generate_array_builder_adds (const std::vector< expression > &elements, bool user_facing, std::ostream &o)

void	generate_idxs (const std::vector< idx > &idxs, std::ostream &o)

void	generate_idxs_user (const std::vector< idx > &idxs, std::ostream &o)

std::string	fun_scalar_type (const function_decl_def &fun, bool is_lp)

void	generate_idx_user (const idx &i, std::ostream &o)

void	generate_arg_decl (bool gen_const, bool gen_ref, const arg_decl &decl, const std::string &scalar_t_name, std::ostream &o)

void	generate_array_var_type (const base_expr_type &base_type, const std::string &real_var_type, std::ostream &o)

void	generate_bare_type (const expr_type &t, const std::string &scalar_t_name, std::ostream &o)

void	generate_catch_throw_located (int indent, std::ostream &o)

void	generate_class_decl (const std::string &model_name, std::ostream &o)

void	generate_class_decl_end (std::ostream &o)

void	generate_comment (const std::string &msg, int indent, std::ostream &o)

void	generate_constrained_param_names_method (const program &prog, std::ostream &o)

void	generate_constructor (const program &prog, const std::string &model_name, std::ostream &o)

void	generate_cpp (const program &prog, const std::string &model_name, const std::vector< io::preproc_event > &history, std::ostream &o)

void	generate_destructor (const std::string &model_name, std::ostream &o)

void	generate_dims_method (const program &prog, std::ostream &o)

void	generate_eigen_index_expression (const expression &e, std::ostream &o)

void	generate_function_instantiation_template_parameters (const function_decl_def &fun, bool is_rng, bool is_lp, bool is_log, const std::string &rng_class, std::ostream &out)

void	generate_function (const function_decl_def &fun, std::ostream &out)

void	generate_function_arguments (const function_decl_def &fun, bool is_rng, bool is_lp, bool is_log, std::ostream &o, bool double_only=false, std::string rng_type="RNG", bool parameter_defaults=false)

void	generate_function_body (const function_decl_def &fun, const std::string &scalar_t_name, std::ostream &o)

void	generate_function_functor (const function_decl_def &fun, 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	generate_function_instantiation (const function_decl_def &fun, const std::vector< std::string > &namespaces, std::ostream &out)

void	generate_function_instantiation_body (const function_decl_def &fun, const std::vector< std::string > &namespaces, bool is_rng, bool is_lp, bool is_log, const std::string &rng_class, std::ostream &o)

void	generate_function_instantiation_name (const function_decl_def &fun, std::ostream &out)

void	generate_function_instantiations (const std::vector< function_decl_def > &funs, const std::vector< std::string > &namespaces, std::ostream &o)

void	generate_function_name (const function_decl_def &fun, 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	generate_functions (const std::vector< function_decl_def > &funs, std::ostream &o)

void	generate_functor_arguments (const function_decl_def &fun, bool is_rng, bool is_lp, bool is_log, std::ostream &o)

void	generate_globals (std::ostream &o)

void	generate_idx (const idx &i, std::ostream &o)

void	generate_idxs (size_t pos, const std::vector< idx > &idxs, std::ostream &o)

void	generate_include (const std::string &lib_name, std::ostream &o)

void	generate_includes (std::ostream &o)

void	generate_indent (size_t indent, std::ostream &o)

template<bool isLHS>
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_indexed_expr_user (const std::string &expr, const std::vector< expression > indexes, std::ostream &o)

void	generate_init_method (const std::vector< var_decl > &vs, std::ostream &o)

void	generate_initialization (std::ostream &o, size_t indent, 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_initializer (std::ostream &o, const std::string &base_type, const std::vector< expression > &dims, const expression &type_arg1=expression(), const expression &type_arg2=expression())

template<typename T >
void	generate_line_number (const T &line, int indent, std::ostream &o)

template void	generate_line_number (const var_decl &, int indent, std::ostream &o)

template void	generate_line_number (const statement &, int indent, std::ostream &o)

void	generate_local_var_decls (const std::vector< var_decl > &vs, int indent, std::ostream &o)

void	generate_local_var_inits (std::vector< var_decl > vs, bool declare_vars, int indent, std::ostream &o)

void	generate_log_prob (const program &p, std::ostream &o)

void	generate_member_var_decls (const std::vector< var_decl > &vs, int indent, std::ostream &o)

void	generate_member_var_decls_all (const program &prog, std::ostream &o)

void	generate_member_var_inits (const std::vector< var_decl > &vs, int indent, std::ostream &o)

void	generate_model_name_method (const std::string &model_name, std::ostream &o)

void	generate_model_typedef (const std::string &model_name, std::ostream &o)

void	generate_namespace_end (std::ostream &o)

void	generate_namespace_start (const std::string &name, std::ostream &o)

void	generate_param_names_method (const program &prog, std::ostream &o)

void	generate_printable (const printable &p, std::ostream &o)

void	generate_private_decl (std::ostream &o)

void	generate_program_reader_fun (const std::vector< io::preproc_event > &history, std::ostream &o)

void	generate_propto_default_function (const function_decl_def &fun, const std::string &scalar_t_name, std::ostream &o)

void	generate_propto_default_function_body (const function_decl_def &fun, std::ostream &o)

void	generate_public_decl (std::ostream &o)

void	generate_quoted_expression (const expression &e, std::ostream &o)

void	generate_quoted_string (const std::string &s, std::ostream &o)

void	generate_real_var_type (const scope &var_scope, bool has_var, std::ostream &o)

void	generate_register_mpi (const std::string &model_name, std::ostream &o)

void	generate_set_param_ranges (const std::vector< var_decl > &var_decls, int indent, std::ostream &o)

void	generate_standalone_functions (const program &prog, const std::vector< std::string > &namespaces, const std::vector< io::preproc_event > &history, std::ostream &o)

void	generate_statement (const statement &s, int indent, std::ostream &o)

void	generate_statements (const std::vector< statement > statements, int indent, std::ostream &o)

void	generate_try (int indent, std::ostream &o)

void	generate_type (const std::string &base_type, const std::vector< expression > &, size_t end, std::ostream &o)

void	generate_typedef (const std::string &type, const std::string &abbrev, std::ostream &o)

void	generate_typedefs (std::ostream &o)

void	generate_unconstrained_param_names_method (const program &prog, std::ostream &o)

void	generate_using (const std::string &type, std::ostream &o)

void	generate_using_namespace (const std::string &ns, std::ostream &o)

void	generate_usings (std::ostream &o)

void	generate_usings_standalone_functions (std::ostream &o)

void	generate_validate_context_size (size_t indent, 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	generate_validate_positive (const std::string &var_name, const expression &expr, int indents, std::ostream &o)

void	generate_validate_transformed_params (const std::vector< var_decl > &vs, int indent, std::ostream &o)

void	generate_validate_var_decl (const var_decl &decl, int indent, std::ostream &o)

void	generate_validate_var_decls (const std::vector< var_decl > decls, int indent, std::ostream &o)

void	generate_var_resizing (const std::vector< var_decl > &vs, int indent, std::ostream &o)

void	generate_version_comment (std::ostream &o)

void	generate_void_statement (const std::string &name, const size_t indent, std::ostream &o)

void	generate_write_array_method (const program &prog, const std::string &model_name, std::ostream &o)

template<typename D >
bool	has_lb (const D &x)

template<typename D >
bool	has_lub (const D &x)

bool	has_only_int_args (const function_decl_def &fun)

template<typename D >
bool	has_ub (const D &x)

void	generate_statement (const std::vector< statement > &ss, int indent, std::ostream &o)

template<typename T >
std::string	to_string (const T &x)

bool	has_prob_suffix (const std::string &s)

void	replace_suffix (const std::string &old_suffix, const std::string &new_suffix, fun &f)

void	set_fun_type (fun &fun, std::ostream &error_msgs)

int	num_dimss (std::vector< std::vector< stan::lang::expression > > &dimss)

template<class T >
void	validate_integrate_ode_non_control_args (const T &ode_fun, const variable_map &var_map, bool &pass, std::ostream &error_msgs)

template<class T >
void	validate_algebra_solver_non_control_args (const T &alg_fun, const variable_map &var_map, bool &pass, std::ostream &error_msgs)

void	qualify_builtins (fun &f)

bool	has_rng_lp_suffix (const std::string &s)

bool	deprecate_fun (const std::string &old_name, const std::string &new_name, fun &f, std::ostream &msgs)

bool	deprecate_suffix (const std::string &deprecated_suffix, const std::string &replacement, fun &f, std::ostream &msgs)

bool	is_double_return (const std::string &function_name, const std::vector< expr_type > &arg_types, std::ostream &error_msgs)

bool	is_univariate (const expr_type &et)

bool	can_assign_to_lhs_var (const std::string &lhs_var_name, const scope &var_scope, const variable_map &vm, std::ostream &error_msgs)

expr_type	infer_var_dims_type (const base_var_decl &var_type, const variable_dims &var_dims)

bool	has_same_shape (const expr_type &lhs_type, const expression &rhs_expr, const std::string &name, const std::string &stmt_type, std::ostream &error_msgs)

bool	fun_exists (const std::set< std::pair< std::string, function_signature_t > > &existing, const std::pair< std::string, function_signature_t > &name_sig, bool name_only=true)

void	dump_program_line (size_t idx_errline, int offset, const std::string &origin_file, size_t origin_line, const io::program_reader &reader, const std::vector< std::string > &program_lines, std::stringstream &error_msgs)

bool	parse (std::ostream *out, std::istream &in, const std::string &name, const io::program_reader &reader, program &prog, const bool allow_undefined=false)

template<typename E >
bool	is_type (const std::exception &e)

void	rethrow_located (const std::exception &e, int line, const io::program_reader &reader=stan::io::program_reader())

Variables
const int	model_name_origin = 0

const int	data_origin = 1

const int	transformed_data_origin = 2

const int	parameter_origin = 3

const int	transformed_parameter_origin = 4

const int	derived_origin = 5

const int	function_argument_origin = 6

const int	function_argument_origin_lp = 7

const int	function_argument_origin_rng = 8

const int	void_function_argument_origin = 9

const int	void_function_argument_origin_lp = 10

const int	void_function_argument_origin_rng = 11

const int	loop_identifier_origin = 12

boost::phoenix::function< assign_lhs >	assign_lhs_f

boost::phoenix::function< validate_expr_type3 >	validate_expr_type3_f

boost::phoenix::function< is_prob_fun >	is_prob_fun_f

boost::phoenix::function< addition_expr3 >	addition3_f

boost::phoenix::function< subtraction_expr3 >	subtraction3_f

boost::phoenix::function< increment_size_t >	increment_size_t_f

boost::phoenix::function< validate_conditional_op >	validate_conditional_op_f

boost::phoenix::function< binary_op_expr >	binary_op_f

boost::phoenix::function< validate_non_void_arg_function >	validate_non_void_arg_f

boost::phoenix::function< set_void_function >	set_void_function_f

boost::phoenix::function< set_allows_sampling_origin >	set_allows_sampling_origin_f

boost::phoenix::function< validate_declarations >	validate_declarations_f

boost::phoenix::function< add_function_signature >	add_function_signature_f

boost::phoenix::function< validate_return_type >	validate_return_type_f

boost::phoenix::function< validate_pmf_pdf_variate >	validate_pmf_pdf_variate_f

boost::phoenix::function< validate_prob_fun >	validate_prob_fun_f

boost::phoenix::function< set_fun_params_scope >	set_fun_params_scope_f

boost::phoenix::function< unscope_variables >	unscope_variables_f

boost::phoenix::function< add_fun_var >	add_fun_var_f

boost::phoenix::function< set_omni_idx >	set_omni_idx_f

boost::phoenix::function< validate_int_expr_silent >	validate_int_expr_silent_f

boost::phoenix::function< validate_int_expression_warn >	validate_int_expression_warn_f

boost::phoenix::function< validate_ints_expression >	validate_ints_expression_f

boost::phoenix::function< add_params_var >	add_params_var_f

boost::phoenix::function< remove_params_var >	remove_params_var_f

boost::phoenix::function< program_error >	program_error_f

boost::phoenix::function< add_conditional_condition >	add_conditional_condition_f

boost::phoenix::function< add_conditional_body >	add_conditional_body_f

boost::phoenix::function< deprecate_old_assignment_op >	deprecate_old_assignment_op_f

boost::phoenix::function< non_void_return_msg >	non_void_return_msg_f

boost::phoenix::function< validate_return_allowed >	validate_return_allowed_f

boost::phoenix::function< validate_void_return_allowed >	validate_void_return_allowed_f

boost::phoenix::function< set_lhs_var_assgn >	set_lhs_var_assgn_f

boost::phoenix::function< validate_lhs_var_assgn >	validate_lhs_var_assgn_f

boost::phoenix::function< validate_assgn >	validate_assgn_f

boost::phoenix::function< validate_sample >	validate_sample_f

boost::phoenix::function< expression_as_statement >	expression_as_statement_f

boost::phoenix::function< unscope_locals >	unscope_locals_f

boost::phoenix::function< add_while_condition >	add_while_condition_f

boost::phoenix::function< add_while_body >	add_while_body_f

boost::phoenix::function< add_loop_identifier >	add_loop_identifier_f

boost::phoenix::function< add_array_loop_identifier >	add_array_loop_identifier_f

boost::phoenix::function< add_matrix_loop_identifier >	add_matrix_loop_identifier_f

boost::phoenix::function< store_loop_identifier >	store_loop_identifier_f

boost::phoenix::function< remove_loop_identifier >	remove_loop_identifier_f

boost::phoenix::function< deprecate_increment_log_prob >	deprecate_increment_log_prob_f

boost::phoenix::function< validate_allow_sample >	validate_allow_sample_f

boost::phoenix::function< validate_non_void_expression >	validate_non_void_expression_f

boost::phoenix::function< set_void_return >	set_void_return_f

boost::phoenix::function< set_no_op >	set_no_op_f

boost::phoenix::function< deprecated_integrate_ode >	deprecated_integrate_ode_f

boost::phoenix::function< validate_integrate_ode >	validate_integrate_ode_f

boost::phoenix::function< validate_integrate_ode_control >	validate_integrate_ode_control_f

boost::phoenix::function< validate_algebra_solver >	validate_algebra_solver_f

boost::phoenix::function< validate_algebra_solver_control >	validate_algebra_solver_control_f

boost::phoenix::function< validate_map_rect >	validate_map_rect_f

boost::phoenix::function< set_fun_type_named >	set_fun_type_named_f

boost::phoenix::function< infer_array_expr_type >	infer_array_expr_type_f

boost::phoenix::function< infer_vec_or_matrix_expr_type >	infer_vec_or_matrix_expr_type_f

boost::phoenix::function< exponentiation_expr >	exponentiation_f

boost::phoenix::function< multiplication_expr >	multiplication_f

boost::phoenix::function< division_expr >	division_f

boost::phoenix::function< modulus_expr >	modulus_f

boost::phoenix::function< left_division_expr >	left_division_f

boost::phoenix::function< elt_multiplication_expr >	elt_multiplication_f

boost::phoenix::function< elt_division_expr >	elt_division_f

boost::phoenix::function< negate_expr >	negate_expr_f

boost::phoenix::function< logical_negate_expr >	logical_negate_expr_f

boost::phoenix::function< transpose_expr >	transpose_f

boost::phoenix::function< add_idxs >	add_idxs_f

boost::phoenix::function< add_expression_dimss >	add_expression_dimss_f

boost::phoenix::function< set_var_type >	set_var_type_f

boost::phoenix::function< require_vbar >	require_vbar_f

boost::phoenix::function< add_line_number >	add_line_number_f

boost::phoenix::function< validate_decl_constraints >	validate_decl_constraints_f

boost::phoenix::function< validate_definition >	validate_definition_f

boost::phoenix::function< validate_identifier >	validate_identifier_f

boost::phoenix::function< copy_square_cholesky_dimension_if_necessary >	copy_square_cholesky_dimension_if_necessary_f

boost::phoenix::function< empty_range >	empty_range_f

boost::phoenix::function< validate_int_expr >	validate_int_expr_f

boost::phoenix::function< validate_int_expr_no_error_msgs >	validate_int_expr_no_error_msgs_f

boost::phoenix::function< set_int_range_lower >	set_int_range_lower_f

boost::phoenix::function< set_int_range_upper >	set_int_range_upper_f

boost::phoenix::function< validate_int_data_expr >	validate_int_data_expr_f

boost::phoenix::function< validate_double_expr >	validate_double_expr_f

boost::phoenix::function< set_double_range_lower >	set_double_range_lower_f

boost::phoenix::function< set_double_range_upper >	set_double_range_upper_f

boost::phoenix::function< add_var >	add_var_f

boost::phoenix::function< validate_in_loop >	validate_in_loop_f

boost::phoenix::function< non_void_expression >	non_void_expression_f

boost::phoenix::function< set_var_scope >	set_var_scope_f

boost::phoenix::function< set_data_origin >	set_data_origin_f

boost::phoenix::function< set_var_scope_local >	set_var_scope_local_f

boost::phoenix::function< reset_var_scope >	reset_var_scope_f

boost::phoenix::function< trace >	trace_f

boost::phoenix::function< deprecate_pound_comment >	deprecate_pound_comment_f

Typedef Documentation

typedef std::pair<expr_type, std::vector<function_arg_type> > stan::lang::function_signature_t

The type of a function signature, mapping a vector of argument expression types to a result expression type.

Definition at line 17 of file function_signature_t.hpp.

typedef std::string::const_iterator stan::lang::input_iterator_t

Definition at line 10 of file iterator_typedefs.hpp.

typedef int stan::lang::origin_block

The type of a variable indicating where a variable was declared. This is a typedef rather than an enum to get around forward declaration issues with enums in header files.

Definition at line 11 of file origin_block.hpp.

typedef boost::spirit::line_pos_iterator<input_iterator_t> stan::lang::pos_iterator_t

Definition at line 11 of file iterator_typedefs.hpp.

Function Documentation

bool stan::lang::can_assign_to_lhs_var	(	const std::string &	lhs_var_name,
		const scope &	var_scope,
		const variable_map &	vm,
		std::ostream &	error_msgs
	)

Definition at line 148 of file semantic_actions_def.cpp.

References allTimeWatchdog::endl, stan::lang::variable_map::exists(), stan::lang::scope::fun(), stan::lang::variable_map::get_scope(), stan::lang::scope::is_local(), loop_identifier_origin, print_scope(), stan::lang::scope::program_block(), and string.

Referenced by stan::lang::validate_lhs_var_assgn::operator()().

                                                        {
       if (lhs_var_name == std::string("lp__")) {
         error_msgs << std::endl
                    << "Error (fatal):  Use of lp__ is no longer supported."
                    << std::endl
                    << "  Use target += ... statement to increment log density."
                    << std::endl;
         return false;
       }
       if (!vm.exists(lhs_var_name)) {
         error_msgs << "Unknown variable in assignment"
                    << "; lhs variable=" << lhs_var_name
                    << std::endl;
         return false;
       }
       scope lhs_origin = vm.get_scope(lhs_var_name);
       // enforce constancy of loop variables
       if (lhs_origin.program_block() == loop_identifier_origin) {
         error_msgs << "Loop variable " << lhs_var_name
                    << " cannot be used on left side of assignment statement."
                    << std::endl;
         return false;
       }
       // enforce constancy of function args
       if (!lhs_origin.is_local() && lhs_origin.fun()) {
         error_msgs << "Cannot assign to function argument variables."
                    << std::endl
                    << "Use local variables instead."
                    << std::endl;
         return false;
       }
       if (lhs_origin.program_block() != var_scope.program_block()) {
         error_msgs << "Cannot assign to variable outside of declaration block"
                    << "; left-hand-side variable origin=";
         print_scope(error_msgs, lhs_origin);
         error_msgs << std::endl;
         return false;
       }
       return true;
     }

bool stan::lang::compile	(	std::ostream *	msgs,
		std::istream &	in,
		std::ostream &	out,
		const std::string &	name,
		const bool	allow_undefined = `false`,
		const std::string &	filename = `"unknown file name"`,
		const std::vector< std::string > &	include_paths = `std::vector<std::string>()`
	)

Read a Stan model specification from the specified input, parse it, and write the C++ code for it to the specified output, allowing undefined function declarations if the flag is set to true and searching the specified include path for included files.

Parameters

msgs	Output stream for warning messages
in	Stan model specification
out	C++ code output stream
name	Name of model class
allow_undefined	true if permits undefined functions
filename	name of file or other source from which input stream was derived
include_paths	array of paths to search for included files

Returns: false if code could not be generated due to syntax error in the Stan model; true otherwise.

Definition at line 35 of file compiler.hpp.

References shutoffs::filename, generate_cpp(), stan::io::program_reader::history(), confusionMatrixTree::out, parse(), cacheDefinitionData::prog, stan::io::program_reader::program(), ss, and string.

Referenced by expect_match(), stanc_helper(), and TEST().

                                             {
       io::program_reader reader(in, filename, include_paths);
       std::string s = reader.program();
       std::stringstream ss(s);
       program prog;
       bool parse_succeeded = parse(msgs, ss, name, reader, prog,
                                    allow_undefined);
       if (!parse_succeeded)
         return false;
       generate_cpp(prog, name, reader.history(), out);
       return true;
     }

bool stan::lang::compile_functions	(	std::ostream *	msgs,
		std::istream &	stan_funcs_in,
		std::ostream &	cpp_out,
		const std::vector< std::string > &	namespaces,
		const bool	allow_undefined = `false`,
		const std::string &	filename = `"unknown file name"`,
		const std::vector< std::string > &	include_paths = `std::vector<std::string>()`
	)

Read a Stan file with only the functions block from the specified input, parse it, and write the C++ code for it to the specified output.

Parameters

[in]	msgs	Output stream for warning messages
[in]	stan_funcs_in	Stan model specification
[in]	cpp_out	C++ code output stream
[in]	namespaces	Vector of namespace to generate the functions in
[in]	allow_undefined	Permit undefined functions?
	filename	name of file or other source from which input stream was derived
	include_paths	array of paths to search for included files

Returns: false if code could not be generated due to syntax error in the functions file; true otherwise.

Definition at line 31 of file compile_functions.hpp.

References shutoffs::filename, generate_standalone_functions(), stan::io::program_reader::history(), parse(), cacheDefinitionData::prog, stan::io::program_reader::program(), ss, and string.

Referenced by stanc_helper().

                                                      {
       io::program_reader reader(stan_funcs_in, filename, include_paths);
       std::string s = reader.program();
       std::stringstream ss(s);
       program prog;
 
       std::string name("functions_only_model");
 
       bool parsed_ok = parse(msgs, ss, name, reader, prog, allow_undefined);
       if (!parsed_ok)
         return false;  // syntax error in program
 
       generate_standalone_functions(prog, namespaces,
                                     reader.history(), cpp_out);
       return true;
     }

bool stan::lang::deprecate_fun	(	const std::string &	old_name,
		const std::string &	new_name,
		fun &	f,
		std::ostream &	msgs
	)

Definition at line 97 of file semantic_actions_def.cpp.

References allTimeWatchdog::endl, stan::lang::fun::name_, and stan::lang::fun::original_name_.

Referenced by stan::lang::set_fun_type_named::operator()().

                                                  {
       if (f.name_ != old_name) return false;
       f.original_name_ = f.name_;
       f.name_ = new_name;
       msgs << "Warning: Function name '" << old_name << "' is deprecated"
            << " and will be removed in a later release; please replace"
            << " with '" << new_name << "'" << std::endl;
       return true;
     }

bool stan::lang::deprecate_suffix	(	const std::string &	deprecated_suffix,
		const std::string &	replacement,
		fun &	f,
		std::ostream &	msgs
	)

Definition at line 108 of file semantic_actions_def.cpp.

References allTimeWatchdog::endl, ends_with(), and stan::lang::fun::name_.

Referenced by stan::lang::set_fun_type_named::operator()().

                                             {
       if (!ends_with(deprecated_suffix, f.name_)) return false;
       msgs << "Warning: Deprecated function '" << f.name_ << "';"
            << " please replace suffix '" << deprecated_suffix
            << "' with " << replacement << std::endl;
       return true;
     }

void stan::lang::dump_program_line	(	size_t	idx_errline,
		int	offset,
		const std::string &	origin_file,
		size_t	origin_line,
		const io::program_reader &	reader,
		const std::vector< std::string > &	program_lines,
		std::stringstream &	error_msgs
	)

Definition at line 844 of file semantic_actions_def.cpp.

References allTimeWatchdog::endl, novadaq::HexUtils::format(), submit_syst::str, string, and stan::io::program_reader::trace().

Referenced by stan::lang::program_error::operator()().

                                                         {
       boost::format fmt_lineno("%6d: ");
       if (idx_errline + offset > 0
           && idx_errline + offset < program_lines.size()) {
         io::program_reader::trace_t trace = reader.trace(idx_errline + offset);
         if (trace[trace.size() - 1].first == origin_file) {
           std::string lineno = str(fmt_lineno % (origin_line + offset));
           error_msgs << lineno << program_lines[idx_errline + offset - 1]
                      << std::endl;
         }
       }
     }

const std::vector<expression> stan::lang::EMPTY_EXP_VECTOR ( 0 )

Size zero vector of expressions.

Referenced by stan::lang::write_dims_visgen::operator()(), stan::lang::unconstrained_param_names_visgen::operator()(), stan::lang::constrained_param_names_visgen::operator()(), stan::lang::write_array_vars_visgen::operator()(), stan::lang::write_array_visgen::operator()(), and stan::lang::init_local_var_visgen::operator()().

bool stan::lang::ends_with	(	const std::string &	suffix,
		const std::string &	s
	)

Returns true if the specified suffix appears at the end of the specified string.

Parameters

suffix	suffix to test
s	string in which to search

Returns: true if the string ends with the suffix

Definition at line 10 of file ends_with_def.hpp.

Referenced by deprecate_suffix(), Expression::fetch(), generate_function(), generate_function_functor(), generate_function_instantiation(), stan::lang::function_signatures::get_result_type(), has_ccdf_suffix(), has_cdf_suffix(), has_prob_fun_suffix(), has_prob_suffix(), has_rng_lp_suffix(), stan::lang::set_allows_sampling_origin::operator()(), stan::lang::add_function_signature::operator()(), stan::lang::validate_return_type::operator()(), stan::lang::validate_pmf_pdf_variate::operator()(), stan::lang::validate_sample::operator()(), replace_suffix(), strip_ccdf_suffix(), strip_cdf_suffix(), and strip_prob_fun_suffix().

                                                                 {
       size_t idx = s.rfind(suffix);
       return idx != std::string::npos && idx == (s.size() - suffix.size());
     }

const std::string stan::lang::EOL ( "\n" )

End-of-line marker.

const std::string stan::lang::EOL2 ( "\n\n" )

Sequence of two end-of-line markers.

Referenced by generate_class_decl_end(), generate_constrained_param_names_method(), generate_constructor(), generate_destructor(), generate_dims_method(), generate_function_body(), generate_function_functor(), generate_globals(), generate_init_method(), generate_local_var_inits(), generate_log_prob(), generate_model_name_method(), generate_model_typedef(), generate_namespace_end(), generate_namespace_start(), generate_param_names_method(), generate_unconstrained_param_names_method(), generate_version_comment(), and generate_write_array_method().

bool stan::lang::fun_exists	(	const std::set< std::pair< std::string, function_signature_t > > &	existing,
		const std::pair< std::string, function_signature_t > &	name_sig,
		bool	name_only = `true`
	)

Definition at line 511 of file semantic_actions_def.cpp.

References it, and string.

Referenced by stan::lang::add_function_signature::operator()().

                                            {
       for (std::set<std::pair<std::string,
              function_signature_t> >::const_iterator it
              = existing.begin();
            it != existing.end();
            ++it) {
         if (name_sig.first == (*it).first
             && (name_only
                 || name_sig.second.second == (*it).second.second))
           return true;  // name and arg sequences match
       }
       return false;
     }

bool stan::lang::fun_name_exists ( const std::string & name )

Return true if the function name has been declared as a built-in or by the user.

Parameters

name	name of function

Returns: true if it has been declared

Definition at line 10 of file fun_name_exists_def.hpp.

References stan::lang::function_signatures::has_key(), and stan::lang::function_signatures::instance().

Referenced by stan::lang::validate_prob_fun::operator()().

                                                 {
       return function_signatures::instance().has_key(name);
     }

std::string stan::lang::fun_name_to_operator ( const std::string & name )

Definition at line 321 of file function_signatures_def.hpp.

Referenced by stan::lang::function_signatures::get_result_type(), and TEST().

                                                           {
       // binary infix (pow handled by parser)
       if (name == "add") return "+";
       if (name == "subtract") return "-";
       if (name == "multiply") return "*";
       if (name == "divide") return "/";
       if (name == "modulus") return "%";
       if (name == "mdivide_left") return "\\";
       if (name == "mdivide_right") return "/";
       if (name == "elt_multiply") return ".*";
       if (name == "elt_divide") return "./";
 
       // unary prefix (+ handled by parser)
       if (name == "minus") return "-";
       if (name == "logical_negation") return "!";
 
       // unary suffix
       if (name == "transpose") return "'";
 
       // none of the above
       return "ERROR";
     }

std::string stan::lang::fun_scalar_type	(	const function_decl_def &	fun,
		bool	is_lp
	)

Return the string representing the scalar type to use in the body of the specified function declaration, with a flag indicating if the function is a log probability function.

Parameters

[in]	fun	function declaration
[in]	is_lp	true if the function is a log probability function

Returns: string representing scalar type to use within the function body

Definition at line 24 of file fun_scalar_type.hpp.

References stan::lang::function_decl_def::arg_decls_, has_only_int_args(), MECModelEnuComparisons::i, and ss.

Referenced by generate_function(), and generate_function_functor().

                                                                         {
       size_t num_args = fun.arg_decls_.size();
       // nullary, non-lp
       if (has_only_int_args(fun) && !is_lp)
         return "double";
 
       // need template metaprogram to construct return
       std::stringstream ss;
       ss << "typename boost::math::tools::promote_args<";
       int num_open_brackets = 1;
       int num_generated_params = 0;
       for (size_t i = 0; i < num_args; ++i) {
         if (!fun.arg_decls_[i].arg_type_.base_type_.is_int_type()) {
           if (num_generated_params > 0)
             ss << ", ";
           // break into blocks of 4 and apply promotion recursively
           // setting at 4 leaves room for an extra parameter at the end
           if (num_generated_params == 4) {
             ss << "typename boost::math::tools::promote_args<";
             num_generated_params = 0;
             ++num_open_brackets;
           }
           ss << "T" << i << "__";
           ++num_generated_params;
         }
       }
       if (is_lp) {
         if (num_generated_params > 0)
           ss << ", ";
         ss << "T_lp__";
       }
       for (int i = 0; i < num_open_brackets; ++i)
         ss << ">::type";
       return ss.str();
     }

void stan::lang::generate_arg_decl	(	bool	gen_const,
		bool	gen_ref,
		const arg_decl &	decl,
		const std::string &	scalar_t_name,
		std::ostream &	o
	)

Generate the argument declaration for a function with flags indicating whether to generate a const qualifer and whether to make the variable a reference, for the specified declaration and scalar type name from context, writing to the specified stream.

Parameters

[in]	gen_const	true if declaration is for const
[in]	gen_ref	true if declaration is for reference
[in]	decl	argument declaration
[in]	scalar_t_name	string representing context scalar type
[in,out]	o	stream for writing

Definition at line 26 of file generate_arg_decl.hpp.

References stan::lang::arg_decl::arg_type_, generate_bare_type(), and stan::lang::arg_decl::name_.

Referenced by generate_function_arguments().

                                                                           {
       if (gen_const) o << "const ";
       generate_bare_type(decl.arg_type_, scalar_t_name, o);
       if (gen_ref) o << "&";
       o << " " << decl.name_;
     }

void stan::lang::generate_array_builder_adds	(	const std::vector< expression > &	elements,
		bool	user_facing,
		std::ostream &	o
	)

Recursive helper function for array, matrix, and row_vector expressions which generates chain of calls to math lib array_builder add function for each of the contained elements.

Parameters

[in]	elements	vector of expression elements to generate
[in]	user_facing	true if expression might be reported to user
[in,out]	o	stream for generating

Definition at line 20 of file generate_array_builder_adds.hpp.

References generate_expression(), and MECModelEnuComparisons::i.

Referenced by stan::lang::expression_visgen::operator()(), and TEST().

                                                     {
       for (size_t i = 0; i < elements.size(); ++i) {
         o << ".add(";
         generate_expression(elements[i], user_facing, o);
         o << ")";
       }
     }

void stan::lang::generate_array_var_type	(	const base_expr_type &	base_type,
		const std::string &	real_var_type,
		std::ostream &	o
	)

Generate C++ type for array expressions according to context in which expression appears.

Parameters

[in]	base_type	expression base type
[in]	real_var_type	context-dependent `real` type
[in,out]	o	generated typename

Definition at line 19 of file generate_array_var_type.hpp.

References stan::lang::base_expr_type::is_double_type(), stan::lang::base_expr_type::is_int_type(), stan::lang::base_expr_type::is_matrix_type(), stan::lang::base_expr_type::is_row_vector_type(), and stan::lang::base_expr_type::is_vector_type().

Referenced by stan::lang::expression_visgen::operator()(), and TEST().

                                                 {
       if (base_type.is_int_type())
         o << "int";
       else if (base_type.is_double_type())
         o << real_var_type;
       else if (base_type.is_vector_type())
         o << "Eigen::Matrix<" << real_var_type << ",Eigen::Dynamic,1> ";
       else if (base_type.is_row_vector_type())
         o << "Eigen::Matrix<" << real_var_type << ",1,Eigen::Dynamic> ";
       else if (base_type.is_matrix_type())
         o << "Eigen::Matrix<" << real_var_type
           << ",Eigen::Dynamic,Eigen::Dynamic> ";
     }

void stan::lang::generate_bare_type	(	const expr_type &	t,
		const std::string &	scalar_t_name,
		std::ostream &	o
	)

Generate the basic type for the specified expression type without dimensions, using the specified scalar type string, writing to the specified stream.

Parameters

[in]	t	expression type
[in]	scalar_t_name	name of scalar type for double values and containers
[in]	o	stream for generating

Definition at line 22 of file generate_bare_type.hpp.

References stan::lang::expr_type::base_type_, d, stan::lang::base_expr_type::is_double_type(), stan::lang::base_expr_type::is_int_type(), stan::lang::base_expr_type::is_matrix_type(), stan::lang::base_expr_type::is_row_vector_type(), stan::lang::base_expr_type::is_vector_type(), stan::lang::base_expr_type::is_void_type(), and stan::lang::expr_type::num_dims_.

Referenced by generate_arg_decl(), and generate_function_inline_return_type().

                                            {
       for (size_t d = 0; d < t.num_dims_; ++d)
         o << "std::vector<";
       bool is_template_type = false;
       if (t.base_type_.is_int_type()) {
         o << "int";
         is_template_type = false;
       } else if (t.base_type_.is_double_type()) {
         o << scalar_t_name;
         is_template_type = false;
       } else if (t.base_type_.is_vector_type()) {
         o << "Eigen::Matrix<"
           << scalar_t_name
           << ", Eigen::Dynamic,1>";
         is_template_type = true;
       } else if (t.base_type_.is_row_vector_type()) {
         o << "Eigen::Matrix<"
           << scalar_t_name
           << ", 1,Eigen::Dynamic>";
         is_template_type = true;
       } else if (t.base_type_.is_matrix_type()) {
         o << "Eigen::Matrix<"
           << scalar_t_name
           << ", Eigen::Dynamic,Eigen::Dynamic>";
         is_template_type = true;
       } else if (t.base_type_.is_void_type()) {
         o << "void";
       } else {
         o << "UNKNOWN TYPE";
       }
       for (size_t d = 0; d < t.num_dims_; ++d) {
         if (d > 0 || is_template_type)
           o << " ";
         o << ">";
       }
     }

void stan::lang::generate_catch_throw_located	(	int	indent,
		std::ostream &	o
	)

Generate code to catch and rethrow an exception that includes location information read out of the generated context.

Parameters

[in]	indent	indentation level
[in,out]	o	stream for generating.

Definition at line 20 of file generate_catch_throw_located.hpp.

References EOL(), generate_comment(), and generate_indent().

Referenced by generate_constructor(), generate_function_body(), generate_log_prob(), and generate_write_array_method().

                                                                  {
       generate_indent(indent, o);
       o << "} catch (const std::exception& e) {" << EOL;
       generate_indent(indent + 1, o);
       o << "stan::lang::rethrow_located(e, current_statement_begin__"
         << ", prog_reader__());"
         << EOL;
       generate_comment("Next line prevents compiler griping about no return",
                        indent + 1, o);
       generate_indent(indent + 1, o);
       o << "throw std::runtime_error"
         << "(\"*** IF YOU SEE THIS, PLEASE REPORT A BUG ***\");" << EOL;
       generate_indent(indent, o);
       o << "}" << EOL;
     }

void stan::lang::generate_class_decl	(	const std::string &	model_name,
		std::ostream &	o
	)

Generate the specified name for the model class to the specified stream.

Parameters

[in]	model_name	name of class
[in,out]	o	stream for generating

Definition at line 19 of file generate_class_decl.hpp.

References EOL().

Referenced by generate_cpp().

                                             {
       o << "class " << model_name << " : public prob_grad {" << EOL;
     }

void stan::lang::generate_class_decl_end ( std::ostream & o )

Definition at line 11 of file generate_class_decl_end.hpp.

References EOL2().

Referenced by generate_cpp().

                                                 {
       o << "}; // model" << EOL2;
     }

void stan::lang::generate_comment	(	const std::string &	msg,
		int	indent,
		std::ostream &	o
	)

Generate the specified message as a comment with the specified indentation and an end-of-line.

Parameters

[in]	msg	text of comment
[in]	indent	indentation level
[in,out]	o	stream for generating

Definition at line 19 of file generate_comment.hpp.

References EOL(), and generate_indent().

Referenced by generate_catch_throw_located(), generate_constructor(), generate_log_prob(), generate_validate_transformed_params(), and generate_write_array_method().

                                          {
       generate_indent(indent, o);
       o << "// " << msg        << EOL;
     }

void stan::lang::generate_constrained_param_names_method	(	const program &	prog,
		std::ostream &	o
	)

Generate the constrained_param_names method for the specified program on the specified stream.

Parameters

[in]	prog	program from which to generate
[in,out]	o	stream for generating

Definition at line 20 of file generate_constrained_param_names_method.hpp.

References stan::lang::program::derived_decl_, EOL(), EOL2(), stan::lang::program::generated_decl_, MECModelEnuComparisons::i, INDENT(), INDENT2(), and stan::lang::program::parameter_decl_.

Referenced by generate_cpp().

                                                                 {
       o << EOL << INDENT
         << "void constrained_param_names("
         << "std::vector<std::string>& param_names__,"
         << EOL << INDENT
         << "                             bool include_tparams__ = true,"
         << EOL << INDENT
         << "                             bool include_gqs__ = true) const {"
         << EOL << INDENT2
         << "std::stringstream param_name_stream__;" << EOL;
       constrained_param_names_visgen vis1(1, o);
       constrained_param_names_visgen vis2(2, o);
       for (size_t i = 0; i < prog.parameter_decl_.size(); ++i)
         boost::apply_visitor(vis1, prog.parameter_decl_[i].decl_);
       o << EOL << INDENT2
         << "if (!include_gqs__ && !include_tparams__) return;" << EOL;
       o << EOL << INDENT2 << "if (include_tparams__) {"  << EOL;
       for (size_t i = 0; i < prog.derived_decl_.first.size(); ++i)
         boost::apply_visitor(vis2, prog.derived_decl_.first[i].decl_);
       o << INDENT2 << "}" << EOL2;
       o << EOL << INDENT2 << "if (!include_gqs__) return;" << EOL;
       for (size_t i = 0; i < prog.generated_decl_.first.size(); ++i)
         boost::apply_visitor(vis1, prog.generated_decl_.first[i].decl_);
       o << INDENT << "}" << EOL2;
     }

void stan::lang::generate_constructor	(	const program &	prog,
		const std::string &	model_name,
		std::ostream &	o
	)

Generate the constructors for the specified program with the specified model name to the specified stream.

Parameters

[in]	prog	program from which to generate
[in]	model_name	name of model for class name
[in,out]	o	stream for generating

Definition at line 31 of file generate_constructor.hpp.

References stan::lang::program::data_decl_, stan::lang::program::derived_data_decl_, EOL(), EOL2(), generate_catch_throw_located(), generate_comment(), generate_member_var_inits(), generate_set_param_ranges(), generate_statements(), generate_try(), generate_validate_var_decls(), generate_var_resizing(), generate_void_statement(), INDENT(), INDENT2(), and stan::lang::program::parameter_decl_.

Referenced by generate_cpp().

                                                                           {
       // constructor without seed or template parameter
       o << INDENT << model_name << "(stan::io::var_context& context__," << EOL;
       o << INDENT << "    std::ostream* pstream__ = 0)" << EOL;
       o << INDENT2 << ": prob_grad(0) {" << EOL;
       o << INDENT2 << "ctor_body(context__, 0, pstream__);" << EOL;
       o << INDENT << "}" << EOL2;
       // constructor with specified seed
       o << INDENT << model_name << "(stan::io::var_context& context__," << EOL;
       o << INDENT << "    unsigned int random_seed__," << EOL;
       o << INDENT << "    std::ostream* pstream__ = 0)" << EOL;
       o << INDENT2 << ": prob_grad(0) {" << EOL;
       o << INDENT2 << "ctor_body(context__, random_seed__, pstream__);" << EOL;
       o << INDENT << "}" << EOL2;
       // body of constructor now in function
       o << INDENT << "void ctor_body(stan::io::var_context& context__," << EOL;
       o << INDENT << "               unsigned int random_seed__," << EOL;
       o << INDENT << "               std::ostream* pstream__) {" << EOL;
       o << INDENT2 << "typedef double local_scalar_t__;" << EOL2;
 
       o << INDENT2 << "boost::ecuyer1988 base_rng__ =" << EOL;
       o << INDENT2 << "  stan::services::util::create_rng(random_seed__, 0);"
         << EOL;
       o << INDENT2 << "(void) base_rng__;  // suppress unused var warning"
         << EOL2;
       o << INDENT2 << "current_statement_begin__ = -1;" << EOL2;
 
       o << INDENT2 << "static const char* function__ = \""
         << model_name << "_namespace::" << model_name << "\";" << EOL;
       generate_void_statement("function__", 2, o);
       o << INDENT2 << "size_t pos__;" << EOL;
       generate_void_statement("pos__", 2, o);
       o << INDENT2 << "std::vector<int> vals_i__;" << EOL;
       o << INDENT2 << "std::vector<double> vals_r__;" << EOL;
       o << INDENT2
         << "local_scalar_t__ DUMMY_VAR__"
         << "(std::numeric_limits<double>::quiet_NaN());"
         << EOL;
       o << INDENT2 << "(void) DUMMY_VAR__;  // suppress unused var warning"
         << EOL2;
       o << INDENT2 << "// initialize member variables" << EOL;
       generate_try(2, o);
       generate_member_var_inits(prog.data_decl_, 3, o);
       o << EOL;
       generate_comment("validate, data variables", 3, o);
       generate_validate_var_decls(prog.data_decl_, 3, o);
       generate_comment("initialize data variables", 3, o);
       generate_var_resizing(prog.derived_data_decl_.first, 3, o);
       o << EOL;
       generate_statements(prog.derived_data_decl_.second, 3, o);
       o << EOL;
       generate_comment("validate transformed data", 3, o);
       generate_validate_var_decls(prog.derived_data_decl_.first, 3, o);
       o << EOL;
       generate_comment("validate, set parameter ranges", 3, o);
       generate_set_param_ranges(prog.parameter_decl_, 3, o);
       generate_catch_throw_located(2, o);
       o << INDENT << "}" << EOL;
     }

void stan::lang::generate_cpp	(	const program &	prog,
		const std::string &	model_name,
		const std::vector< io::preproc_event > &	history,
		std::ostream &	o
	)

Generae the C++ code for the specified program, generating it in a class and namespace derived from the specified model name, writing to the specified stream.

Parameters

[in]	prog	program from which to generate
[in]	model_name	name of model for generating namespace and class name
[in]	history	I/O include history for text underlying program
[in,out]	o	stream for generating

Definition at line 51 of file generate_cpp.hpp.

References stan::lang::program::function_decl_defs_, generate_class_decl(), generate_class_decl_end(), generate_constrained_param_names_method(), generate_constructor(), generate_destructor(), generate_dims_method(), generate_functions(), generate_globals(), generate_includes(), generate_init_method(), generate_log_prob(), generate_member_var_decls_all(), generate_model_name_method(), generate_model_typedef(), generate_namespace_end(), generate_namespace_start(), generate_param_names_method(), generate_private_decl(), generate_program_reader_fun(), generate_public_decl(), generate_register_mpi(), generate_unconstrained_param_names_method(), generate_usings(), generate_version_comment(), generate_write_array_method(), and stan::lang::program::parameter_decl_.

Referenced by compile(), model_to_cpp(), and TEST().

                                      {
       generate_version_comment(o);
       generate_includes(o);
       generate_namespace_start(model_name, o);
       generate_usings(o);
       //      generate_typedefs(o);
       generate_globals(o);
       generate_program_reader_fun(history, o);
       generate_functions(prog.function_decl_defs_, o);
       generate_class_decl(model_name, o);
       generate_private_decl(o);
       generate_member_var_decls_all(prog, o);
       generate_public_decl(o);
       generate_constructor(prog, model_name, o);
       generate_destructor(model_name, o);
       // put back if ever need integer params
       // generate_set_param_ranges(prog.parameter_decl_, o);
       generate_init_method(prog.parameter_decl_, o);
       generate_log_prob(prog, o);
       generate_param_names_method(prog, o);
       generate_dims_method(prog, o);
       generate_write_array_method(prog, model_name, o);
       generate_model_name_method(model_name, o);
       generate_constrained_param_names_method(prog, o);
       generate_unconstrained_param_names_method(prog, o);
       generate_class_decl_end(o);
       generate_namespace_end(o);
       generate_model_typedef(model_name, o);
       generate_register_mpi(model_name, o);
     }

void stan::lang::generate_destructor	(	const std::string &	model_name,
		std::ostream &	o
	)

Generate the destructor for the class with name specified by the model name to the specified stream.

Parameters

[in]	model_name	name of model to use as class name
[in,out]	o	stream for generating.

Definition at line 19 of file generate_destructor.hpp.

References EOL(), EOL2(), and INDENT().

Referenced by generate_cpp().

                                                                          {
       o << EOL << INDENT << "~" << model_name << "() { }"  << EOL2;
     }

void stan::lang::generate_dims_method	(	const program &	prog,
		std::ostream &	o
	)

Generate the get_dims method for the parameters, transformed parameters, and generated quantities, using the specified program and generating to the specified stream.

Parameters

[in]	prog	program from which to generate
[in,out]	o	stream for generating

Definition at line 21 of file generate_dims_method.hpp.

References stan::lang::program::derived_decl_, EOL(), EOL2(), stan::lang::program::generated_decl_, MECModelEnuComparisons::i, INDENT(), INDENT2(), and stan::lang::program::parameter_decl_.

Referenced by generate_cpp().

                                                                   {
       write_dims_visgen vis(o);
       o << EOL << INDENT
         << "void get_dims(std::vector<std::vector<size_t> >& dimss__) const {"
         << EOL;
       o << INDENT2 << "dimss__.resize(0);" << EOL;
       o << INDENT2 << "std::vector<size_t> dims__;" << EOL;
       for (size_t i = 0; i < prog.parameter_decl_.size(); ++i)
         boost::apply_visitor(vis, prog.parameter_decl_[i].decl_);
       for (size_t i = 0; i < prog.derived_decl_.first.size(); ++i)
         boost::apply_visitor(vis, prog.derived_decl_.first[i].decl_);
       for (size_t i = 0; i < prog.generated_decl_.first.size(); ++i)
         boost::apply_visitor(vis, prog.generated_decl_.first[i].decl_);
       o << INDENT << "}" << EOL2;
     }

void stan::lang::generate_eigen_index_expression	(	const expression &	e,
		std::ostream &	o
	)

Generate the specified expression cast to an Eigen index to disambiguate from pointer.

Parameters

[in]	e	expression for size
[in,out]	o	stream for generating

Definition at line 19 of file generate_eigen_index_expression.hpp.

References stan::lang::expression::expr_, generate_expression(), and NOT_USER_FACING().

Referenced by stan::lang::local_var_decl_visgen::generate_init_args(), and generate_initializer().

                                                                              {
       o << "static_cast<Eigen::VectorXd::Index>(";
       generate_expression(e.expr_, NOT_USER_FACING, o);
       o << ")";
     }

void stan::lang::generate_expression	(	const expression &	e,
		bool	user_facing,
		std::ostream &	o
	)

Write the code generated by the specified expression to the specified output stream, putting it in a user-readable format if the user-facing flag is true. This is just the header for a forward declaration defined in the generator.

Parameters

[in]	e	expression to write
[in]	user_facing	true if expression should be written so that a user can understand it
[in,out]	o	stream to which expression is written

Generate the specified expression to the specified stream with user-facing/C++ format and parameter/data format controlled by the flags.

Parameters

[in]	e	expression to generate
[in]	user_facing	true if expression might be reported to user
[in,out]	o	stream for generating

Definition at line 21 of file generate_expression.hpp.

References stan::lang::expression::expr_.

                                             {
       expression_visgen vis(o, user_facing);
       boost::apply_visitor(vis, e.expr_);
     }

void stan::lang::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 _log.

Exact behavior differs for unmarked functions, and functions ending in one of "_rng", "_lp", or "_log".

Parameters

[in]	fun	function AST object
[in,out]	out	output stream to which function definition is written

Definition at line 30 of file generate_function.hpp.

References stan::lang::function_decl_def::body_, ends_with(), EOL(), fun_scalar_type(), generate_function_arguments(), generate_function_body(), generate_function_inline_return_type(), generate_function_name(), generate_function_template_parameters(), generate_propto_default_function(), stan::lang::statement::is_no_op_statement(), stan::lang::function_decl_def::name_, and string.

Referenced by generate_functions().

                                             {
       bool is_rng = ends_with("_rng", fun.name_);
       bool is_lp = ends_with("_lp", fun.name_);
       bool is_pf = ends_with("_log", fun.name_)
         || ends_with("_lpdf", fun.name_) || ends_with("_lpmf", fun.name_);
       std::string scalar_t_name = fun_scalar_type(fun, is_lp);
 
       generate_function_template_parameters(fun, is_rng, is_lp, is_pf, out);
       generate_function_inline_return_type(fun, scalar_t_name, 0, out);
       generate_function_name(fun, out);
       generate_function_arguments(fun, is_rng, is_lp, is_pf, out);
       generate_function_body(fun, scalar_t_name, out);
 
       // need a second function def for default propto=false for _log
       // funs; but don't want duplicate def, so don't do it for
       // forward decl when body is no-op
       if (is_pf && !fun.body_.is_no_op_statement())
         generate_propto_default_function(fun, scalar_t_name, out);
       out << EOL;
     }

void stan::lang::generate_function_arguments	(	const function_decl_def &	fun,
		bool	is_rng,
		bool	is_lp,
		bool	is_log,
		std::ostream &	o,
		bool	double_only = `false`,
		std::string	rng_type = `"RNG"`,
		bool	parameter_defaults = `false`
	)

Generate the arguments for the specified function, with precalculated flags for whether it is an RNG, uses the log density accumulator or is a probability function, to the specified stream.

Parameters

[in]	fun	function declaration
[in]	is_rng	true if function is an RNG
[in]	is_lp	true if function accesses log density accumulator
[in]	is_log	true if function is log probability function
[in,out]	o	stream for generating
[in]	double_only	do not do any templating and make all arguments based on the standard double type
[in]	rng_type	set a type of the rng argument in _rng functions
[in]	parameter_defaults	if true, default values for the standard parameters (now only pstream__) will be generated

Definition at line 33 of file generate_function_arguments.hpp.

References stan::lang::function_decl_def::arg_decls_, EOL(), generate_arg_decl(), MECModelEnuComparisons::i, INDENT(), stan::lang::function_decl_def::name_, and string.

Referenced by generate_function(), generate_function_functor(), generate_function_instantiation(), and generate_propto_default_function().

                                                                       {
       o << "(";
       for (size_t i = 0; i < fun.arg_decls_.size(); ++i) {
         std::string template_type_i;
         if (double_only) {
           template_type_i = "double";
         } else {
           template_type_i = "T" + boost::lexical_cast<std::string>(i) + "__";
         }
         generate_arg_decl(true, true, fun.arg_decls_[i], template_type_i, o);
         if (i + 1 < fun.arg_decls_.size()) {
           o << "," << EOL << INDENT;
           for (size_t i = 0; i <= fun.name_.size(); ++i)
             o << " ";
         }
       }
       if ((is_rng || is_lp) && fun.arg_decls_.size() > 0)
         o << ", ";
       if (is_rng) {
         o << rng_type << "& base_rng__";
       } else if (is_lp) {
         if (double_only) {
           o << "double& lp__, stan::math::accumulator<double>& lp_accum__";
         } else {
           o << "T_lp__& lp__, T_lp_accum__& lp_accum__";
         }
       }
       if (is_rng || is_lp || fun.arg_decls_.size() > 0)
         o << ", ";
 
       o << "std::ostream* pstream__";
       if (parameter_defaults) {
         o << " = nullptr";
       }
 
       o << ")";
     }

void stan::lang::generate_function_body	(	const function_decl_def &	fun,
		const std::string &	scalar_t_name,
		std::ostream &	o
	)

Generate the body of the specified function, with the specified local scalar type, writing to the specified stream.

Parameters

[in]	fun	function declaration
[in]	scalar_t_name	name of type to use for scalars in the function body
[in,out]	o	stream for generating

Definition at line 24 of file generate_function_body.hpp.

References stan::lang::expr_type::base_type_, stan::lang::function_decl_def::body_, EOL(), EOL2(), generate_catch_throw_located(), generate_statement(), generate_try(), INDENT(), INDENT2(), stan::lang::base_expr_type::is_int_type(), stan::lang::statement::is_no_op_statement(), and stan::lang::function_decl_def::return_type_.

Referenced by generate_function().

                                                {
       if (fun.body_.is_no_op_statement()) {
         o << ";" << EOL;
         return;
       }
       o << " {" << EOL;
       o << INDENT << "typedef " << scalar_t_name << " local_scalar_t__;" << EOL;
       o << INDENT << "typedef "
         << (fun.return_type_.base_type_.is_int_type()
             ? "int" : "local_scalar_t__")
         << " fun_return_scalar_t__;" << EOL;
       o << INDENT
         << "const static bool propto__ = true;" << EOL
         << INDENT << "(void) propto__;" << EOL;
       // use this dummy for inits
       o << INDENT2 << "local_scalar_t__ "
         << "DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());" << EOL;
       o << INDENT2 << "(void) DUMMY_VAR__;  // suppress unused var warning"
         << EOL2;
 
       o << INDENT << "int current_statement_begin__ = -1;" << EOL;
       generate_try(1, o);
       generate_statement(fun.body_, 2, o);
       generate_catch_throw_located(1, o);
       o << "}" << EOL;
     }

void stan::lang::generate_function_functor	(	const function_decl_def &	fun,
		std::ostream &	o
	)

Generate the functor to accompnay a function with the specified declaration, writing to the specified stream.

Parameters

[in]	fun	function declaration
[in,out]	o	stream for generating

Definition at line 25 of file generate_function_functor.hpp.

References stan::lang::function_decl_def::body_, ends_with(), EOL(), EOL2(), fun_scalar_type(), generate_function_arguments(), generate_function_inline_return_type(), generate_function_name(), generate_function_template_parameters(), generate_functor_arguments(), INDENT(), INDENT2(), stan::lang::statement::is_no_op_statement(), stan::lang::function_decl_def::name_, and string.

Referenced by generate_functions().

                                                   {
       if (fun.body_.is_no_op_statement())
         return;   // forward declaration, so no functor needed
 
       bool is_rng = ends_with("_rng", fun.name_);
       bool is_lp = ends_with("_lp", fun.name_);
       bool is_pf = ends_with("_log", fun.name_)
         || ends_with("_lpdf", fun.name_) || ends_with("_lpmf", fun.name_);
       std::string scalar_t_name = fun_scalar_type(fun, is_lp);
 
       o << EOL << "struct ";
       generate_function_name(fun, o);
       o << "_functor__ {" << EOL;
 
       o << INDENT;
       generate_function_template_parameters(fun, is_rng, is_lp, is_pf, o);
 
       o << INDENT;
       generate_function_inline_return_type(fun, scalar_t_name, 1, o);
 
       o <<  INDENT << "operator()";
       generate_function_arguments(fun, is_rng, is_lp, is_pf, o);
       o << " const {" << EOL;
 
       o << INDENT2 << "return ";
       generate_function_name(fun, o);
       generate_functor_arguments(fun, is_rng, is_lp, is_pf, o);
       o << ";" << EOL;
       o << INDENT << "}"  << EOL;
       o << "};" << EOL2;
     }

void stan::lang::generate_function_inline_return_type	(	const function_decl_def &	fun,
		const std::string &	scalar_t_name,
		int	indent,
		std::ostream &	out
	)

Generate the return type for the specified function declaration in the context of the specified scalar type at the specified indentation level on the specified stream.

Parameters

[in]	fun	function declaration
[in]	scalar_t_name	string version of scalar type in context
[in]	indent	indentation level
[in,out]	out	stream for generating

Definition at line 25 of file generate_function_inline_return_type.hpp.

References EOL(), generate_bare_type(), generate_indent(), and stan::lang::function_decl_def::return_type_.

Referenced by generate_function(), generate_function_functor(), generate_function_instantiation(), and generate_propto_default_function().

                                                                {
       generate_indent(indent, out);
       generate_bare_type(fun.return_type_, scalar_t_name, out);
       out << EOL;
     }

void stan::lang::generate_function_instantiation	(	const function_decl_def &	fun,
		const std::vector< std::string > &	namespaces,
		std::ostream &	out
	)

Generate a non-variable (double only) instantiation of specified function and optionally its default for propto=false for functions ending in _log.

Exact behavior differs for unmarked functions, and functions ending in one of "_rng", "_lp", or "_log".

Parameters

[in]	fun	function AST object
[in]	namespaces	vector of strings used to generate the namespaces generated code is nested in.
[in,out]	out	output stream to which function definition is written

Definition at line 31 of file generate_function_instantiation.hpp.

References stan::lang::function_decl_def::body_, ends_with(), EOL(), generate_function_arguments(), generate_function_inline_return_type(), generate_function_instantiation_body(), generate_function_instantiation_name(), stan::lang::statement::is_no_op_statement(), stan::lang::function_decl_def::name_, and string.

Referenced by generate_function_instantiations().

                                             {
       // Do not generate anything for forward decalrations
       if (fun.body_.is_no_op_statement()) {
         return;
       }
 
       bool is_rng = ends_with("_rng", fun.name_);
       bool is_lp = ends_with("_lp", fun.name_);
       bool is_pf = ends_with("_log", fun.name_)
         || ends_with("_lpdf", fun.name_) || ends_with("_lpmf", fun.name_);
 
       // scalar type is always double for instantiations
       std::string scalar_t_name = "double";
       std::string rng_class = "boost::ecuyer1988";
 
       out << "// [[stan::function]]" << EOL;
       generate_function_inline_return_type(fun, scalar_t_name, 0, out);
       generate_function_instantiation_name(fun, out);
       generate_function_arguments(
         fun, is_rng, is_lp, is_pf, out, true /*no templates*/, rng_class,
         true /*parameter_defaults*/);
 
       generate_function_instantiation_body(
         fun, namespaces, is_rng, is_lp, is_pf, rng_class, out);
 
       out << EOL;
     }

void stan::lang::generate_function_instantiation_body	(	const function_decl_def &	fun,
		const std::vector< std::string > &	namespaces,
		bool	is_rng,
		bool	is_lp,
		bool	is_log,
		const std::string &	rng_class,
		std::ostream &	o
	)

Generate the body for a function instantiation (e.g., the call to the templated function with all templated arguments based on double). Requires precalculated flags for whether it is an RNG, uses the log density accumulator or is a probability function, to the specified stream.

Parameters

[in]	fun	function declaration
[in]	namespaces	vector of strings used to generate the namespaces generated code is nested in.
[in]	is_rng	true if function is an RNG
[in]	is_lp	true if function accesses log density accumulator
[in]	is_log	true if function is log probability function
[in]	rng_class	class of the RNG being used (required by xxx_rng functions)
[in,out]	o	stream for generating

Definition at line 33 of file generate_function_instantiation_body.hpp.

References stan::lang::function_decl_def::arg_decls_, EOL(), generate_function_instantiation_template_parameters(), generate_function_name(), stan::lang::expr_type::is_void(), stan::lang::function_decl_def::return_type_, and string.

Referenced by generate_function_instantiation().

                                                    {
       o << "{" << EOL;
       o << "  ";
       if (!fun.return_type_.is_void()) {
         o << "return ";
       }
       o << EOL;
       for (const std::string& namespace_i : namespaces) {
         o << namespace_i << "::";
       }
       generate_function_name(fun, o);
       generate_function_instantiation_template_parameters(
         fun, is_rng, is_lp, is_log, rng_class, o);
 
       o << "(";
       for (size_t arg_i = 0; arg_i < fun.arg_decls_.size(); ++arg_i) {
         o << fun.arg_decls_[arg_i].name_;
         if (arg_i + 1 < fun.arg_decls_.size()) {
           o << ", ";
         }
       }
       if ((is_rng || is_lp) && fun.arg_decls_.size() > 0)
         o << ", ";
       if (is_rng)
         o << "base_rng__";
       else if (is_lp)
           o << "lp__, lp_accum__";
       if (is_rng || is_lp || fun.arg_decls_.size() > 0)
         o << ", ";
       o << "pstream__";
       o << ");" << EOL;
       o << "}" << EOL;
     }

void stan::lang::generate_function_instantiation_name	(	const function_decl_def &	fun,
		std::ostream &	out
	)

Generate a name for a non-variable (double only) instantiation of specified function

Parameters

[in]	fun	function AST object
[in,out]	out	output stream to which function definition is written

Definition at line 19 of file generate_function_instantiation_name.hpp.

References stan::lang::function_decl_def::name_.

Referenced by generate_function_instantiation().

                                             {
       out << fun.name_;
     }

void stan::lang::generate_function_instantiation_template_parameters	(	const function_decl_def &	fun,
		bool	is_rng,
		bool	is_lp,
		bool	is_log,
		const std::string &	rng_class,
		std::ostream &	out
	)

Generate the concrete template parameters for function instantiation.

Parameters

[in]	fun	function declaration
[in]	is_rng	true if function is a random number generator
[in]	is_lp	true if function accesses log density accumulator
[in]	is_log	true if function is a probability function
[in]	rng_class	class of the RNG being used (required by xxx_rng functions)
[in]	out	stream for generating

Definition at line 27 of file generate_fun_inst_templ_params.hpp.

References stan::lang::function_decl_def::arg_decls_, MECModelEnuComparisons::i, and string.

Referenced by generate_function_instantiation_body().

                                                                {
       std::vector<std::string> type_params;
       type_params.reserve(fun.arg_decls_.size());
 
       if (is_log) {
         std::string propto_value = "false";
         type_params.push_back(propto_value);
       }
 
       for (size_t i = 0; i < fun.arg_decls_.size(); ++i) {
         // no template parameter for int-based args
         if (!fun.arg_decls_[i].arg_type_.base_type_.is_int_type()) {
           type_params.push_back("double");
         }
       }
       if (is_rng) {
         type_params.push_back(rng_class);
       } else if (is_lp) {
         type_params.push_back("double");
         // the trailing space after '>' is necessary to compile
         type_params.push_back("stan::math::accumulator<double> ");
       }
 
       if (!type_params.empty()) {
         out << "<";
         for (size_t param_i = 0; param_i < type_params.size(); ++param_i) {
           if (param_i > 0)
             out << ", ";
           out << type_params[param_i];
         }
         out << ">";
       }
     }

void stan::lang::generate_function_instantiations	(	const std::vector< function_decl_def > &	funs,
		const std::vector< std::string > &	namespaces,
		std::ostream &	o
	)

Generate instantiations of templated functions with non-variable parametersfor standalone generation of functions.

Parameters

[in]	funs	sequence of function declarations and definitions
[in]	namespaces	vector of strings used to generate the namespaces generated code is nested in.
[in,out]	o	stream for generating

Definition at line 23 of file generate_function_instantiations.hpp.

References generate_function_instantiation(), and MECModelEnuComparisons::i.

Referenced by generate_standalone_functions().

                           {
       for (size_t i = 0; i < funs.size(); ++i) {
         generate_function_instantiation(funs[i], namespaces, o);
       }
     }

void stan::lang::generate_function_name	(	const function_decl_def &	fun,
		std::ostream &	o
	)

Generate the function name from the specified declaration on the specified stream.

Parameters

[in]	fun	function declaration
[in,out]	o	stream for generating

Definition at line 17 of file generate_function_name.hpp.

References stan::lang::function_decl_def::name_.

Referenced by generate_function(), generate_function_functor(), generate_function_instantiation_body(), and generate_propto_default_function().

                                                {
       o << fun.name_;
     }

void stan::lang::generate_function_template_parameters	(	const function_decl_def &	fun,
		bool	is_rng,
		bool	is_lp,
		bool	is_log,
		std::ostream &	out
	)

Generate the template declaration for functions.

Parameters

[in]	fun	function declaration
[in]	is_rng	true if function is a random number generator
[in]	is_lp	true if function accesses log density accumulator
[in]	is_log	true if function is a probability function
[in]	out	stream for generating

Definition at line 22 of file generate_function_template_parameters.hpp.

References stan::lang::function_decl_def::arg_decls_, EOL(), has_only_int_args(), and MECModelEnuComparisons::i.

Referenced by generate_function(), generate_function_functor(), and generate_propto_default_function().

                                                                              {
       if (!has_only_int_args(fun)) {  // other cases handled below
         out << "template <";
         bool continuing_tps = false;
         if (is_log) {
           out << "bool propto";
           continuing_tps = true;
         }
         for (size_t i = 0; i < fun.arg_decls_.size(); ++i) {
           // no template parameter for int-based args
           if (!fun.arg_decls_[i].arg_type_.base_type_.is_int_type()) {
             if (continuing_tps)
               out << ", ";
             out << "typename T" << i << "__";
             continuing_tps = true;
           }
         }
         if (is_rng) {
           if (continuing_tps)
             out << ", ";
           out << "class RNG";
           continuing_tps = true;
         } else if (is_lp) {
           if (continuing_tps)
             out << ", ";
           out << "typename T_lp__, typename T_lp_accum__";
           continuing_tps = true;
         }
         out << ">" << EOL;
       } else {  // no-arg function
         if (is_rng) {
           // nullary RNG case
           out << "template <class RNG>" << EOL;
         } else if (is_lp) {
           out << "template <typename T_lp__, typename T_lp_accum__>"
               << EOL;
         } else if (is_log) {
           out << "template <bool propto>"
               << EOL;
         }
       }
     }

void stan::lang::generate_functions	(	const std::vector< function_decl_def > &	funs,
		std::ostream &	o
	)

Generate function forward declarations, definitions, and functors for the the specified sequence of function declarations and definitions, writing to the specified stream.

Parameters

[in]	funs	sequence of function declarations and definitions
[in,out]	o	stream for generating are generated (for non-templated functions only)

Definition at line 23 of file generate_functions.hpp.

References generate_function(), generate_function_functor(), and MECModelEnuComparisons::i.

Referenced by generate_cpp(), and generate_standalone_functions().

                                            {
       for (size_t i = 0; i < funs.size(); ++i) {
         generate_function(funs[i], o);
         generate_function_functor(funs[i], o);
       }
     }

void stan::lang::generate_functor_arguments	(	const function_decl_def &	fun,
		bool	is_rng,
		bool	is_lp,
		bool	is_log,
		std::ostream &	o
	)

Generate the arguments for the functor for the specified function declaration, with flags indicating whether it is a random number generator, accesses the log density accumulator, or is a probability function, writing to the specified stream.

Parameters

[in]	fun	function declaration
[in]	is_rng	true if function is a random number generator
[in]	is_lp	true if function acceses log density accumulator
[in]	is_log	true if function is log probability function
[in,out]	o	stream for generating

Definition at line 23 of file generate_functor_arguments.hpp.

References stan::lang::function_decl_def::arg_decls_, and MECModelEnuComparisons::i.

Referenced by generate_function_functor().

                                                                             {
       o << "(";
       for (size_t i = 0; i < fun.arg_decls_.size(); ++i) {
         if (i > 0)
           o << ", ";
         o << fun.arg_decls_[i].name_;
       }
       if ((is_rng || is_lp) && fun.arg_decls_.size() > 0)
         o << ", ";
       if (is_rng)
         o << "base_rng__";
       else if (is_lp)
         o << "lp__, lp_accum__";
       if (is_rng || is_lp || fun.arg_decls_.size() > 0)
         o << ", ";
       o << "pstream__";
       o << ")";
     }

void stan::lang::generate_globals ( std::ostream & o )

Generate the global variables to the specified stream.

Parameters

[in] o stream for generating

Definition at line 15 of file generate_globals.hpp.

References EOL2().

Referenced by generate_cpp().

                                          {
       o << "static int current_statement_begin__;" << EOL2;
     }

void stan::lang::generate_idx	(	const idx &	i,
		std::ostream &	o
	)

Generate the specified multiple index on the specified stream.

Parameters

[in]	i	multiple index to generate
[in,out]	o	stream for generating

Definition at line 18 of file generate_idx.hpp.

References stan::lang::idx::idx_.

Referenced by generate_idxs().

                                                    {
       idx_visgen vis(o);
       boost::apply_visitor(vis, i.idx_);
     }

void stan::lang::generate_idx_user	(	const idx &	i,
		std::ostream &	o
	)

Generate the specified multiple index for users to the specified stream.

Parameters

[in]	i	multiple index
[in,out]	o	stream for writing

Generate specified multiple index for user on specified stream.

Parameters

[in]	i	multiple index
[in,out]	o	stream for generating

Definition at line 19 of file geneate_idx_user.hpp.

References stan::lang::idx::idx_.

Referenced by generate_idxs_user().

                                                         {
       idx_user_visgen vis(o);
       boost::apply_visitor(vis, i.idx_);
     }

void stan::lang::generate_idxs	(	size_t	pos,
		const std::vector< idx > &	idxs,
		std::ostream &	o
	)

Recursive helper function tracking position to generate specified multiple indexes on the specified stream in order to terminate with a nil index properly.

Parameters

[in]	pos	position in list to generate next
[in]	idxs	multiple indexes to generate
[in,out]	o	stream for generating

Definition at line 21 of file generate_idxs.hpp.

References generate_idx(), and generate_idxs().

                                       {
       if (pos == idxs.size()) {
         o << "stan::model::nil_index_list()";
       } else {
         o << "stan::model::cons_list(";
         generate_idx(idxs[pos], o);
         o << ", ";
         generate_idxs(pos + 1, idxs, o);
         o << ")";
       }
     }

void stan::lang::generate_idxs	(	const std::vector< idx > &	idxs,
		std::ostream &	o
	)

Generate the specified multiple indexes on the specified stream.

Parameters

[in]	idxs	multiple indexes to generate
[in,out]	o	stream for generating

Definition at line 40 of file generate_idxs.hpp.

Referenced by generate_idxs(), stan::lang::expression_visgen::operator()(), stan::lang::statement_visgen::operator()(), and TEST().

                                                                   {
       generate_idxs(0, idxs, o);
     }

void stan::lang::generate_idxs_user	(	const std::vector< idx > &	idxs,
		std::ostream &	o
	)

Generate the specified multiple indexes for users to the specified stream.

Parameters

[in]	idxs	multiple indexes
[in,out]	o	stream for writing

Definition at line 20 of file generate_idxs_user.hpp.

References generate_idx_user(), and MECModelEnuComparisons::i.

Referenced by stan::lang::expression_visgen::operator()().

                                                                        {
       if (idxs.size() == 0)
         return;
       o << "[";
       for (size_t i = 0; i < idxs.size(); ++i) {
         if (i > 0)
           o << ", ";
         generate_idx_user(idxs[i], o);
       }
       o << "]";
     }

void stan::lang::generate_include	(	const std::string &	lib_name,
		std::ostream &	o
	)

Generate an include statement for the specified library path.

Parameters

lib_name	path to library
o	stream for generating

Definition at line 18 of file generate_include.hpp.

References EOL().

Referenced by generate_includes(), and generate_standalone_functions().

                                                                     {
       o << "#include" << " " << "<" << lib_name << ">" << EOL;
     }

void stan::lang::generate_includes ( std::ostream & o )

Generate include statements for a Stan model class to the specified stream.

Parameters

o	stream for generating

Definition at line 18 of file generate_includes.hpp.

References EOL(), and generate_include().

Referenced by generate_cpp().

                                           {
       generate_include("stan/model/model_header.hpp", o);
       o << EOL;
     }

void stan::lang::generate_indent	(	size_t	indent,
		std::ostream &	o
	)

Write the specified number of indentations to the specified output stream.

Parameters

	indent	number of indentations
[in,out]	o	stream to which indentations are written

Definition at line 17 of file generate_indent.hpp.

References art::detail::indent(), and INDENT().

Referenced by stan::lang::validate_var_decl_visgen::basic_validate(), stan::lang::local_var_decl_visgen::declare_array(), stan::lang::init_vars_visgen::fill_real(), stan::lang::validate_var_decl_visgen::generate_begin_for_dims(), stan::lang::init_visgen::generate_buffer_loop(), generate_catch_throw_located(), stan::lang::init_visgen::generate_check_double(), stan::lang::init_visgen::generate_check_int(), generate_comment(), stan::lang::init_visgen::generate_declaration(), stan::lang::init_visgen::generate_dims_loop_fwd(), stan::lang::validate_var_decl_visgen::generate_end_for_dims(), generate_function_inline_return_type(), stan::lang::set_param_ranges_visgen::generate_increment(), stan::lang::set_param_ranges_visgen::generate_increment_i(), stan::lang::init_visgen::generate_indent_num_dims(), stan::lang::local_var_init_nan_visgen::generate_init(), generate_initialization(), stan::lang::write_array_visgen::generate_initialize_array(), stan::lang::init_local_var_visgen::generate_initialize_array(), generate_local_var_decls(), generate_local_var_inits(), generate_member_var_inits(), stan::lang::constrained_param_names_visgen::generate_param_names_array(), stan::lang::unconstrained_param_names_visgen::generate_param_names_array(), generate_set_param_ranges(), generate_statement(), stan::lang::statement_visgen::generate_truncation(), generate_try(), generate_validate_context_size(), generate_validate_positive(), generate_validate_var_decls(), generate_var_resizing(), generate_void_statement(), stan::lang::init_visgen::generate_write_loop(), stan::lang::validate_var_decl_visgen::nonbasic_validate(), stan::lang::init_vars_visgen::operator()(), stan::lang::dump_member_var_visgen::operator()(), stan::lang::set_param_ranges_visgen::operator()(), stan::lang::statement_visgen::operator()(), stan::lang::validate_transformed_params_visgen::validate_array(), and stan::lang::write_array_vars_visgen::write_array().

                                                        {
       for (size_t k = 0; k < indent; ++k)
         o << INDENT;
     }

template<bool isLHS>

void stan::lang::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
	)

Generate the specified expression indexed with the specified indices with the specified base type of expression being indexed, number of dimensions, and a flag indicating whether the generation is for user output or C++ compilation. Depending on the base type, two layers of parens may be written in the underlying code.

Template Parameters

isLHS true if indexed expression appears on left-hand side of an assignment

Parameters

[in]	expr	string for expression
[in]	indexes	indexes for expression
[in]	base_type	base type of expression
[in]	e_num_dims	number of array dimensions in expression
[in]	user_facing	true if expression might be reported to user
[in,out]	o	stream for generating

Definition at line 32 of file generate_indexed_expr.hpp.

References generate_expression(), generate_indexed_expr_user(), generate_quoted_string(), stan::lang::base_expr_type::is_matrix_type(), and getGoodRuns4SAM::n.

                                                                 {
       if (user_facing) {
         generate_indexed_expr_user(expr, indexes, o);
         return;
       }
       size_t ai_size = indexes.size();
       if (ai_size == 0) {
         o << expr;
         return;
       }
       if (ai_size <= (e_num_dims + 1) || !base_type.is_matrix_type()) {
         for (size_t n = 0; n < ai_size; ++n)
           o << (isLHS ? "get_base1_lhs(" : "get_base1(");
         o << expr;
         for (size_t n = 0; n < ai_size; ++n) {
           o << ',';
           generate_expression(indexes[n], user_facing, o);
           o << ',';
           generate_quoted_string(expr, o);
           o << ',' << (n + 1) << ')';
         }
       } else {
         for (size_t n = 0; n < ai_size - 1; ++n)
           o << (isLHS ? "get_base1_lhs(" : "get_base1(");
         o << expr;
         for (size_t n = 0; n < ai_size - 2; ++n) {
           o << ',';
           generate_expression(indexes[n], user_facing, o);
           o << ',';
           generate_quoted_string(expr, o);
           o << ',' << (n+1) << ')';
         }
         o << ',';
         generate_expression(indexes[ai_size - 2U], user_facing, o);
         o << ',';
         generate_expression(indexes[ai_size - 1U], user_facing, o);
         o << ',';
         generate_quoted_string(expr, o);
         o << ',' << (ai_size - 1U) << ')';
       }
     }

void stan::lang::generate_indexed_expr_user	(	const std::string &	expr,
		const std::vector< expression >	indexes,
		std::ostream &	o
	)

Generate an expression with indices, writing brackets around indices and commas in between as necessary. If no indices are presents, no brackets will be written.

Parameters

[in]	expr	expression for indexing
[in]	indexes	sequence of indexes
[in,out]	o	stream for writing

Definition at line 24 of file generate_indexed_expr_user.hpp.

References generate_expression(), and MECModelEnuComparisons::i.

Referenced by generate_indexed_expr().

                                                    {
       static const bool user_facing = true;
       o << expr;
       if (indexes.size() == 0) return;
       o << '[';
       for (size_t i = 0; i < indexes.size(); ++i) {
         if (i > 0) o << ", ";
         generate_expression(indexes[i], user_facing, o);
       }
       o << ']';
     }

void stan::lang::generate_init_method	(	const std::vector< var_decl > &	vs,
		std::ostream &	o
	)

Generate the transform_inits method for the specified variable declarations to the specified stream.

Parameters

[in]	vs	variable declarations
[in,out]	o	stream for generating

Definition at line 22 of file generate_init_method.hpp.

References EOL(), EOL2(), MECModelEnuComparisons::i, INDENT(), and INDENT2().

Referenced by generate_cpp().

                                              {
       o << EOL;
       o << INDENT
         << "void transform_inits(const stan::io::var_context& context__,"
         << EOL;
       o << INDENT << "                     std::vector<int>& params_i__,"
         << EOL;
       o << INDENT << "                     std::vector<double>& params_r__,"
         << EOL;
       o << INDENT << "                     std::ostream* pstream__) const {"
         << EOL;
       o << INDENT2 << "stan::io::writer<double> "
         << "writer__(params_r__,params_i__);"
         << EOL;
       o << INDENT2 << "size_t pos__;" << EOL;
       o << INDENT2 << "(void) pos__; // dummy call to supress warning" << EOL;
       o << INDENT2 << "std::vector<double> vals_r__;" << EOL;
       o << INDENT2 << "std::vector<int> vals_i__;"
         << EOL;
       init_visgen vis(2, o);
       for (size_t i = 0; i < vs.size(); ++i)
         boost::apply_visitor(vis, vs[i].decl_);
 
       o << EOL
         << INDENT2 << "params_r__ = writer__.data_r();" << EOL;
       o << INDENT2 << "params_i__ = writer__.data_i();" << EOL;
       o << INDENT << "}" << EOL2;
 
       o << INDENT
         << "void transform_inits(const stan::io::var_context& context," << EOL;
       o << INDENT
         << "                     "
         << "Eigen::Matrix<double,Eigen::Dynamic,1>& params_r," << EOL;
       o << INDENT
         << "                     std::ostream* pstream__) const {" << EOL;
       o << INDENT << "  std::vector<double> params_r_vec;" << EOL;
       o << INDENT << "  std::vector<int> params_i_vec;" << EOL;
       o << INDENT
         << "  transform_inits(context, params_i_vec, params_r_vec, pstream__);"
         << EOL;
       o << INDENT << "  params_r.resize(params_r_vec.size());" << EOL;
       o << INDENT << "  for (int i = 0; i < params_r.size(); ++i)" << EOL;
       o << INDENT << "    params_r(i) = params_r_vec[i];" << EOL;
       o << INDENT << "}" << EOL2;
     }

void stan::lang::generate_initialization	(	std::ostream &	o,
		size_t	indent,
		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()`
	)

Generate varaible initialization, checking dimension sizes are all positive, gnerating to the specified stream for a variable with the specified name, type, dimension sizes, and optional matrix/vector size declarations.

Parameters

[in,out]	o	stream for generating
[in]	indent	indentation level
[in]	var_name	name of variable being initialized
[in]	base_type	base type of variable
[in]	dims	dimension sizes
[in]	type_arg1	optional vector/row-vector size or matrix rows
[in]	type_arg2	optional size of matrix columns

Definition at line 31 of file generate_initialization.hpp.

References generate_indent(), generate_initializer(), generate_type(), generate_validate_positive(), MECModelEnuComparisons::i, is_nil(), and msf_helper::o.

Referenced by stan::lang::var_resizing_visgen::operator()().

                                                                              {
       // check array dimensions
       for (size_t i = 0; i < dims.size(); ++i)
         generate_validate_positive(var_name, dims[i], indent, o);
       // check vector, row_vector, and matrix rows
       if (!is_nil(type_arg1))
         generate_validate_positive(var_name, type_arg1, indent, o);
       // check matrix cols
       if (!is_nil(type_arg2))
         generate_validate_positive(var_name, type_arg2, indent, o);
 
       // initialize variable
       generate_indent(indent, o);
       o << var_name << " = ";
       generate_type(base_type, dims, dims.size(), o);
       generate_initializer(o, base_type, dims, type_arg1, type_arg2);
     }

void stan::lang::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()`
	)

Generate an initializer for a variable of the specified base type with the specified dimension sizes with an additional size for vectors and row vectors and two additional sizes for matrices.

Parameters

o	stream for generating
base_type	base type of variable
dims	sizes of dimensions for variable
type_arg1	size of vector or row vector or size of rows for matrix, not used otherwise
type_arg2	size of columns for matrix, not used otherwise

Definition at line 28 of file generate_initializer.hpp.

References EOL(), generate_eigen_index_expression(), generate_expression(), generate_type(), MECModelEnuComparisons::i, is_nil(), NOT_USER_FACING(), and msf_helper::o.

Referenced by stan::lang::init_visgen::generate_declaration(), and generate_initialization().

                                                                           {
       for (size_t i = 0; i < dims.size(); ++i) {
         o << '(';
         generate_expression(dims[i].expr_, NOT_USER_FACING, o);
         o << ',';
         generate_type(base_type, dims, dims.size() - i - 1, o);
       }
 
       o << '(';
       if (!is_nil(type_arg1)) {
         generate_eigen_index_expression(type_arg1, o);
         if (!is_nil(type_arg2)) {
           o << ',';
           generate_eigen_index_expression(type_arg2, o);
         }
       } else if (!is_nil(type_arg2.expr_)) {
         generate_eigen_index_expression(type_arg2, o);
       } else {
         o << '0';
       }
       o << ')';
 
       for (size_t i = 0; i < dims.size(); ++i)
         o << ')';
       o << ';' << EOL;
     }

template<typename T >

void stan::lang::generate_line_number	(	const T &	line,
		int	indent,
		std::ostream &	o
	)

Definition at line 20 of file generate_line_number.hpp.

References EOL(), art::detail::indent(), and msf_helper::o.

                                                          {
       o << "current_statement_begin__ = " <<  line.begin_line_ << ";" << EOL;
     }

template void stan::lang::generate_line_number	(	const var_decl &	,
		int	indent,
		std::ostream &	o
	)

template void stan::lang::generate_line_number	(	const statement &	,
		int	indent,
		std::ostream &	o
	)

void stan::lang::generate_local_var_decls	(	const std::vector< var_decl > &	vs,
		int	indent,
		std::ostream &	o
	)

Generate local variable declarations, including initializations, for the specified declarations, indentation level, writing to the specified stream. Generated code is preceeded by stmt updating global variable current_statement_begin__ to src file line number where variable is declared.

Parameters

[in]	vs	variable declarations
[in]	indent	indentation level
[in,out]	o	stream for generating

Definition at line 29 of file generate_local_var_decls.hpp.

References EOL(), generate_expression(), generate_indent(), MECModelEnuComparisons::i, and NOT_USER_FACING().

Referenced by generate_log_prob(), generate_write_array_method(), and stan::lang::statement_visgen::operator()().

                                                  {
       local_var_decl_visgen vis_decl(indent, o);
       local_var_init_nan_visgen vis_init(indent, o);
       init_vars_visgen vis_filler(indent, o);
       for (size_t i = 0; i < vs.size(); ++i) {
         generate_indent(indent, o);
         o << "current_statement_begin__ = " <<  vs[i].begin_line_ << ";"
           << EOL;
         boost::apply_visitor(vis_decl, vs[i].decl_);
         boost::apply_visitor(vis_init, vs[i].decl_);
         boost::apply_visitor(vis_filler, vs[i].decl_);
         if (vs[i].has_def()) {
           generate_indent(indent, o);
           o << "stan::math::assign("
             << vs[i].name()
             << ",";
           generate_expression(vs[i].def(), NOT_USER_FACING, o);
           o << ");" << EOL;
         }
       }
       o << EOL;
     }

void stan::lang::generate_local_var_inits	(	std::vector< var_decl >	vs,
		bool	declare_vars,
		int	indent,
		std::ostream &	o
	)

Generate initializations for the specified local variables, with flags indicating whether the generation is in a variable context and whether variables need to be declared, writing to the specified stream.

Parameters

[in]	vs	variable declarations
[in]	declare_vars	true if variables should be declared
[in]	indent	indentation level
[in,out]	o	stream for generating

Definition at line 26 of file generate_local_var_inits.hpp.

References EOL2(), generate_indent(), and MECModelEnuComparisons::i.

Referenced by generate_log_prob().

                                                              {
       generate_indent(indent, o);
       o << "stan::io::reader<local_scalar_t__> in__(params_r__,params_i__);"
         << EOL2;
       init_local_var_visgen vis_init(declare_vars, indent, o);
       for (size_t i = 0; i < vs.size(); ++i)
         boost::apply_visitor(vis_init, vs[i].decl_);
     }

void stan::lang::generate_log_prob	(	const program &	p,
		std::ostream &	o
	)

Generate the log_prob method for the model class for the specified program on the specified stream.

Parameters

p	program
o	stream for generating

Definition at line 27 of file generate_log_prob.hpp.

References stan::lang::program::derived_decl_, EOL(), EOL2(), generate_catch_throw_located(), generate_comment(), generate_local_var_decls(), generate_local_var_inits(), generate_statement(), generate_statements(), generate_try(), generate_validate_transformed_params(), generate_validate_var_decls(), INDENT(), INDENT2(), INDENT3(), stan::lang::program::parameter_decl_, and stan::lang::program::statement_.

Referenced by generate_cpp().

                                                             {
       o << EOL;
       o << INDENT << "template <bool propto__, bool jacobian__, typename T__>"
         << EOL;
       o << INDENT << "T__ log_prob(vector<T__>& params_r__,"
         << EOL;
       o << INDENT << "             vector<int>& params_i__,"
         << EOL;
       o << INDENT << "             std::ostream* pstream__ = 0) const {"
         << EOL2;
       o << INDENT2 << "typedef T__ local_scalar_t__;" << EOL2;
 
       // use this dummy for inits
       o << INDENT2
         << "local_scalar_t__ DUMMY_VAR__"
         << "(std::numeric_limits<double>::quiet_NaN());"
         << EOL;
       o << INDENT2 << "(void) DUMMY_VAR__;  // suppress unused var warning"
         << EOL2;
 
       o << INDENT2 << "T__ lp__(0.0);"
         << EOL;
       o << INDENT2 << "stan::math::accumulator<T__> lp_accum__;"
         << EOL2;
 
       bool gen_local_vars = true;
 
       generate_try(2, o);
 
       generate_comment("model parameters", 3, o);
       generate_local_var_inits(p.parameter_decl_, gen_local_vars, 3, o);
       o << EOL;
 
       generate_comment("transformed parameters", 3, o);
       generate_local_var_decls(p.derived_decl_.first, 3, o);
       o << EOL;
 
       generate_statements(p.derived_decl_.second, 3, o);
       o << EOL;
 
       generate_validate_transformed_params(p.derived_decl_.first, 3, o);
       o << INDENT3
         << "const char* function__ = \"validate transformed params\";"
         << EOL;
       o << INDENT3
         << "(void) function__;  // dummy to suppress unused var warning"
         << EOL;
 
       generate_validate_var_decls(p.derived_decl_.first, 3, o);
 
       o << EOL;
       generate_comment("model body", 3, o);
 
       generate_statement(p.statement_, 3, o);
       o << EOL;
       generate_catch_throw_located(2, o);
 
       o << EOL;
       o << INDENT2 << "lp_accum__.add(lp__);" << EOL;
       o << INDENT2 << "return lp_accum__.sum();" << EOL2;
       o << INDENT << "} // log_prob()" << EOL2;
 
       o << INDENT
         << "template <bool propto, bool jacobian, typename T_>" << EOL;
       o << INDENT
         << "T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r," << EOL;
       o << INDENT << "           std::ostream* pstream = 0) const {" << EOL;
       o << INDENT << "  std::vector<T_> vec_params_r;" << EOL;
       o << INDENT << "  vec_params_r.reserve(params_r.size());" << EOL;
       o << INDENT << "  for (int i = 0; i < params_r.size(); ++i)" << EOL;
       o << INDENT << "    vec_params_r.push_back(params_r(i));" << EOL;
       o << INDENT << "  std::vector<int> vec_params_i;" << EOL;
       o << INDENT
         << "  return log_prob<propto,jacobian,T_>(vec_params_r, "
         << "vec_params_i, pstream);" << EOL;
       o << INDENT << "}" << EOL2;
     }

void stan::lang::generate_member_var_decls	(	const std::vector< var_decl > &	vs,
		int	indent,
		std::ostream &	o
	)

Generate member variable declarations for the specified variable declarations at the specified indentation level to the specified stream.

Parameters

[in]	vs	variable declarations
[in]	indent	indentation level
[in]	o	stream for writing

Definition at line 22 of file generate_member_var_decls.hpp.

References MECModelEnuComparisons::i.

Referenced by generate_member_var_decls_all().

                                                               {
       member_var_decl_visgen vis(indent, o);
       for (size_t i = 0; i < vs.size(); ++i)
         boost::apply_visitor(vis, vs[i].decl_);
     }

void stan::lang::generate_member_var_decls_all	(	const program &	prog,
		std::ostream &	o
	)

Generate member variable declarations for the data and transformed data blocks for the specified program, writing to the specified stream.

Parameters

[in]	prog	program from which to generate
[in,out]	o	stream for generating

Definition at line 19 of file generate_member_var_decls_all.hpp.

References stan::lang::program::data_decl_, stan::lang::program::derived_data_decl_, and generate_member_var_decls().

Referenced by generate_cpp().

                                                       {
       generate_member_var_decls(prog.data_decl_, 1, o);
       generate_member_var_decls(prog.derived_data_decl_.first, 1, o);
     }

void stan::lang::generate_member_var_inits	(	const std::vector< var_decl > &	vs,
		int	indent,
		std::ostream &	o
	)

Generate initializations for member variables by reading from constructor variable context. Generated initializations are preceeded by stmt updating global variable current_statement_begin__ to src file line number where variable is declared.

Parameters

[in]	vs	member variable declarations
[in]	indent	indentation level
[in,out]	o	stream for generating

Definition at line 26 of file generate_member_var_inits.hpp.

References EOL(), generate_indent(), and MECModelEnuComparisons::i.

Referenced by generate_constructor().

                                                               {
       dump_member_var_visgen vis(indent, o);
       for (size_t i = 0; i < vs.size(); ++i) {
         generate_indent(indent, o);
         o << "current_statement_begin__ = " <<  vs[i].begin_line_ << ";"
           << EOL;
         boost::apply_visitor(vis, vs[i].decl_);
       }
     }

void stan::lang::generate_model_name_method	(	const std::string &	model_name,
		std::ostream &	o
	)

Generate the model_name method for the specified name on the specified stream.

Parameters

[in]	model_name	name of model
[in,out]	o	stream for generating

Definition at line 19 of file generate_model_name_method.hpp.

References EOL(), EOL2(), INDENT(), and INDENT2().

Referenced by generate_cpp().

                                                    {
       o << INDENT << "static std::string model_name() {" << EOL
         << INDENT2 << "return \"" << model_name << "\";" << EOL
         << INDENT << "}" << EOL2;
     }

void stan::lang::generate_model_typedef	(	const std::string &	model_name,
		std::ostream &	o
	)

Generate reusable typedef of stan_model for specified model name writing to the specified stream.

Parameters

model_name	name of model
o	stream for generating

Definition at line 19 of file generate_model_typedef.hpp.

References EOL2().

Referenced by generate_cpp(), and TEST().

                                                {
       o << "typedef " << model_name << "_namespace::" << model_name
         << " stan_model;" << EOL2;
     }

void stan::lang::generate_namespace_end ( std::ostream & o )

Generate the end of a namespace to the specified stream.

Parameters

[in,out] o stream for generating

Definition at line 15 of file generate_namespace_end.hpp.

References EOL2().

Referenced by generate_cpp().

                                                {
       o << "}" << EOL2;
     }

void stan::lang::generate_namespace_start	(	const std::string &	name,
		std::ostream &	o
	)

Generate the opening name and brace for a namespace, with two end of lines.

Parameters

[in]	name	name of namespace
[in,out]	o	stream for generating

Definition at line 18 of file generate_namespace_start.hpp.

References EOL2().

Referenced by generate_cpp().

                                                                         {
       o << "namespace " << name << "_namespace {" << EOL2;
     }

void stan::lang::generate_param_names_method	(	const program &	prog,
		std::ostream &	o
	)

Generate the method to get_param_names, which retrieves the parameter names for the specified program on the specified stream.

Parameters

[in]	prog	program from which to generate
[in,out]	o	stream for generating

Definition at line 21 of file generate_param_names_method.hpp.

References stan::lang::program::derived_decl_, EOL(), EOL2(), stan::lang::program::generated_decl_, MECModelEnuComparisons::i, INDENT(), INDENT2(), and stan::lang::program::parameter_decl_.

Referenced by generate_cpp().

                                                                          {
       write_param_names_visgen vis(o);
       o << EOL << INDENT
         << "void get_param_names(std::vector<std::string>& names__) const {"
         << EOL;
       o << INDENT2 << "names__.resize(0);" << EOL;
       for (size_t i = 0; i < prog.parameter_decl_.size(); ++i)
         boost::apply_visitor(vis, prog.parameter_decl_[i].decl_);
       for (size_t i = 0; i < prog.derived_decl_.first.size(); ++i)
         boost::apply_visitor(vis, prog.derived_decl_.first[i].decl_);
       for (size_t i = 0; i < prog.generated_decl_.first.size(); ++i)
         boost::apply_visitor(vis, prog.generated_decl_.first[i].decl_);
       o << INDENT << "}" << EOL2;
     }

void stan::lang::generate_printable	(	const printable &	p,
		std::ostream &	o
	)

Generate the specified printable object to the specified stream.

Parameters

p	object to print
o	stream for printing

Definition at line 18 of file generate_printable.hpp.

References stan::lang::printable::printable_.

Referenced by stan::lang::statement_visgen::operator()().

                                                                {
       printable_visgen vis(o);
       boost::apply_visitor(vis, p.printable_);
     }

void stan::lang::generate_private_decl ( std::ostream & o )

Generate the private declaration scope for a class to the specified stream.

Parameters

[in,out] o stream for generating

Definition at line 17 of file generate_private_decl.hpp.

References EOL().

Referenced by generate_cpp().

                                               {
       o << "private:" << EOL;
     }

void stan::lang::generate_program_reader_fun	(	const std::vector< io::preproc_event > &	history,
		std::ostream &	o
	)

Generate a top-level function that returns the program reader for the specified history.

Implementation note: Because this is only called when there is an error to report, reconstructing on each call has acceptable performance.

Parameters

[in]	history	record of I/O path for lines in compound program
[in,out]	o	stream to which generated code is written

Definition at line 24 of file generate_program_reader_fun.hpp.

References allTimeWatchdog::endl, MECModelEnuComparisons::i, and INDENT().

Referenced by generate_cpp(), and generate_standalone_functions().

                                                {
       o << "stan::io::program_reader prog_reader__() {" << std::endl;
       o << INDENT << "stan::io::program_reader reader;" << std::endl;
       for (size_t i = 0; i < history.size(); ++i)
         o << INDENT << "reader.add_event("
           << history[i].concat_line_num_
           << ", " << history[i]. line_num_
           << ", \"" << history[i].action_ << "\""
           << ", \"" << history[i].path_ << "\");" << std::endl;
       o << INDENT << "return reader;" << std::endl;
       o << "}" << std::endl << std::endl;
     }

void stan::lang::generate_propto_default_function	(	const function_decl_def &	fun,
		const std::string &	scalar_t_name,
		std::ostream &	o
	)

Generate a version of the specified function with propto set to false, with the specified local scalar type, writing to the specified stream.

Parameters

[in]	fun	function declaration
[in]	scalar_t_name	string representation of scalar type for local scalar variables
[in,out]	o	stream for generating

Definition at line 26 of file generate_propto_default_function.hpp.

References generate_function_arguments(), generate_function_inline_return_type(), generate_function_name(), generate_function_template_parameters(), and generate_propto_default_function_body().

Referenced by generate_function().

                                                          {
       generate_function_template_parameters(fun, false, false, false, o);
       generate_function_inline_return_type(fun, scalar_t_name, 0, o);
       generate_function_name(fun, o);
       generate_function_arguments(fun, false, false, false, o);
       generate_propto_default_function_body(fun, o);
     }

void stan::lang::generate_propto_default_function_body	(	const function_decl_def &	fun,
		std::ostream &	o
	)

Generate the body of the specified function with propto set to false, writing to the specified stream.

Parameters

[in]	fun	function declaration
[in,out]	o	stream for generating

Definition at line 19 of file generate_propto_default_function_body.hpp.

References stan::lang::function_decl_def::arg_decls_, EOL(), MECModelEnuComparisons::i, INDENT(), and stan::lang::function_decl_def::name_.

Referenced by generate_propto_default_function().

                                                               {
       o << " {" << EOL;
       o << INDENT << "return ";
       o << fun.name_ << "<false>(";
       for (size_t i = 0; i < fun.arg_decls_.size(); ++i) {
         if (i > 0)
           o << ",";
         o << fun.arg_decls_[i].name_;
       }
       if (fun.arg_decls_.size() > 0)
         o << ", ";
       o << "pstream__";
       o << ");" << EOL;
       o << "}" << EOL;
     }

void stan::lang::generate_public_decl ( std::ostream & o )

Generate the public declaration scope for a class to the specified stream.

Parameters

[in,out] o stream for generating

Definition at line 17 of file generate_public_decl.hpp.

References EOL().

Referenced by generate_cpp().

                                              {
       o << "public:" << EOL;
     }

void stan::lang::generate_quoted_expression	(	const expression &	e,
		std::ostream &	o
	)

Definition at line 16 of file generate_quoted_expression.hpp.

References generate_expression(), generate_quoted_string(), NOT_USER_FACING(), msf_helper::o, and ss.

Referenced by generate_validate_positive(), and test_generate_quoted_expression().

                                                                         {
       std::stringstream ss;
       generate_expression(e, NOT_USER_FACING, ss);
       generate_quoted_string(ss.str(), o);
     }

void stan::lang::generate_quoted_string	(	const std::string &	s,
		std::ostream &	o
	)

Print the specified string to the specified output stream, wrapping in double quotes (") and inserting a backslash to escape double quotes, single quotes, and backslashes.

Parameters

[in]	s	String to output
[in,out]	o	Output stream

Definition at line 18 of file generate_quoted_string.hpp.

References MECModelEnuComparisons::i.

Referenced by generate_indexed_expr(), generate_quoted_expression(), stan::lang::printable_visgen::operator()(), test_generate_quoted_string(), and test_generate_quoted_string_quote().

                                                                    {
       o << '"';
       for (size_t i = 0; i < s.size(); ++i) {
         if (s[i] == '"' || s[i] == '\\' || s[i] == '\'' )
           o << '\\';
         o << s[i];
       }
       o << '"';
     }

void stan::lang::generate_real_var_type	(	const scope &	var_scope,
		bool	has_var,
		std::ostream &	o
	)

Generate correct C++ type for expressions which contain a Stan real variable according to scope in which expression is used and expression contents.

Parameters

[in]	var_scope	expression origin block
[in]	has_var	does expression contains a variable?
[in,out]	o	generated typename

Definition at line 19 of file generate_real_var_type.hpp.

References stan::lang::scope::fun(), and has_var().

Referenced by stan::lang::expression_visgen::operator()(), and TEST().

                                                {
       if (var_scope.fun() || has_var)
         o << "local_scalar_t__";
       else
         o << "double";
     }

void stan::lang::generate_register_mpi	(	const std::string &	model_name,
		std::ostream &	o
	)

Definition at line 13 of file generate_register_mpi.hpp.

References a, allTimeWatchdog::endl, stan::lang::map_rect::registered_calls(), and string.

Referenced by generate_cpp().

                                           {
   for (auto a : map_rect::registered_calls()) {
     int id = a.first;
     std::string fun_name = a.second;
     o << "STAN_REGISTER_MAP_RECT(" << id << ", " << model_name << "_namespace::"
       << fun_name << "_functor__"
       << ")" << std::endl;
   }
 }

void stan::lang::generate_set_param_ranges	(	const std::vector< var_decl > &	var_decls,
		int	indent,
		std::ostream &	o
	)

Definition at line 28 of file generate_set_param_ranges.hpp.

References EOL(), generate_indent(), and MECModelEnuComparisons::i.

Referenced by generate_constructor().

                                                               {
       generate_indent(indent, o);
       o << "num_params_r__ = 0U;" << EOL;
       generate_indent(indent, o);
       o << "param_ranges_i__.clear();" << EOL;
       set_param_ranges_visgen vis(indent, o);
       for (size_t i = 0; i < var_decls.size(); ++i) {
         generate_indent(indent, o);
         o << "current_statement_begin__ = " <<  var_decls[i].begin_line_ << ";"
           << EOL;
         boost::apply_visitor(vis, var_decls[i].decl_);
       }
     }

void stan::lang::generate_standalone_functions	(	const program &	prog,
		const std::vector< std::string > &	namespaces,
		const std::vector< io::preproc_event > &	history,
		std::ostream &	o
	)

Generate the C++ code for standalone functions, generating it in the namespace provided, writing to the specified stream.

Parameters

[in]	prog	program from which to generate
[in]	namespaces	namespace to generate the functions in
[in]	history	I/O include history for text underlying program
[in,out]	o	stream for generating

Definition at line 31 of file generate_standalone_functions.hpp.

References EOL(), stan::lang::program::function_decl_defs_, generate_function_instantiations(), generate_functions(), generate_include(), generate_program_reader_fun(), generate_typedefs(), generate_usings_standalone_functions(), and generate_version_comment().

Referenced by compile_functions().

                           {
       generate_version_comment(o);
 
       generate_include("stan/model/standalone_functions_header.hpp", o);
       o << EOL;
 
       // generate namespace starts
       for (size_t namespace_i = 0;
           namespace_i < namespaces.size(); ++namespace_i) {
         o << "namespace " << namespaces[namespace_i] << " { ";
       }
       o << EOL;
 
       generate_usings_standalone_functions(o);
       generate_typedefs(o);
       generate_program_reader_fun(history, o);
       generate_functions(prog.function_decl_defs_, o);
 
       // generate namespace ends
       for (size_t namespace_i = 0;
           namespace_i < namespaces.size(); ++namespace_i) {
         o << " } ";
       }
       o << EOL;
 
       generate_function_instantiations(prog.function_decl_defs_, namespaces, o);
     }

void stan::lang::generate_statement	(	const statement &	s,
		int	indent,
		std::ostream &	o
	)

Generate the specified statement with the specified indentation level on the specified output stream. Generated statement is preceeded by stmt updating global variable current_statement_begin__ to src file line number where stmt begins.

Parameters

[in]	s	statement to generate
[in]	indent	indentation level
[in,out]	o	stream for generating

Definition at line 25 of file generate_statement.hpp.

References stan::lang::statement::begin_line_, EOL(), generate_indent(), and stan::lang::statement::statement_.

Referenced by generate_function_body(), generate_log_prob(), generate_statements(), stan::lang::statement_visgen::operator()(), and TEST().

                                                                            {
       is_numbered_statement_vis vis_is_numbered;
       if (boost::apply_visitor(vis_is_numbered, s.statement_)) {
         generate_indent(indent, o);
         o << "current_statement_begin__ = " << s.begin_line_ << ";" << EOL;
       }
       statement_visgen vis(indent, o);
       boost::apply_visitor(vis, s.statement_);
     }

void stan::lang::generate_statement	(	const std::vector< statement > &	ss,
		int	indent,
		std::ostream &	o
	)

void stan::lang::generate_statements	(	const std::vector< statement >	statements,
		int	indent,
		std::ostream &	o
	)

Generate the set of statements in a program block with the specified indentation level on the specified stream.

Parameters

[in]	statements	vector of statements
[in]	indent	indentation level
[in,out]	o	stream for generating

Definition at line 20 of file generate_statements.hpp.

References generate_statement(), and MECModelEnuComparisons::i.

Referenced by generate_constructor(), generate_log_prob(), and generate_write_array_method().

                                                         {
       for (size_t i = 0; i < statements.size(); ++i)
         generate_statement(statements[i], indent, o);
     }

void stan::lang::generate_try	(	int	indent,
		std::ostream &	o
	)

Generate the opening for a try statement at the specified indentation level on the specified stream.

Parameters

[in]	indent	indentation level
[in,out]	o	stream for generating

Definition at line 19 of file generate_try.hpp.

References EOL(), and generate_indent().

Referenced by generate_constructor(), generate_function_body(), generate_log_prob(), and generate_write_array_method().

                                                  {
       generate_indent(indent, o);
       o << "try {" << EOL;
     }

void stan::lang::generate_type	(	const std::string &	base_type,
		const std::vector< expression > &	,
		size_t	end,
		std::ostream &	o
	)

Generate the base type for multi-dimensional arrays.

Parameters

[in]	base_type	string representing bae type
[in]	end	number of standard vector embeddings
[in,out]	o	stream for generating

Definition at line 19 of file generate_type.hpp.

References febshutoff_auto::end, and MECModelEnuComparisons::i.

Referenced by stan::lang::init_visgen::generate_declaration(), generate_initialization(), generate_initializer(), and stan::lang::expression_visgen::operator()().

                                                   {
       for (size_t i = 0; i < end; ++i)
         o << "std::vector<";
       o << base_type;
       for (size_t i = 0; i < end; ++i) {
         if (i > 0) o << ' ';
         o << '>';
       }
     }

void stan::lang::generate_typedef	(	const std::string &	type,
		const std::string &	abbrev,
		std::ostream &	o
	)

Generate a typedef statement for the specified type and abbreviation to the specified stream.

Parameters

[in]	type	type for definition
[in]	abbrev	abbreviation defined for type
[in,out]	o	stream for writing

Definition at line 20 of file generate_typedef.hpp.

References EOL().

Referenced by generate_typedefs().

                                          {
       o << "typedef" << " " << type << " " << abbrev << ";" << EOL;
     }

void stan::lang::generate_typedefs ( std::ostream & o )

Generate the typedefs required for the Stan model class to the specified stream.

Parameters

[in,out] o stream for generating

Definition at line 17 of file generate_typedefs.hpp.

References EOL(), and generate_typedef().

Referenced by generate_standalone_functions().

                                           {
       generate_typedef("Eigen::Matrix<double,Eigen::Dynamic,1>", "vector_d", o);
       generate_typedef("Eigen::Matrix<double,1,Eigen::Dynamic>",
                        "row_vector_d", o);
       generate_typedef("Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic>",
                        "matrix_d", o);
       o << EOL;
     }

void stan::lang::generate_unconstrained_param_names_method	(	const program &	prog,
		std::ostream &	o
	)

Generate the method unconstrained_param_names for the specified program on the specified stream.

Parameters

[in]	prog	progam from which to generate
[in,out]	o	stream for generating

Definition at line 20 of file generate_unconstrained_param_names_method.hpp.

References stan::lang::program::derived_decl_, EOL(), EOL2(), stan::lang::program::generated_decl_, MECModelEnuComparisons::i, INDENT(), INDENT2(), and stan::lang::program::parameter_decl_.

Referenced by generate_cpp().

                                                                   {
       o << EOL << INDENT
         << "void unconstrained_param_names("
         << "std::vector<std::string>& param_names__,"
         << EOL << INDENT
         << "                               bool include_tparams__ = true,"
         << EOL << INDENT
         << "                               bool include_gqs__ = true) const {"
         << EOL << INDENT2
         << "std::stringstream param_name_stream__;" << EOL;
       unconstrained_param_names_visgen vis1(1, o);
       unconstrained_param_names_visgen vis2(2, o);
       for (size_t i = 0; i < prog.parameter_decl_.size(); ++i)
         boost::apply_visitor(vis1, prog.parameter_decl_[i].decl_);
       o << EOL << INDENT2
         << "if (!include_gqs__ && !include_tparams__) return;"  << EOL;
       o << EOL << INDENT2 << "if (include_tparams__) {"  << EOL;
       for (size_t i = 0; i < prog.derived_decl_.first.size(); ++i)
         boost::apply_visitor(vis2, prog.derived_decl_.first[i].decl_);
       o << INDENT2 << "}" << EOL2;
 
       o << EOL << INDENT2 << "if (!include_gqs__) return;" << EOL;
       for (size_t i = 0; i < prog.generated_decl_.first.size(); ++i)
         boost::apply_visitor(vis1, prog.generated_decl_.first[i].decl_);
       o << INDENT << "}" << EOL2;
     }

void stan::lang::generate_using	(	const std::string &	type,
		std::ostream &	o
	)

Generate a using statement for the specified type to the specified stream.

Parameters

[in]	type	type for which using statement is geneated
[in,out]	o	stream for generation

Definition at line 19 of file generate_using.hpp.

References EOL().

Referenced by generate_usings(), and generate_usings_standalone_functions().

                                                               {
       o << "using " << type << ";" << EOL;
     }

void stan::lang::generate_using_namespace	(	const std::string &	ns,
		std::ostream &	o
	)

Generate using statement for the specified namespace to the specfied stream.

Parameters

[in]	ns	namespace for which using statement is generated
[in,out]	o	stream for generating

Definition at line 19 of file generate_using_namespace.hpp.

References EOL().

Referenced by generate_usings(), and generate_usings_standalone_functions().

                                                                       {
       o << "using namespace " << ns << ";" << EOL;
     }

void stan::lang::generate_usings ( std::ostream & o )

Generate the using statements for a Stan model.

Parameters

[in,out] o stream for generating

Definition at line 18 of file generate_usings.hpp.

References EOL(), generate_using(), and generate_using_namespace().

Referenced by generate_cpp().

                                         {
       generate_using("std::istream", o);
       generate_using("std::string", o);
       generate_using("std::stringstream", o);
       generate_using("std::vector", o);
       generate_using("stan::io::dump", o);
       generate_using("stan::math::lgamma", o);
       generate_using("stan::model::prob_grad", o);
       generate_using_namespace("stan::math", o);
       o << EOL;
     }

void stan::lang::generate_usings_standalone_functions ( std::ostream & o )

Generate the using statements for a Stan standalone functions file.

Parameters

[in,out] o stream for generating

Definition at line 18 of file generate_usings_standalone_functions.hpp.

References EOL(), generate_using(), and generate_using_namespace().

Referenced by generate_standalone_functions().

                                                              {
       generate_using("std::istream", o);
       generate_using("std::string", o);
       generate_using("std::stringstream", o);
       generate_using("std::vector", o);
       generate_using_namespace("stan::math", o);
       o << EOL;
     }

void stan::lang::generate_validate_context_size	(	size_t	indent,
		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()`
	)

Definition at line 30 of file generate_validate_context_size.hpp.

References EOL(), generate_expression(), generate_indent(), generate_validate_positive(), MECModelEnuComparisons::i, is_nil(), and NOT_USER_FACING().

Referenced by stan::lang::var_size_validating_visgen::operator()().

                                                           {
       // check array dimensions
       for (size_t i = 0; i < dims.size(); ++i)
         generate_validate_positive(var_name, dims[i], indent, o);
       // check vector, row_vector, and matrix rows
       if (!is_nil(type_arg1))
         generate_validate_positive(var_name, type_arg1, indent, o);
       // check matrix cols
       if (!is_nil(type_arg2))
         generate_validate_positive(var_name, type_arg2, indent, o);
 
       // calls var_context to make sure dimensions match
       generate_indent(indent, o);
       o << "context__.validate_dims("
         << '"' << stage << '"' << ", "
         << '"' << var_name << '"' << ", "
         << '"' << base_type << '"' << ", "
         << "context__.to_vec(";
       for (size_t i = 0; i < dims.size(); ++i) {
         if (i > 0) o << ",";
         generate_expression(dims[i].expr_, NOT_USER_FACING, o);
       }
       if (!is_nil(type_arg1)) {
         if (dims.size() > 0) o << ",";
         generate_expression(type_arg1.expr_, NOT_USER_FACING, o);
         if (!is_nil(type_arg2)) {
           o << ",";
           generate_expression(type_arg2.expr_, NOT_USER_FACING, o);
         }
       }
       o << "));" << EOL;
     }

void stan::lang::generate_validate_positive	(	const std::string &	var_name,
		const expression &	expr,
		int	indents,
		std::ostream &	o
	)

Generate call to stan_math lib function validate_non_negative_index which will throw an informative error if dim size is < 0

This check should precede the variable declaration in order to avoid bad alloc runtime error. Called by
generate_validate_context_size - data variables
generate_initialization - transformed data declarations
generate_var_resiszing - initializes transformed data variables
generate_local_var_decls - local variables, transformed parameters write array, generated quantities
generate_set_param_ranges - parameter variables

Parameters

[in]	var_name	variable name
[in]	expr	declared dim size expression
[in]	indents	indentation level
[in,out]	o	output stream for generated code

Definition at line 33 of file generate_validate_positive.hpp.

References EOL(), generate_expression(), generate_indent(), generate_quoted_expression(), and NOT_USER_FACING().

Referenced by stan::lang::local_var_decl_visgen::declare_array(), generate_initialization(), generate_validate_context_size(), stan::lang::set_param_ranges_visgen::operator()(), and stan::lang::local_var_decl_visgen::operator()().

                                                    {
       generate_indent(indents, o);
       o << "validate_non_negative_index(\"" << var_name << "\", ";
       generate_quoted_expression(expr, o);
       o << ", ";
       generate_expression(expr, NOT_USER_FACING, o);
       o << ");" << EOL;
     }

void stan::lang::generate_validate_transformed_params	(	const std::vector< var_decl > &	vs,
		int	indent,
		std::ostream &	o
	)

Generate code to validate the specified transformed parameters, generating at the specified indentation level to the specified stream.

Parameters

[in]	vs	variable declarations
[in]	indent	indentation level
[in,out]	o	stream for generating

Definition at line 24 of file generate_validate_transformed_params.hpp.

References EOL(), generate_comment(), and MECModelEnuComparisons::i.

Referenced by generate_log_prob().

                                                                          {
       generate_comment("validate transformed parameters", indent, o);
       validate_transformed_params_visgen vis(indent, o);
       for (size_t i = 0; i < vs.size(); ++i)
         boost::apply_visitor(vis, vs[i].decl_);
       o << EOL;
     }

void stan::lang::generate_validate_var_decl	(	const var_decl &	decl,
		int	indent,
		std::ostream &	o
	)

Generate code to validate the specified variable declaration at the specified indentation level to the specified stream.

Parameters

[in]	decl	variable declaration
[in]	indent	indentation level
[in,out]	o	stream for generating

Definition at line 20 of file generate_validate_var_decl.hpp.

References stan::lang::var_decl::decl_.

Referenced by generate_validate_var_decls().

                                                    {
       validate_var_decl_visgen vis(indent, o);
       boost::apply_visitor(vis, decl.decl_);
     }

void stan::lang::generate_validate_var_decls	(	const std::vector< var_decl >	decls,
		int	indent,
		std::ostream &	o
	)

Generate code to validate the specified variable declarations at the specified indentation level to the specified stream. Generated code is preceeded by stmt updating global variable current_statement_begin__ to src file line number where variable is declared.

Parameters

[in]	decls	variable declarations
[in]	indent	indentation level
[in,out]	o	stream for generating

Definition at line 24 of file generate_validate_var_decls.hpp.

References EOL(), generate_indent(), generate_validate_var_decl(), and MECModelEnuComparisons::i.

Referenced by generate_constructor(), generate_log_prob(), and generate_write_array_method().

                                                                 {
       for (size_t i = 0; i < decls.size(); ++i) {
         generate_indent(indent, o);
         o << "current_statement_begin__ = " <<  decls[i].begin_line_ << ";"
           << EOL;
 
         generate_validate_var_decl(decls[i], indent, o);
       }
     }

void stan::lang::generate_var_resizing	(	const std::vector< var_decl > &	vs,
		int	indent,
		std::ostream &	o
	)

Generate code to to the specified stream to resize the variables in the specified declarations and fill them with dummy values. Generated code is preceeded by stmt updating global variable current_statement_begin__ to src file line number where variable is declared.

Parameters

[in]	vs	variable declarations
[in]	indent	indentation level
[in,out]	o	stream for generating

Definition at line 28 of file generate_var_resizing.hpp.

References EOL(), generate_expression(), generate_indent(), MECModelEnuComparisons::i, and NOT_USER_FACING().

Referenced by generate_constructor().

                                                           {
       var_resizing_visgen vis_resizer(indent, o);
       init_vars_visgen vis_filler(indent, o);
       for (size_t i = 0; i < vs.size(); ++i) {
         generate_indent(indent, o);
         o << "current_statement_begin__ = " <<  vs[i].begin_line_ << ";"
           << EOL;
         boost::apply_visitor(vis_resizer, vs[i].decl_);
         boost::apply_visitor(vis_filler, vs[i].decl_);
         if (vs[i].has_def()) {
           generate_indent(indent, o);
           o << "stan::math::assign(" << vs[i].name() << ",";
           generate_expression(vs[i].def(), NOT_USER_FACING, o);
           o << ");" << EOL;
         }
       }
     }

void stan::lang::generate_version_comment ( std::ostream & o )

Generate a comment indicating which version of Stan generated the model code to the specified stream.

Parameters

[in,out] o stream for generating

Definition at line 18 of file generate_version_comment.hpp.

References EOL2(), stan::MAJOR_VERSION, stan::MINOR_VERSION, and stan::PATCH_VERSION.

Referenced by generate_cpp(), and generate_standalone_functions().

                                                  {
       o << "// Code generated by Stan version " << stan::MAJOR_VERSION
         << "." << stan::MINOR_VERSION
         << "." << stan::PATCH_VERSION
         << EOL2;
     }

void stan::lang::generate_void_statement	(	const std::string &	name,
		const size_t	indent,
		std::ostream &	o
	)

Generate a dummy void-cast statement for a variable of the specified name at the specified indentation level to the specified output stream.

Parameters

[in]	name	variable name
[in]	indent	indentation level
[in,out]	o	stream for genering

Definition at line 20 of file generate_void_statement.hpp.

References EOL(), and generate_indent().

Referenced by stan::lang::local_var_decl_visgen::declare_array(), generate_constructor(), stan::lang::init_local_var_visgen::generate_initialize_array(), generate_write_array_method(), and stan::lang::statement_visgen::operator()().

                                                  {
       generate_indent(indent, o);
       o << "(void) " << name << ";"
         << "  // dummy to suppress unused var warning"
         << EOL;
     }

void stan::lang::generate_write_array_method	(	const program &	prog,
		const std::string &	model_name,
		std::ostream &	o
	)

Generate the write_array method for the specified program, with specified model name to the specified stream.

Parameters

[in]	prog	program from which to generate
[in]	model_name	name of model
[in,out]	o	stream for generating

Definition at line 30 of file generate_write_array_method.hpp.

References stan::lang::program::derived_decl_, EOL(), EOL2(), generate_catch_throw_located(), generate_comment(), generate_local_var_decls(), generate_statements(), generate_try(), generate_validate_var_decls(), generate_void_statement(), stan::lang::program::generated_decl_, MECModelEnuComparisons::i, INDENT(), INDENT2(), INDENT3(), and stan::lang::program::parameter_decl_.

Referenced by generate_cpp().

                                                     {
       o << INDENT << "template <typename RNG>" << EOL;
       o << INDENT << "void write_array(RNG& base_rng__," << EOL;
       o << INDENT << "                 std::vector<double>& params_r__," << EOL;
       o << INDENT << "                 std::vector<int>& params_i__," << EOL;
       o << INDENT << "                 std::vector<double>& vars__," << EOL;
       o << INDENT << "                 bool include_tparams__ = true," << EOL;
       o << INDENT << "                 bool include_gqs__ = true," << EOL;
       o << INDENT
         << "                 std::ostream* pstream__ = 0) const {" << EOL;
       o << INDENT2 << "typedef double local_scalar_t__;" << EOL2;
 
       o << INDENT2 << "vars__.resize(0);" << EOL;
       o << INDENT2
         << "stan::io::reader<local_scalar_t__> in__(params_r__,params_i__);"
         << EOL;
       o << INDENT2 << "static const char* function__ = \""
         << model_name << "_namespace::write_array\";" << EOL;
       generate_void_statement("function__", 2, o);
 
       // declares, reads, and sets parameters
       generate_comment("read-transform, write parameters", 2, o);
       write_array_visgen vis(o);
       for (size_t i = 0; i < prog.parameter_decl_.size(); ++i)
         boost::apply_visitor(vis, prog.parameter_decl_[i].decl_);
 
 
       // writes parameters
       write_array_vars_visgen vis_writer(2, o);
       for (size_t i = 0; i < prog.parameter_decl_.size(); ++i)
         boost::apply_visitor(vis_writer, prog.parameter_decl_[i].decl_);
       o << EOL;
 
       generate_comment("declare and define transformed parameters", 2, o);
       o << INDENT2 <<  "double lp__ = 0.0;" << EOL;
       generate_void_statement("lp__", 2, o);
       o << INDENT2 << "stan::math::accumulator<double> lp_accum__;" << EOL2;
 
       o << INDENT2
         << "local_scalar_t__ DUMMY_VAR__"
         << "(std::numeric_limits<double>::quiet_NaN());"
         << EOL;
       o << INDENT2 << "(void) DUMMY_VAR__;  // suppress unused var warning"
         << EOL2;
 
       generate_try(2, o);
       generate_local_var_decls(prog.derived_decl_.first, 3, o);
       o << EOL;
       generate_statements(prog.derived_decl_.second, 3, o);
       

Classes

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation