stan::services::sample Namespace Reference

Classes
struct	adaptation_engaged
struct	gamma
struct	init_buffer
struct	int_time
struct	kappa
struct	max_depth
struct	num_samples
struct	num_warmup
struct	save_warmup
struct	stepsize
struct	stepsize_jitter
struct	t0
struct	term_buffer
struct	thin
struct	window

Functions
template<class Model >
int	fixed_param (Model &model, stan::io::var_context &init, unsigned int random_seed, unsigned int chain, double init_radius, int num_samples, int num_thin, int refresh, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_nuts_dense_e (Model &model, stan::io::var_context &init, stan::io::var_context &init_inv_metric, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, int max_depth, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_nuts_dense_e (Model &model, stan::io::var_context &init, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, int max_depth, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_nuts_dense_e_adapt (Model &model, stan::io::var_context &init, stan::io::var_context &init_inv_metric, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, int max_depth, double delta, double gamma, double kappa, double t0, unsigned int init_buffer, unsigned int term_buffer, unsigned int window, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_nuts_dense_e_adapt (Model &model, stan::io::var_context &init, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, int max_depth, double delta, double gamma, double kappa, double t0, unsigned int init_buffer, unsigned int term_buffer, unsigned int window, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_nuts_diag_e (Model &model, stan::io::var_context &init, stan::io::var_context &init_inv_metric, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, int max_depth, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_nuts_diag_e (Model &model, stan::io::var_context &init, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, int max_depth, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_nuts_diag_e_adapt (Model &model, stan::io::var_context &init, stan::io::var_context &init_inv_metric, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, int max_depth, double delta, double gamma, double kappa, double t0, unsigned int init_buffer, unsigned int term_buffer, unsigned int window, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_nuts_diag_e_adapt (Model &model, stan::io::var_context &init, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, int max_depth, double delta, double gamma, double kappa, double t0, unsigned int init_buffer, unsigned int term_buffer, unsigned int window, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_nuts_unit_e (Model &model, stan::io::var_context &init, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, int max_depth, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_nuts_unit_e_adapt (Model &model, stan::io::var_context &init, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, int max_depth, double delta, double gamma, double kappa, double t0, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_static_dense_e (Model &model, stan::io::var_context &init, stan::io::var_context &init_inv_metric, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, double int_time, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_static_dense_e (Model &model, stan::io::var_context &init, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, double int_time, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_static_dense_e_adapt (Model &model, stan::io::var_context &init, stan::io::var_context &init_inv_metric, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, double int_time, double delta, double gamma, double kappa, double t0, unsigned int init_buffer, unsigned int term_buffer, unsigned int window, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_static_dense_e_adapt (Model &model, stan::io::var_context &init, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, double int_time, double delta, double gamma, double kappa, double t0, unsigned int init_buffer, unsigned int term_buffer, unsigned int window, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_static_diag_e (Model &model, stan::io::var_context &init, stan::io::var_context &init_inv_metric, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, double int_time, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_static_diag_e (Model &model, stan::io::var_context &init, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, double int_time, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_static_diag_e_adapt (Model &model, stan::io::var_context &init, stan::io::var_context &init_inv_metric, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, double int_time, double delta, double gamma, double kappa, double t0, unsigned int init_buffer, unsigned int term_buffer, unsigned int window, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_static_diag_e_adapt (Model &model, stan::io::var_context &init, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, double int_time, double delta, double gamma, double kappa, double t0, unsigned int init_buffer, unsigned int term_buffer, unsigned int window, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_static_unit_e (Model &model, stan::io::var_context &init, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, double int_time, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)
template<class Model >
int	hmc_static_unit_e_adapt (Model &model, stan::io::var_context &init, unsigned int random_seed, unsigned int chain, double init_radius, int num_warmup, int num_samples, int num_thin, bool save_warmup, int refresh, double stepsize, double stepsize_jitter, double int_time, double delta, double gamma, double kappa, double t0, callbacks::interrupt &interrupt, callbacks::logger &logger, callbacks::writer &init_writer, callbacks::writer &sample_writer, callbacks::writer &diagnostic_writer)

Function Documentation

template<class Model >

int stan::services::sample::fixed_param	(	Model &	model,
		stan::io::var_context &	init,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_samples,
		int	num_thin,
		int	refresh,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs the fixed parameter sampler.

The fixed parameter sampler sets the parameters randomly once on the unconstrained scale, then runs the model for the number of iterations specified with the parameters fixed.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	refresh	Controls the output
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 44 of file fixed_param.hpp.

References stan::services::util::create_rng(), febshutoff_auto::end, stan::services::util::generate_transitions(), MECModelEnuComparisons::i, stan::services::util::initialize(), stan::services::error_codes::OK, febshutoff_auto::start, stan::services::util::mcmc_writer::write_diagnostic_names(), stan::services::util::mcmc_writer::write_sample_names(), and stan::services::util::mcmc_writer::write_timing().

Referenced by TEST_F().

                                                          {
        boost::ecuyer1988 rng = util::create_rng(random_seed, chain);

        std::vector<int> disc_vector;
        std::vector<double> cont_vector
          = util::initialize(model, init, rng, init_radius, false,
                             logger, init_writer);

        stan::mcmc::fixed_param_sampler sampler;
        util::mcmc_writer
          writer(sample_writer, diagnostic_writer, logger);
        Eigen::VectorXd cont_params(cont_vector.size());
        for (size_t i = 0; i < cont_vector.size(); i++)
          cont_params[i] = cont_vector[i];
        stan::mcmc::sample s(cont_params, 0, 0);

        // Headers
        writer.write_sample_names(s, sampler, model);
        writer.write_diagnostic_names(s, sampler, model);

        clock_t start = clock();

        util::generate_transitions(sampler, num_samples, 0, num_samples,
                                   num_thin, refresh, true, false, writer,
                                   s, model, rng, interrupt, logger);
        clock_t end = clock();

        double sampleDeltaT = static_cast<double>(end - start) / CLOCKS_PER_SEC;
        writer.write_timing(0.0, sampleDeltaT);

        return error_codes::OK;
      }

template<class Model >

int stan::services::sample::hmc_nuts_dense_e	(	Model &	model,
		stan::io::var_context &	init,
		stan::io::var_context &	init_inv_metric,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		int	max_depth,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs HMC with NUTS without adaptation using dense Euclidean metric with a pre-specified Euclidean metric.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	init_inv_metric	var context exposing an initial dense inverse Euclidean metric (must be positive definite)
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	max_depth	Maximum tree depth
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 49 of file hmc_nuts_dense_e.hpp.

References stan::services::error_codes::CONFIG, stan::services::util::create_rng(), stan::math::domain_error(), e, stan::services::util::initialize(), stan::services::error_codes::OK, stan::services::util::read_dense_inv_metric(), stan::services::util::run_sampler(), stan::mcmc::base_nuts< Model, dense_e_metric, expl_leapfrog, BaseRNG >::set_max_depth(), stan::mcmc::base_nuts< Model, dense_e_metric, expl_leapfrog, BaseRNG >::set_metric(), stan::mcmc::base_hmc< Model, dense_e_metric, expl_leapfrog, BaseRNG >::set_nominal_stepsize(), stan::mcmc::base_hmc< Model, dense_e_metric, expl_leapfrog, BaseRNG >::set_stepsize_jitter(), and stan::services::util::validate_dense_inv_metric().

Referenced by hmc_nuts_dense_e(), and TEST_F().

                                                               {
        boost::ecuyer1988 rng = util::create_rng(random_seed, chain);

        std::vector<int> disc_vector;
        std::vector<double> cont_vector
          = util::initialize(model, init, rng, init_radius, true,
                             logger, init_writer);

        Eigen::MatrixXd inv_metric;
        try {
          inv_metric =
            util::read_dense_inv_metric(init_inv_metric, model.num_params_r(),
                                         logger);
          util::validate_dense_inv_metric(inv_metric, logger);
        } catch (const std::domain_error& e) {
          return error_codes::CONFIG;
        }

        stan::mcmc::dense_e_nuts<Model, boost::ecuyer1988>
          sampler(model, rng);

        sampler.set_metric(inv_metric);

        sampler.set_nominal_stepsize(stepsize);
        sampler.set_stepsize_jitter(stepsize_jitter);
        sampler.set_max_depth(max_depth);

        util::run_sampler(sampler, model, cont_vector, num_warmup, num_samples,
                          num_thin, refresh, save_warmup, rng, interrupt,
                          logger,
                          sample_writer, diagnostic_writer);
        return error_codes::OK;
      }

template<class Model >

int stan::services::sample::hmc_nuts_dense_e	(	Model &	model,
		stan::io::var_context &	init,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		int	max_depth,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs HMC with NUTS without adaptation using dense Euclidean metric, with identity matrix as initial inv_metric.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	max_depth	Maximum tree depth
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 121 of file hmc_nuts_dense_e.hpp.

References stan::services::util::create_unit_e_dense_inv_metric(), and hmc_nuts_dense_e().

                                                               {
        stan::io::dump dmp =
          util::create_unit_e_dense_inv_metric(model.num_params_r());
        stan::io::var_context& unit_e_metric = dmp;

        return hmc_nuts_dense_e(model, init, unit_e_metric,
                                random_seed, chain, init_radius, num_warmup,
                                num_samples, num_thin, save_warmup, refresh,
                                stepsize, stepsize_jitter, max_depth,
                                interrupt, logger,
                                init_writer, sample_writer, diagnostic_writer);
      }

template<class Model >

int stan::services::sample::hmc_nuts_dense_e_adapt	(	Model &	model,
		stan::io::var_context &	init,
		stan::io::var_context &	init_inv_metric,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		int	max_depth,
		double	delta,
		double	gamma,
		double	kappa,
		double	t0,
		unsigned int	init_buffer,
		unsigned int	term_buffer,
		unsigned int	window,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs HMC with NUTS with adaptation using dense Euclidean metric with a pre-specified Euclidean metric.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	init_inv_metric	var context exposing an initial dense inverse Euclidean metric (must be positive definite)
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	max_depth	Maximum tree depth
[in]	delta	adaptation target acceptance statistic
[in]	gamma	adaptation regularization scale
[in]	kappa	adaptation relaxation exponent
[in]	t0	adaptation iteration offset
[in]	init_buffer	width of initial fast adaptation interval
[in]	term_buffer	width of final fast adaptation interval
[in]	window	initial width of slow adaptation interval
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 57 of file hmc_nuts_dense_e_adapt.hpp.

References stan::services::error_codes::CONFIG, stan::services::util::create_rng(), stan::math::domain_error(), e, stan::mcmc::stepsize_covar_adapter::get_stepsize_adaptation(), stan::services::util::initialize(), test_ParserArtEvents::log, stan::services::error_codes::OK, stan::services::util::read_dense_inv_metric(), stan::services::util::run_adaptive_sampler(), stan::mcmc::base_nuts< Model, dense_e_metric, expl_leapfrog, BaseRNG >::set_max_depth(), stan::mcmc::base_nuts< Model, dense_e_metric, expl_leapfrog, BaseRNG >::set_metric(), stan::mcmc::base_hmc< Model, dense_e_metric, expl_leapfrog, BaseRNG >::set_nominal_stepsize(), stan::mcmc::base_hmc< Model, dense_e_metric, expl_leapfrog, BaseRNG >::set_stepsize_jitter(), stan::mcmc::stepsize_covar_adapter::set_window_params(), and stan::services::util::validate_dense_inv_metric().

Referenced by hmc_nuts_dense_e_adapt(), and TEST_F().

                                                                     {
        boost::ecuyer1988 rng = util::create_rng(random_seed, chain);

        std::vector<int> disc_vector;
        std::vector<double> cont_vector
          = util::initialize(model, init, rng, init_radius, true,
                             logger, init_writer);

        Eigen::MatrixXd inv_metric;
        try {
          inv_metric =
            util::read_dense_inv_metric(init_inv_metric, model.num_params_r(),
                                        logger);
          util::validate_dense_inv_metric(inv_metric, logger);
        } catch (const std::domain_error& e) {
          return error_codes::CONFIG;
        }

        stan::mcmc::adapt_dense_e_nuts<Model, boost::ecuyer1988>
          sampler(model, rng);

        sampler.set_metric(inv_metric);

        sampler.set_nominal_stepsize(stepsize);
        sampler.set_stepsize_jitter(stepsize_jitter);
        sampler.set_max_depth(max_depth);

        sampler.get_stepsize_adaptation().set_mu(log(10 * stepsize));
        sampler.get_stepsize_adaptation().set_delta(delta);
        sampler.get_stepsize_adaptation().set_gamma(gamma);
        sampler.get_stepsize_adaptation().set_kappa(kappa);
        sampler.get_stepsize_adaptation().set_t0(t0);

        sampler.set_window_params(num_warmup, init_buffer, term_buffer,
                                  window, logger);

        util::run_adaptive_sampler(sampler, model, cont_vector, num_warmup,
                                   num_samples, num_thin, refresh, save_warmup,
                                   rng, interrupt, logger,
                                   sample_writer, diagnostic_writer);

        return error_codes::OK;
      }

template<class Model >

int stan::services::sample::hmc_nuts_dense_e_adapt	(	Model &	model,
		stan::io::var_context &	init,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		int	max_depth,
		double	delta,
		double	gamma,
		double	kappa,
		double	t0,
		unsigned int	init_buffer,
		unsigned int	term_buffer,
		unsigned int	window,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs HMC with NUTS with adaptation using dense Euclidean metric, with identity matrix as initial inv_metric.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	max_depth	Maximum tree depth
[in]	delta	adaptation target acceptance statistic
[in]	gamma	adaptation regularization scale
[in]	kappa	adaptation relaxation exponent
[in]	t0	adaptation iteration offset
[in]	init_buffer	width of initial fast adaptation interval
[in]	term_buffer	width of final fast adaptation interval
[in]	window	initial width of slow adaptation interval
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 148 of file hmc_nuts_dense_e_adapt.hpp.

References stan::services::util::create_unit_e_dense_inv_metric(), and hmc_nuts_dense_e_adapt().

                                                                     {
        stan::io::dump dmp =
          util::create_unit_e_dense_inv_metric(model.num_params_r());
        stan::io::var_context& unit_e_metric = dmp;

        return hmc_nuts_dense_e_adapt(model, init, unit_e_metric,
                                      random_seed, chain, init_radius,
                                      num_warmup, num_samples, num_thin,
                                      save_warmup, refresh,
                                      stepsize, stepsize_jitter, max_depth,
                                      delta, gamma, kappa, t0,
                                      init_buffer, term_buffer, window,
                                      interrupt, logger,
                                      init_writer, sample_writer,
                                      diagnostic_writer);
      }

template<class Model >

int stan::services::sample::hmc_nuts_diag_e	(	Model &	model,
		stan::io::var_context &	init,
		stan::io::var_context &	init_inv_metric,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		int	max_depth,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs HMC with NUTS without adaptation using diagonal Euclidean metric with a pre-specified Euclidean metric.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	init_inv_metric	var context exposing an initial diagonal inverse Euclidean metric (must be positive definite)
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	max_depth	Maximum tree depth
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 50 of file hmc_nuts_diag_e.hpp.

References stan::services::error_codes::CONFIG, stan::services::util::create_rng(), stan::math::domain_error(), e, stan::services::util::initialize(), stan::services::error_codes::OK, stan::services::util::read_diag_inv_metric(), stan::services::util::run_sampler(), stan::mcmc::base_nuts< Model, diag_e_metric, expl_leapfrog, BaseRNG >::set_max_depth(), stan::mcmc::base_nuts< Model, diag_e_metric, expl_leapfrog, BaseRNG >::set_metric(), stan::mcmc::base_hmc< Model, diag_e_metric, expl_leapfrog, BaseRNG >::set_nominal_stepsize(), stan::mcmc::base_hmc< Model, diag_e_metric, expl_leapfrog, BaseRNG >::set_stepsize_jitter(), and stan::services::util::validate_diag_inv_metric().

Referenced by hmc_nuts_diag_e(), and TEST_F().

                                                              {
        boost::ecuyer1988 rng = util::create_rng(random_seed, chain);
        std::vector<int> disc_vector;
        std::vector<double> cont_vector
          = util::initialize(model, init, rng, init_radius, true,
                             logger, init_writer);

        Eigen::VectorXd inv_metric;
        try {
          inv_metric =
            util::read_diag_inv_metric(init_inv_metric, model.num_params_r(),
                                        logger);
          util::validate_diag_inv_metric(inv_metric, logger);
        } catch (const std::domain_error& e) {
          return error_codes::CONFIG;
        }

        stan::mcmc::diag_e_nuts<Model, boost::ecuyer1988>
          sampler(model, rng);

        sampler.set_metric(inv_metric);
        sampler.set_nominal_stepsize(stepsize);
        sampler.set_stepsize_jitter(stepsize_jitter);
        sampler.set_max_depth(max_depth);

        util::run_sampler(sampler, model, cont_vector, num_warmup, num_samples,
                          num_thin, refresh, save_warmup, rng,
                          interrupt, logger,
                          sample_writer, diagnostic_writer);

        return error_codes::OK;
      }

template<class Model >

int stan::services::sample::hmc_nuts_diag_e	(	Model &	model,
		stan::io::var_context &	init,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		int	max_depth,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs HMC with NUTS without adaptation using diagonal Euclidean metric, with identity matrix as initial inv_metric.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	max_depth	Maximum tree depth
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 120 of file hmc_nuts_diag_e.hpp.

References stan::services::util::create_unit_e_diag_inv_metric(), and hmc_nuts_diag_e().

                                                              {
        stan::io::dump dmp =
          util::create_unit_e_diag_inv_metric(model.num_params_r());
        stan::io::var_context& unit_e_metric = dmp;

        return hmc_nuts_diag_e(model, init, unit_e_metric,
                               random_seed, chain, init_radius, num_warmup,
                               num_samples, num_thin, save_warmup, refresh,
                               stepsize, stepsize_jitter, max_depth,
                               interrupt, logger,
                               init_writer, sample_writer, diagnostic_writer);
      }

template<class Model >

int stan::services::sample::hmc_nuts_diag_e_adapt	(	Model &	model,
		stan::io::var_context &	init,
		stan::io::var_context &	init_inv_metric,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		int	max_depth,
		double	delta,
		double	gamma,
		double	kappa,
		double	t0,
		unsigned int	init_buffer,
		unsigned int	term_buffer,
		unsigned int	window,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs HMC with NUTS with adaptation using diagonal Euclidean metric with a pre-specified Euclidean metric.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	init_inv_metric	var context exposing an initial diagonal inverse Euclidean metric (must be positive definite)
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	max_depth	Maximum tree depth
[in]	delta	adaptation target acceptance statistic
[in]	gamma	adaptation regularization scale
[in]	kappa	adaptation relaxation exponent
[in]	t0	adaptation iteration offset
[in]	init_buffer	width of initial fast adaptation interval
[in]	term_buffer	width of final fast adaptation interval
[in]	window	initial width of slow adaptation interval
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 57 of file hmc_nuts_diag_e_adapt.hpp.

References stan::services::error_codes::CONFIG, stan::services::util::create_rng(), stan::math::domain_error(), e, stan::mcmc::stepsize_var_adapter::get_stepsize_adaptation(), stan::services::util::initialize(), test_ParserArtEvents::log, stan::services::error_codes::OK, stan::services::util::read_diag_inv_metric(), stan::services::util::run_adaptive_sampler(), stan::mcmc::base_nuts< Model, diag_e_metric, expl_leapfrog, BaseRNG >::set_max_depth(), stan::mcmc::base_nuts< Model, diag_e_metric, expl_leapfrog, BaseRNG >::set_metric(), stan::mcmc::base_hmc< Model, diag_e_metric, expl_leapfrog, BaseRNG >::set_nominal_stepsize(), stan::mcmc::base_hmc< Model, diag_e_metric, expl_leapfrog, BaseRNG >::set_stepsize_jitter(), stan::mcmc::stepsize_var_adapter::set_window_params(), and stan::services::util::validate_diag_inv_metric().

Referenced by stan::test::performance::command(), hmc_nuts_diag_e_adapt(), and TEST_F().

                                                                    {
        boost::ecuyer1988 rng = util::create_rng(random_seed, chain);

        std::vector<int> disc_vector;
        std::vector<double> cont_vector
          = util::initialize(model, init, rng, init_radius, true,
                             logger, init_writer);

        Eigen::VectorXd inv_metric;
        try {
          inv_metric =
            util::read_diag_inv_metric(init_inv_metric, model.num_params_r(),
                                        logger);
          util::validate_diag_inv_metric(inv_metric, logger);
        } catch (const std::domain_error& e) {
          return error_codes::CONFIG;
        }

        stan::mcmc::adapt_diag_e_nuts<Model, boost::ecuyer1988>
          sampler(model, rng);

        sampler.set_metric(inv_metric);
        sampler.set_nominal_stepsize(stepsize);
        sampler.set_stepsize_jitter(stepsize_jitter);
        sampler.set_max_depth(max_depth);

        sampler.get_stepsize_adaptation().set_mu(log(10 * stepsize));
        sampler.get_stepsize_adaptation().set_delta(delta);
        sampler.get_stepsize_adaptation().set_gamma(gamma);
        sampler.get_stepsize_adaptation().set_kappa(kappa);
        sampler.get_stepsize_adaptation().set_t0(t0);

        sampler.set_window_params(num_warmup, init_buffer, term_buffer,
                                  window, logger);

        util::run_adaptive_sampler(sampler, model, cont_vector, num_warmup,
                                   num_samples, num_thin, refresh, save_warmup,
                                   rng, interrupt, logger,
                                   sample_writer, diagnostic_writer);

        return error_codes::OK;
      }

template<class Model >

int stan::services::sample::hmc_nuts_diag_e_adapt	(	Model &	model,
		stan::io::var_context &	init,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		int	max_depth,
		double	delta,
		double	gamma,
		double	kappa,
		double	t0,
		unsigned int	init_buffer,
		unsigned int	term_buffer,
		unsigned int	window,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs HMC with NUTS with adaptation using diagonal Euclidean metric.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	max_depth	Maximum tree depth
[in]	delta	adaptation target acceptance statistic
[in]	gamma	adaptation regularization scale
[in]	kappa	adaptation relaxation exponent
[in]	t0	adaptation iteration offset
[in]	init_buffer	width of initial fast adaptation interval
[in]	term_buffer	width of final fast adaptation interval
[in]	window	initial width of slow adaptation interval
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 146 of file hmc_nuts_diag_e_adapt.hpp.

References stan::services::util::create_unit_e_diag_inv_metric(), and hmc_nuts_diag_e_adapt().

                                                                    {
        stan::io::dump dmp =
          util::create_unit_e_diag_inv_metric(model.num_params_r());
        stan::io::var_context& unit_e_metric = dmp;

        return hmc_nuts_diag_e_adapt(model, init, unit_e_metric,
                                     random_seed, chain, init_radius,
                                     num_warmup, num_samples, num_thin,
                                     save_warmup, refresh,
                                     stepsize, stepsize_jitter, max_depth,
                                     delta, gamma, kappa, t0,
                                     init_buffer, term_buffer, window,
                                     interrupt, logger,
                                     init_writer, sample_writer,
                                     diagnostic_writer);
      }

template<class Model >

int stan::services::sample::hmc_nuts_unit_e	(	Model &	model,
		stan::io::var_context &	init,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		int	max_depth,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs HMC with NUTS with unit Euclidean metric without adaptation.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	max_depth	Maximum tree depth
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 45 of file hmc_nuts_unit_e.hpp.

References stan::services::util::create_rng(), stan::services::util::initialize(), stan::services::error_codes::OK, stan::services::util::run_sampler(), stan::mcmc::base_nuts< Model, unit_e_metric, expl_leapfrog, BaseRNG >::set_max_depth(), stan::mcmc::base_hmc< Model, unit_e_metric, expl_leapfrog, BaseRNG >::set_nominal_stepsize(), and stan::mcmc::base_hmc< Model, unit_e_metric, expl_leapfrog, BaseRNG >::set_stepsize_jitter().

Referenced by TEST_F().

                                                              {
        boost::ecuyer1988 rng = util::create_rng(random_seed, chain);

        std::vector<int> disc_vector;
        std::vector<double> cont_vector
          = util::initialize(model, init, rng, init_radius, true,
                             logger, init_writer);

        stan::mcmc::unit_e_nuts<Model, boost::ecuyer1988> sampler(model, rng);
        sampler.set_nominal_stepsize(stepsize);
        sampler.set_stepsize_jitter(stepsize_jitter);
        sampler.set_max_depth(max_depth);

        util::run_sampler(sampler, model, cont_vector, num_warmup, num_samples,
                          num_thin, refresh, save_warmup, rng, interrupt,
                          logger,
                          sample_writer, diagnostic_writer);

        return error_codes::OK;
      }

template<class Model >

int stan::services::sample::hmc_nuts_unit_e_adapt	(	Model &	model,
		stan::io::var_context &	init,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		int	max_depth,
		double	delta,
		double	gamma,
		double	kappa,
		double	t0,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs HMC with NUTS with unit Euclidean metric with adaptation.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	max_depth	Maximum tree depth
[in]	delta	adaptation target acceptance statistic
[in]	gamma	adaptation regularization scale
[in]	kappa	adaptation relaxation exponent
[in]	t0	adaptation iteration offset
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 49 of file hmc_nuts_unit_e_adapt.hpp.

References stan::services::util::create_rng(), stan::mcmc::stepsize_adapter::get_stepsize_adaptation(), stan::services::util::initialize(), test_ParserArtEvents::log, stan::services::error_codes::OK, stan::services::util::run_adaptive_sampler(), stan::mcmc::base_nuts< Model, unit_e_metric, expl_leapfrog, BaseRNG >::set_max_depth(), stan::mcmc::base_hmc< Model, unit_e_metric, expl_leapfrog, BaseRNG >::set_nominal_stepsize(), and stan::mcmc::base_hmc< Model, unit_e_metric, expl_leapfrog, BaseRNG >::set_stepsize_jitter().

Referenced by TEST_F().

                                                                    {
        boost::ecuyer1988 rng = util::create_rng(random_seed, chain);

        std::vector<int> disc_vector;
        std::vector<double> cont_vector
          = util::initialize(model, init, rng, init_radius, true,
                             logger, init_writer);

        stan::mcmc::adapt_unit_e_nuts<Model, boost::ecuyer1988>
          sampler(model, rng);
        sampler.set_nominal_stepsize(stepsize);
        sampler.set_stepsize_jitter(stepsize_jitter);
        sampler.set_max_depth(max_depth);

        sampler.get_stepsize_adaptation().set_mu(log(10 * stepsize));
        sampler.get_stepsize_adaptation().set_delta(delta);
        sampler.get_stepsize_adaptation().set_gamma(gamma);
        sampler.get_stepsize_adaptation().set_kappa(kappa);
        sampler.get_stepsize_adaptation().set_t0(t0);

        util::run_adaptive_sampler(sampler, model, cont_vector, num_warmup,
                                   num_samples, num_thin, refresh, save_warmup,
                                   rng, interrupt, logger,
                                   sample_writer, diagnostic_writer);

        return error_codes::OK;
      }

template<class Model >

int stan::services::sample::hmc_static_dense_e	(	Model &	model,
		stan::io::var_context &	init,
		stan::io::var_context &	init_inv_metric,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		double	int_time,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs static HMC without adaptation using dense Euclidean metric with a pre-specified Euclidean metric.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	init_inv_metric	var context exposing an initial diagonal inverse Euclidean metric (must be positive definite)
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	int_time	integration time
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 48 of file hmc_static_dense_e.hpp.

References stan::services::error_codes::CONFIG, stan::services::util::create_rng(), stan::math::domain_error(), e, stan::services::util::initialize(), stan::services::error_codes::OK, stan::services::util::read_dense_inv_metric(), stan::services::util::run_sampler(), stan::mcmc::base_static_hmc< Model, dense_e_metric, expl_leapfrog, BaseRNG >::set_metric(), stan::mcmc::base_static_hmc< Model, dense_e_metric, expl_leapfrog, BaseRNG >::set_nominal_stepsize_and_T(), stan::mcmc::base_hmc< Model, dense_e_metric, expl_leapfrog, BaseRNG >::set_stepsize_jitter(), and stan::services::util::validate_dense_inv_metric().

Referenced by hmc_static_dense_e(), and TEST_F().

                                                                 {
        boost::ecuyer1988 rng = util::create_rng(random_seed, chain);

        std::vector<int> disc_vector;
        std::vector<double> cont_vector
          = util::initialize(model, init, rng, init_radius, true,
                             logger, init_writer);

        Eigen::MatrixXd inv_metric;
        try {
          inv_metric =
            util::read_dense_inv_metric(init_inv_metric, model.num_params_r(),
                                         logger);
          util::validate_dense_inv_metric(inv_metric, logger);
        } catch (const std::domain_error& e) {
          return error_codes::CONFIG;
        }

        stan::mcmc::dense_e_static_hmc<Model, boost::ecuyer1988>
          sampler(model, rng);

        sampler.set_metric(inv_metric);
        sampler.set_nominal_stepsize_and_T(stepsize, int_time);
        sampler.set_stepsize_jitter(stepsize_jitter);

        util::run_sampler(sampler, model, cont_vector, num_warmup, num_samples,
                          num_thin, refresh, save_warmup, rng, interrupt,
                          logger,
                          sample_writer, diagnostic_writer);

        return error_codes::OK;
      }

template<class Model >

int stan::services::sample::hmc_static_dense_e	(	Model &	model,
		stan::io::var_context &	init,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		double	int_time,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs static HMC without adaptation using dense Euclidean metric, with identity matrix as initial inv_metric.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	int_time	integration time
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 120 of file hmc_static_dense_e.hpp.

References stan::services::util::create_unit_e_dense_inv_metric(), and hmc_static_dense_e().

                                                                 {
        stan::io::dump dmp =
          util::create_unit_e_dense_inv_metric(model.num_params_r());
        stan::io::var_context& unit_e_metric = dmp;

        return hmc_static_dense_e(model, init, unit_e_metric,
                                random_seed, chain, init_radius, num_warmup,
                                num_samples, num_thin, save_warmup, refresh,
                                stepsize, stepsize_jitter, int_time,
                                interrupt, logger,
                                init_writer, sample_writer, diagnostic_writer);
      }

template<class Model >

int stan::services::sample::hmc_static_dense_e_adapt	(	Model &	model,
		stan::io::var_context &	init,
		stan::io::var_context &	init_inv_metric,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		double	int_time,
		double	delta,
		double	gamma,
		double	kappa,
		double	t0,
		unsigned int	init_buffer,
		unsigned int	term_buffer,
		unsigned int	window,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs static HMC with adaptation using dense Euclidean metric with a pre-specified Euclidean metric.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	init_inv_metric	var context exposing an initial diagonal inverse Euclidean metric (must be positive definite)
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	int_time	integration time
[in]	delta	adaptation target acceptance statistic
[in]	gamma	adaptation regularization scale
[in]	kappa	adaptation relaxation exponent
[in]	t0	adaptation iteration offset
[in]	init_buffer	width of initial fast adaptation interval
[in]	term_buffer	width of final fast adaptation interval
[in]	window	initial width of slow adaptation interval
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 57 of file hmc_static_dense_e_adapt.hpp.

References stan::services::error_codes::CONFIG, stan::services::util::create_rng(), stan::math::domain_error(), e, stan::mcmc::stepsize_covar_adapter::get_stepsize_adaptation(), stan::services::util::initialize(), test_ParserArtEvents::log, stan::services::error_codes::OK, stan::services::util::read_dense_inv_metric(), stan::services::util::run_adaptive_sampler(), stan::mcmc::base_static_hmc< Model, dense_e_metric, expl_leapfrog, BaseRNG >::set_metric(), stan::mcmc::base_static_hmc< Model, dense_e_metric, expl_leapfrog, BaseRNG >::set_nominal_stepsize_and_T(), stan::mcmc::base_hmc< Model, dense_e_metric, expl_leapfrog, BaseRNG >::set_stepsize_jitter(), stan::mcmc::stepsize_covar_adapter::set_window_params(), and stan::services::util::validate_dense_inv_metric().

Referenced by hmc_static_dense_e_adapt(), and TEST_F().

                                                                       {
        boost::ecuyer1988 rng = util::create_rng(random_seed, chain);

        std::vector<int> disc_vector;
        std::vector<double> cont_vector
          = util::initialize(model, init, rng, init_radius, true,
                             logger, init_writer);

        Eigen::MatrixXd inv_metric;
        try {
          inv_metric =
            util::read_dense_inv_metric(init_inv_metric, model.num_params_r(),
                                         logger);
          util::validate_dense_inv_metric(inv_metric, logger);
        } catch (const std::domain_error& e) {
          return error_codes::CONFIG;
        }

        stan::mcmc::adapt_dense_e_static_hmc<Model, boost::ecuyer1988>
          sampler(model, rng);

        sampler.set_metric(inv_metric);
        sampler.set_nominal_stepsize_and_T(stepsize, int_time);
        sampler.set_stepsize_jitter(stepsize_jitter);

        sampler.get_stepsize_adaptation().set_mu(log(10 * stepsize));
        sampler.get_stepsize_adaptation().set_delta(delta);
        sampler.get_stepsize_adaptation().set_gamma(gamma);
        sampler.get_stepsize_adaptation().set_kappa(kappa);
        sampler.get_stepsize_adaptation().set_t0(t0);

        sampler.set_window_params(num_warmup, init_buffer, term_buffer,
                                  window, logger);

        util::run_adaptive_sampler(sampler, model, cont_vector, num_warmup,
                                   num_samples, num_thin, refresh, save_warmup,
                                   rng, interrupt, logger,
                                   sample_writer, diagnostic_writer);

        return error_codes::OK;
     }

template<class Model >

int stan::services::sample::hmc_static_dense_e_adapt	(	Model &	model,
		stan::io::var_context &	init,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		double	int_time,
		double	delta,
		double	gamma,
		double	kappa,
		double	t0,
		unsigned int	init_buffer,
		unsigned int	term_buffer,
		unsigned int	window,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs static HMC with adaptation using dense Euclidean metric. with identity matrix as initial inv_metric.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	int_time	integration time
[in]	delta	adaptation target acceptance statistic
[in]	gamma	adaptation regularization scale
[in]	kappa	adaptation relaxation exponent
[in]	t0	adaptation iteration offset
[in]	init_buffer	width of initial fast adaptation interval
[in]	term_buffer	width of final fast adaptation interval
[in]	window	initial width of slow adaptation interval
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 148 of file hmc_static_dense_e_adapt.hpp.

References stan::services::util::create_unit_e_dense_inv_metric(), and hmc_static_dense_e_adapt().

                                                                       {
        stan::io::dump dmp =
          util::create_unit_e_dense_inv_metric(model.num_params_r());
        stan::io::var_context& unit_e_metric = dmp;

        return hmc_static_dense_e_adapt(model, init, unit_e_metric,
                                        random_seed, chain, init_radius,
                                        num_warmup, num_samples, num_thin,
                                        save_warmup, refresh,
                                        stepsize, stepsize_jitter, int_time,
                                        delta, gamma, kappa, t0,
                                        init_buffer, term_buffer, window,
                                        interrupt, logger,
                                        init_writer, sample_writer,
                                        diagnostic_writer);
      }

template<class Model >

int stan::services::sample::hmc_static_diag_e	(	Model &	model,
		stan::io::var_context &	init,
		stan::io::var_context &	init_inv_metric,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		double	int_time,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs static HMC without adaptation using diagonal Euclidean metric with a pre-specified Euclidean metric.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	init_inv_metric	var context exposing an initial diagonal inverse Euclidean metric (must be positive definite)
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	int_time	integration time
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 51 of file hmc_static_diag_e.hpp.

References stan::services::error_codes::CONFIG, stan::services::util::create_rng(), stan::math::domain_error(), e, stan::services::util::initialize(), stan::services::error_codes::OK, stan::services::util::read_diag_inv_metric(), stan::services::util::run_sampler(), stan::mcmc::base_static_hmc< Model, diag_e_metric, expl_leapfrog, BaseRNG >::set_metric(), stan::mcmc::base_static_hmc< Model, diag_e_metric, expl_leapfrog, BaseRNG >::set_nominal_stepsize_and_T(), stan::mcmc::base_hmc< Model, diag_e_metric, expl_leapfrog, BaseRNG >::set_stepsize_jitter(), and stan::services::util::validate_diag_inv_metric().

Referenced by hmc_static_diag_e(), and TEST_F().

                                                                {
        boost::ecuyer1988 rng = util::create_rng(random_seed, chain);

        std::vector<int> disc_vector;
        std::vector<double> cont_vector
          = util::initialize(model, init, rng, init_radius, true,
                             logger, init_writer);

        Eigen::VectorXd inv_metric;
        try {
          inv_metric =
            util::read_diag_inv_metric(init_inv_metric, model.num_params_r(),
                                        logger);
          util::validate_diag_inv_metric(inv_metric, logger);
        } catch (const std::domain_error& e) {
          return error_codes::CONFIG;
        }

        stan::mcmc::diag_e_static_hmc<Model, boost::ecuyer1988>
          sampler(model, rng);

        sampler.set_metric(inv_metric);
        sampler.set_nominal_stepsize_and_T(stepsize, int_time);
        sampler.set_stepsize_jitter(stepsize_jitter);

        util::run_sampler(sampler, model, cont_vector, num_warmup, num_samples,
                          num_thin, refresh, save_warmup, rng, interrupt,
                          logger, sample_writer, diagnostic_writer);

        return error_codes::OK;
      }

template<class Model >

int stan::services::sample::hmc_static_diag_e	(	Model &	model,
		stan::io::var_context &	init,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		double	int_time,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs static HMC without adaptation using diagonal Euclidean metric. with identity matrix as initial inv_metric.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	int_time	integration time
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 120 of file hmc_static_diag_e.hpp.

References stan::services::util::create_unit_e_diag_inv_metric(), and hmc_static_diag_e().

                                                                {
        stan::io::dump dmp =
          util::create_unit_e_diag_inv_metric(model.num_params_r());
        stan::io::var_context& unit_e_metric = dmp;

        return hmc_static_diag_e(model, init, unit_e_metric,
                                 random_seed, chain, init_radius, num_warmup,
                                 num_samples, num_thin, save_warmup, refresh,
                                 stepsize, stepsize_jitter, int_time,
                                 interrupt, logger,
                                 init_writer, sample_writer, diagnostic_writer);
      }

template<class Model >

int stan::services::sample::hmc_static_diag_e_adapt	(	Model &	model,
		stan::io::var_context &	init,
		stan::io::var_context &	init_inv_metric,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		double	int_time,
		double	delta,
		double	gamma,
		double	kappa,
		double	t0,
		unsigned int	init_buffer,
		unsigned int	term_buffer,
		unsigned int	window,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs static HMC with adaptation using diagonal Euclidean metric with a pre-specified Euclidean metric.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	init_inv_metric	var context exposing an initial diagonal inverse Euclidean metric (must be positive definite)
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	int_time	integration time
[in]	delta	adaptation target acceptance statistic
[in]	gamma	adaptation regularization scale
[in]	kappa	adaptation relaxation exponent
[in]	t0	adaptation iteration offset
[in]	init_buffer	width of initial fast adaptation interval
[in]	term_buffer	width of final fast adaptation interval
[in]	window	initial width of slow adaptation interval
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 57 of file hmc_static_diag_e_adapt.hpp.

References stan::services::error_codes::CONFIG, stan::services::util::create_rng(), stan::math::domain_error(), e, stan::mcmc::stepsize_var_adapter::get_stepsize_adaptation(), stan::services::util::initialize(), test_ParserArtEvents::log, stan::services::error_codes::OK, stan::services::util::read_diag_inv_metric(), stan::services::util::run_adaptive_sampler(), stan::mcmc::base_static_hmc< Model, diag_e_metric, expl_leapfrog, BaseRNG >::set_metric(), stan::mcmc::base_static_hmc< Model, diag_e_metric, expl_leapfrog, BaseRNG >::set_nominal_stepsize_and_T(), stan::mcmc::base_hmc< Model, diag_e_metric, expl_leapfrog, BaseRNG >::set_stepsize_jitter(), stan::mcmc::stepsize_var_adapter::set_window_params(), and stan::services::util::validate_diag_inv_metric().

Referenced by hmc_static_diag_e_adapt(), and TEST_F().

                                                                      {
        boost::ecuyer1988 rng = util::create_rng(random_seed, chain);

        std::vector<int> disc_vector;
        std::vector<double> cont_vector
          = util::initialize(model, init, rng, init_radius, true,
                             logger, init_writer);

        Eigen::VectorXd inv_metric;
        try {
          inv_metric =
            util::read_diag_inv_metric(init_inv_metric, model.num_params_r(),
                                        logger);
          util::validate_diag_inv_metric(inv_metric, logger);
        } catch (const std::domain_error& e) {
          return error_codes::CONFIG;
        }

        stan::mcmc::adapt_diag_e_static_hmc<Model, boost::ecuyer1988>
          sampler(model, rng);

        sampler.set_metric(inv_metric);
        sampler.set_nominal_stepsize_and_T(stepsize, int_time);
        sampler.set_stepsize_jitter(stepsize_jitter);

        sampler.get_stepsize_adaptation().set_mu(log(10 * stepsize));
        sampler.get_stepsize_adaptation().set_delta(delta);
        sampler.get_stepsize_adaptation().set_gamma(gamma);
        sampler.get_stepsize_adaptation().set_kappa(kappa);
        sampler.get_stepsize_adaptation().set_t0(t0);

        sampler.set_window_params(num_warmup, init_buffer, term_buffer,
                                  window, logger);

        util::run_adaptive_sampler(sampler, model, cont_vector, num_warmup,
                                   num_samples, num_thin, refresh, save_warmup,
                                   rng, interrupt, logger,
                                   sample_writer, diagnostic_writer);

        return error_codes::OK;
      }

template<class Model >

int stan::services::sample::hmc_static_diag_e_adapt	(	Model &	model,
		stan::io::var_context &	init,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		double	int_time,
		double	delta,
		double	gamma,
		double	kappa,
		double	t0,
		unsigned int	init_buffer,
		unsigned int	term_buffer,
		unsigned int	window,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs static HMC with adaptation using diagonal Euclidean metric, with identity matrix as initial inv_metric.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	int_time	integration time
[in]	delta	adaptation target acceptance statistic
[in]	gamma	adaptation regularization scale
[in]	kappa	adaptation relaxation exponent
[in]	t0	adaptation iteration offset
[in]	init_buffer	width of initial fast adaptation interval
[in]	term_buffer	width of final fast adaptation interval
[in]	window	initial width of slow adaptation interval
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 147 of file hmc_static_diag_e_adapt.hpp.

References stan::services::util::create_unit_e_diag_inv_metric(), and hmc_static_diag_e_adapt().

                                                                      {
        stan::io::dump dmp =
          util::create_unit_e_diag_inv_metric(model.num_params_r());
        stan::io::var_context& unit_e_metric = dmp;

        return hmc_static_diag_e_adapt(model, init, unit_e_metric,
                                       random_seed, chain, init_radius,
                                       num_warmup, num_samples, num_thin,
                                       save_warmup, refresh,
                                       stepsize, stepsize_jitter, int_time,
                                       delta, gamma, kappa, t0,
                                       init_buffer, term_buffer, window,
                                       interrupt, logger,
                                       init_writer, sample_writer,
                                       diagnostic_writer);
      }

template<class Model >

int stan::services::sample::hmc_static_unit_e	(	Model &	model,
		stan::io::var_context &	init,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		double	int_time,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs static HMC with unit Euclidean metric without adaptation.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	int_time	integration time
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 46 of file hmc_static_unit_e.hpp.

References stan::services::util::create_rng(), stan::services::util::initialize(), stan::services::error_codes::OK, stan::services::util::run_sampler(), stan::mcmc::base_static_hmc< Model, unit_e_metric, expl_leapfrog, BaseRNG >::set_nominal_stepsize_and_T(), and stan::mcmc::base_hmc< Model, unit_e_metric, expl_leapfrog, BaseRNG >::set_stepsize_jitter().

                                                                {
        boost::ecuyer1988 rng = util::create_rng(random_seed, chain);

        std::vector<int> disc_vector;
        std::vector<double> cont_vector
          = util::initialize(model, init, rng, init_radius, true,
                             logger, init_writer);

        stan::mcmc::unit_e_static_hmc<Model, boost::ecuyer1988>
          sampler(model, rng);
        sampler.set_nominal_stepsize_and_T(stepsize, int_time);
        sampler.set_stepsize_jitter(stepsize_jitter);

        util::run_sampler(sampler, model, cont_vector, num_warmup, num_samples,
                          num_thin, refresh, save_warmup, rng, interrupt,
                          logger, sample_writer,
                          diagnostic_writer);

        return error_codes::OK;
      }

template<class Model >

int stan::services::sample::hmc_static_unit_e_adapt	(	Model &	model,
		stan::io::var_context &	init,
		unsigned int	random_seed,
		unsigned int	chain,
		double	init_radius,
		int	num_warmup,
		int	num_samples,
		int	num_thin,
		bool	save_warmup,
		int	refresh,
		double	stepsize,
		double	stepsize_jitter,
		double	int_time,
		double	delta,
		double	gamma,
		double	kappa,
		double	t0,
		callbacks::interrupt &	interrupt,
		callbacks::logger &	logger,
		callbacks::writer &	init_writer,
		callbacks::writer &	sample_writer,
		callbacks::writer &	diagnostic_writer
	)

Runs static HMC with unit Euclidean metric with adaptation.

Template Parameters

Model

Model class

Parameters

[in]	model	Input model to test (with data already instantiated)
[in]	init	var context for initialization
[in]	random_seed	random seed for the random number generator
[in]	chain	chain id to advance the pseudo random number generator
[in]	init_radius	radius to initialize
[in]	num_warmup	Number of warmup samples
[in]	num_samples	Number of samples
[in]	num_thin	Number to thin the samples
[in]	save_warmup	Indicates whether to save the warmup iterations
[in]	refresh	Controls the output
[in]	stepsize	initial stepsize for discrete evolution
[in]	stepsize_jitter	uniform random jitter of stepsize
[in]	int_time	integration time
[in]	delta	adaptation target acceptance statistic
[in]	gamma	adaptation regularization scale
[in]	kappa	adaptation relaxation exponent
[in]	t0	adaptation iteration offset
[in,out]	interrupt	Callback for interrupts
[in,out]	logger	Logger for messages
[in,out]	init_writer	Writer callback for unconstrained inits
[in,out]	sample_writer	Writer for draws
[in,out]	diagnostic_writer	Writer for diagnostic information

Returns

error_codes::OK if successful

Definition at line 50 of file hmc_static_unit_e_adapt.hpp.

References stan::services::util::create_rng(), stan::mcmc::stepsize_adapter::get_stepsize_adaptation(), stan::services::util::initialize(), test_ParserArtEvents::log, stan::services::error_codes::OK, stan::services::util::run_adaptive_sampler(), stan::mcmc::base_static_hmc< Model, unit_e_metric, expl_leapfrog, BaseRNG >::set_nominal_stepsize_and_T(), and stan::mcmc::base_hmc< Model, unit_e_metric, expl_leapfrog, BaseRNG >::set_stepsize_jitter().

Referenced by TEST_F().

                                                                      {
        boost::ecuyer1988 rng = util::create_rng(random_seed, chain);

        std::vector<int> disc_vector;
        std::vector<double> cont_vector
          = util::initialize(model, init, rng, init_radius,
                             true, logger, init_writer);

        stan::mcmc::adapt_unit_e_static_hmc<Model, boost::ecuyer1988>
          sampler(model, rng);
        sampler.set_nominal_stepsize_and_T(stepsize, int_time);
        sampler.set_stepsize_jitter(stepsize_jitter);

        sampler.get_stepsize_adaptation().set_mu(log(10 * stepsize));
        sampler.get_stepsize_adaptation().set_delta(delta);
        sampler.get_stepsize_adaptation().set_gamma(gamma);
        sampler.get_stepsize_adaptation().set_kappa(kappa);
        sampler.get_stepsize_adaptation().set_t0(t0);

        util::run_adaptive_sampler(sampler, model, cont_vector,
                                   num_warmup, num_samples, num_thin,
                                   refresh, save_warmup, rng,
                                   interrupt, logger,
                                   sample_writer, diagnostic_writer);

        return error_codes::OK;
      }