TEST(McmcNutsBaseNuts, transition) {
rng_t base_rng(0);
int model_size = 1;
double init_momentum = 1.5;
stan::mcmc::ps_point z_init(model_size);
z_init.q(0) = 0;
z_init.p(0) = init_momentum;
stan::mcmc::mock_model model(model_size);
stan::mcmc::mock_nuts sampler(model, base_rng);
sampler.set_nominal_stepsize(1);
sampler.set_stepsize_jitter(0);
sampler.sample_stepsize();
sampler.z() = z_init;
std::stringstream output_stream;
stan::interface_callbacks::writer::stream_writer writer(output_stream);
std::stringstream error_stream;
stan::interface_callbacks::writer::stream_writer error_writer(error_stream);
stan::mcmc::sample init_sample(z_init.q, 0, 0);
stan::mcmc::sample s = sampler.transition(init_sample, writer, error_writer);
EXPECT_EQ(31.5, s.cont_params()(0));
EXPECT_EQ(0, s.log_prob());
EXPECT_EQ(1, s.accept_stat());
EXPECT_EQ("", output_stream.str());
EXPECT_EQ("", error_stream.str());
}
// Returns number of valid points in the completed subtree
int build_tree(int depth, Eigen::VectorXd& rho,
ps_point* z_init, ps_point& z_propose, nuts_util& util)
{
// Base case
if (depth == 0)
{
this->_integrator.evolve(this->_z, this->_hamiltonian,
util.sign * this->_epsilon);
rho += this->_z.p;
if (z_init) *z_init = this->_z;
z_propose = static_cast<ps_point>(this->_z);
double h = this->_hamiltonian.H(this->_z);
if (h != h) h = std::numeric_limits<double>::infinity();
util.criterion = util.log_u + (h - util.H0) < this->_max_delta;
util.sum_prob += stan::math::min(1, std::exp(util.H0 - h));
util.n_tree += 1;
return (util.log_u + (h - util.H0) < 0);
}
// General recursion
else
{
Eigen::VectorXd subtree_rho = Eigen::VectorXd::Zero(rho.size());
ps_point z_init(this->_z);
int n1 = build_tree(depth - 1, subtree_rho, &z_init, z_propose, util);
rho += subtree_rho;
if (!util.criterion) return 0;
subtree_rho.setZero();
ps_point z_propose_right(z_init);
int n2 = build_tree(depth - 1, subtree_rho, 0, z_propose_right, util);
rho += subtree_rho;
double accept_prob = static_cast<double>(n2) /
static_cast<double>(n1 + n2);
if ( util.criterion && (this->_rand_uniform() < accept_prob) )
z_propose = z_propose_right;
util.criterion &= _compute_criterion(z_init, this->_z, rho);
return n1 + n2;
}
}
sample transition(sample& init_sample) {
this->sample_stepsize();
this->seed(init_sample.cont_params());
this->hamiltonian_.sample_p(this->z_, this->rand_int_);
this->hamiltonian_.init(this->z_);
ps_point z_init(this->z_);
double H0 = this->hamiltonian_.H(this->z_);
for (int i = 0; i < L_; ++i)
this->integrator_.evolve(this->z_, this->hamiltonian_,
this->epsilon_);
double h = this->hamiltonian_.H(this->z_);
if (boost::math::isnan(h)) h = std::numeric_limits<double>::infinity();
double acceptProb = std::exp(H0 - h);
if (acceptProb < 1 && this->rand_uniform_() > acceptProb)
this->z_.ps_point::operator=(z_init);
acceptProb = acceptProb > 1 ? 1 : acceptProb;
return sample(this->z_.q, - this->hamiltonian_.V(this->z_), acceptProb);
}
// Returns number of valid points in the completed subtree
int build_tree(int depth, Eigen::VectorXd& rho,
ps_point* z_init_parent, ps_point& z_propose,
nuts_util& util) {
// Base case
if (depth == 0) {
this->integrator_.evolve(this->z_, this->hamiltonian_,
util.sign * this->epsilon_);
rho += this->z_.p;
if (z_init_parent) *z_init_parent = this->z_;
z_propose = this->z_;
double h = this->hamiltonian_.H(this->z_);
if (boost::math::isnan(h))
h = std::numeric_limits<double>::infinity();
util.criterion = util.log_u + (h - util.H0) < this->max_delta_;
if (!util.criterion) ++(this->n_divergent_);
util.sum_prob += stan::math::min(1, std::exp(util.H0 - h));
util.n_tree += 1;
return (util.log_u + (h - util.H0) < 0);
} else {
// General recursion
Eigen::VectorXd left_subtree_rho(rho.size());
left_subtree_rho.setZero();
ps_point z_init(this->z_);
int n1 = build_tree(depth - 1, left_subtree_rho, &z_init,
z_propose, util);
if (z_init_parent) *z_init_parent = z_init;
if (!util.criterion) return 0;
Eigen::VectorXd right_subtree_rho(rho.size());
right_subtree_rho.setZero();
ps_point z_propose_right(z_init);
int n2 = build_tree(depth - 1, right_subtree_rho, 0,
z_propose_right, util);
double accept_prob = static_cast<double>(n2) /
static_cast<double>(n1 + n2);
if ( util.criterion && (this->rand_uniform_() < accept_prob) )
z_propose = z_propose_right;
Eigen::VectorXd& subtree_rho = left_subtree_rho;
subtree_rho += right_subtree_rho;
rho += subtree_rho;
util.criterion &= compute_criterion(z_init, this->z_, subtree_rho);
return n1 + n2;
}
}
void init_stepsize() {
ps_point z_init(this->z_);
this->hamiltonian_.sample_p(this->z_, this->rand_int_);
this->hamiltonian_.init(this->z_);
// Guaranteed to be finite if randomly initialized
double H0 = this->hamiltonian_.H(this->z_);
this->integrator_.evolve(this->z_, this->hamiltonian_,
this->nom_epsilon_);
double h = this->hamiltonian_.H(this->z_);
if (boost::math::isnan(h))
h = std::numeric_limits<double>::infinity();
double delta_H = H0 - h;
int direction = delta_H > std::log(0.8) ? 1 : -1;
while (1) {
this->z_.ps_point::operator=(z_init);
this->hamiltonian_.sample_p(this->z_, this->rand_int_);
this->hamiltonian_.init(this->z_);
double H0 = this->hamiltonian_.H(this->z_);
this->integrator_.evolve(this->z_, this->hamiltonian_,
this->nom_epsilon_);
double h = this->hamiltonian_.H(this->z_);
if (boost::math::isnan(h))
h = std::numeric_limits<double>::infinity();
double delta_H = H0 - h;
if ((direction == 1) && !(delta_H > std::log(0.8)))
break;
else if ((direction == -1) && !(delta_H < std::log(0.8)))
break;
else
this->nom_epsilon_
= direction == 1
? 2.0 * this->nom_epsilon_
: 0.5 * this->nom_epsilon_;
if (this->nom_epsilon_ > 1e7)
throw std::runtime_error("Posterior is improper. "
"Please check your model.");
if (this->nom_epsilon_ == 0)
throw std::runtime_error("No acceptably small step size could "
"be found. Perhaps the posterior is "
"not continuous?");
}
this->z_.ps_point::operator=(z_init);
}
TEST(McmcNutsBaseNuts, build_tree_test) {
rng_t base_rng(0);
int model_size = 1;
double init_momentum = 1.5;
stan::mcmc::ps_point z_init(model_size);
z_init.q(0) = 0;
z_init.p(0) = init_momentum;
stan::mcmc::ps_point z_propose(model_size);
Eigen::VectorXd p_sharp_left = Eigen::VectorXd::Zero(model_size);
Eigen::VectorXd p_sharp_right = Eigen::VectorXd::Zero(model_size);
Eigen::VectorXd rho = z_init.p;
double log_sum_weight = -std::numeric_limits<double>::infinity();
double H0 = -0.1;
int n_leapfrog = 0;
double sum_metro_prob = 0;
stan::mcmc::mock_model model(model_size);
stan::mcmc::mock_nuts sampler(model, base_rng);
sampler.set_nominal_stepsize(1);
sampler.set_stepsize_jitter(0);
sampler.sample_stepsize();
sampler.z() = z_init;
std::stringstream debug, info, warn, error, fatal;
stan::callbacks::stream_logger logger(debug, info, warn, error, fatal);
bool valid_subtree = sampler.build_tree(3, z_propose,
p_sharp_left, p_sharp_right, rho,
H0, 1, n_leapfrog, log_sum_weight,
sum_metro_prob, logger);
EXPECT_TRUE(valid_subtree);
EXPECT_EQ(init_momentum * (n_leapfrog + 1), rho(0));
EXPECT_EQ(1, p_sharp_left(0));
EXPECT_EQ(1, p_sharp_right(0));
EXPECT_EQ(8 * init_momentum, sampler.z().q(0));
EXPECT_EQ(init_momentum, sampler.z().p(0));
EXPECT_EQ(8, n_leapfrog);
EXPECT_FLOAT_EQ(H0 + std::log(n_leapfrog), log_sum_weight);
EXPECT_FLOAT_EQ(std::exp(H0) * n_leapfrog, sum_metro_prob);
EXPECT_EQ("", debug.str());
EXPECT_EQ("", info.str());
EXPECT_EQ("", warn.str());
EXPECT_EQ("", error.str());
EXPECT_EQ("", fatal.str());
}
TEST(McmcBaseNuts, slice_criterion) {
rng_t base_rng(0);
int model_size = 1;
double init_momentum = 1.5;
Eigen::VectorXd rho = Eigen::VectorXd::Zero(model_size);
stan::mcmc::ps_point z_init(model_size);
z_init.q(0) = 0;
z_init.p(0) = init_momentum;
stan::mcmc::ps_point z_propose(model_size);
stan::mcmc::nuts_util util;
util.log_u = 0;
util.H0 = 0;
util.sign = 1;
util.n_tree = 0;
util.sum_prob = 0;
std::stringstream output, error;
stan::mcmc::mock_model model(model_size);
stan::mcmc::divergent_nuts sampler(model, base_rng, &output, &error);
sampler.set_nominal_stepsize(1);
sampler.set_stepsize_jitter(0);
sampler.sample_stepsize();
sampler.z() = z_init;
int n_valid = 0;
sampler.z().V = -750;
n_valid = sampler.build_tree(0, rho, &z_init, z_propose, util);
EXPECT_EQ(1, n_valid);
EXPECT_EQ(0, sampler.n_divergent_);
sampler.z().V = -250;
n_valid = sampler.build_tree(0, rho, &z_init, z_propose, util);
EXPECT_EQ(0, n_valid);
EXPECT_EQ(0, sampler.n_divergent_);
sampler.z().V = 750;
n_valid = sampler.build_tree(0, rho, &z_init, z_propose, util);
EXPECT_EQ(0, n_valid);
EXPECT_EQ(1, sampler.n_divergent_);
EXPECT_EQ("", output.str());
EXPECT_EQ("", error.str());
}
TEST(McmcNutsBaseNuts, build_tree) {
rng_t base_rng(0);
int model_size = 1;
double init_momentum = 1.5;
stan::mcmc::ps_point z_init(model_size);
z_init.q(0) = 0;
z_init.p(0) = init_momentum;
stan::mcmc::ps_point z_propose(model_size);
Eigen::VectorXd rho = z_init.p;
double log_sum_weight = -std::numeric_limits<double>::infinity();
double H0 = -0.1;
int n_leapfrog = 0;
double sum_metro_prob = 0;
stan::mcmc::mock_model model(model_size);
stan::mcmc::mock_nuts sampler(model, base_rng);
sampler.set_nominal_stepsize(1);
sampler.set_stepsize_jitter(0);
sampler.sample_stepsize();
sampler.z() = z_init;
std::stringstream output;
stan::interface_callbacks::writer::stream_writer writer(output);
std::stringstream error_stream;
stan::interface_callbacks::writer::stream_writer error_writer(error_stream);
bool valid_subtree = sampler.build_tree(3, rho, z_propose,
H0, 1, n_leapfrog, log_sum_weight,
sum_metro_prob, writer, error_writer);
EXPECT_TRUE(valid_subtree);
EXPECT_EQ(init_momentum * (n_leapfrog + 1), rho(0));
EXPECT_EQ(8 * init_momentum, sampler.z().q(0));
EXPECT_EQ(init_momentum, sampler.z().p(0));
EXPECT_EQ(8, n_leapfrog);
EXPECT_FLOAT_EQ(H0 + std::log(n_leapfrog), log_sum_weight);
EXPECT_FLOAT_EQ(std::exp(H0) * n_leapfrog, sum_metro_prob);
EXPECT_EQ("", output.str());
EXPECT_EQ("", error_stream.str());
}
TEST(McmcBaseNuts, build_tree) {
rng_t base_rng(0);
int model_size = 1;
double init_momentum = 1.5;
Eigen::VectorXd rho = Eigen::VectorXd::Zero(model_size);
stan::mcmc::ps_point z_init(model_size);
z_init.q(0) = 0;
z_init.p(0) = init_momentum;
stan::mcmc::ps_point z_propose(model_size);
stan::mcmc::nuts_util util;
util.log_u = -1;
util.H0 = -0.1;
util.sign = 1;
util.n_tree = 0;
util.sum_prob = 0;
std::stringstream output, error;
stan::mcmc::mock_model model(model_size);
stan::mcmc::mock_nuts sampler(model, base_rng, &output, &error);
sampler.set_nominal_stepsize(1);
sampler.set_stepsize_jitter(0);
sampler.sample_stepsize();
sampler.z() = z_init;
int n_valid = sampler.build_tree(3, rho, &z_init, z_propose, util);
EXPECT_EQ(8, n_valid);
EXPECT_EQ(8, util.n_tree);
EXPECT_FLOAT_EQ(std::exp(util.H0) * util.n_tree, util.sum_prob);
EXPECT_EQ(init_momentum * util.n_tree, rho(0));
EXPECT_EQ(init_momentum, z_init.q(0));
EXPECT_EQ(init_momentum, z_init.p(0));
EXPECT_EQ(8 * init_momentum, sampler.z().q(0));
EXPECT_EQ(init_momentum, sampler.z().p(0));
EXPECT_EQ("", output.str());
EXPECT_EQ("", error.str());
}
// zcode --------------
int librlc_z_encode(int k, int m, int packet_size,
const char *orig_data, int orig_data_len,
char **encoded_data, char **encoded_parity,
int *chunk_len)
{
z_coder_t z_code;
// z init
z_init(&z_code, m, k, packet_size);
// z encode
int ret = z_encode(z_code.pzi, orig_data, orig_data_len, encoded_data, encoded_parity, chunk_len);
// rs free
z_free(&z_code);
return ret;
}
TEST(McmcNutsBaseNuts, rho_aggregation_test) {
rng_t base_rng(0);
int model_size = 1;
double init_momentum = 1.5;
stan::mcmc::ps_point z_init(model_size);
z_init.q(0) = 0;
z_init.p(0) = init_momentum;
stan::mcmc::ps_point z_propose(model_size);
Eigen::VectorXd p_sharp_left = Eigen::VectorXd::Zero(model_size);
Eigen::VectorXd p_sharp_right = Eigen::VectorXd::Zero(model_size);
Eigen::VectorXd rho = z_init.p;
double log_sum_weight = -std::numeric_limits<double>::infinity();
double H0 = -0.1;
int n_leapfrog = 0;
double sum_metro_prob = 0;
stan::mcmc::mock_model model(model_size);
stan::mcmc::rho_inspector_mock_nuts sampler(model, base_rng);
sampler.set_nominal_stepsize(1);
sampler.set_stepsize_jitter(0);
sampler.sample_stepsize();
sampler.z() = z_init;
std::stringstream debug, info, warn, error, fatal;
stan::callbacks::stream_logger logger(debug, info, warn, error, fatal);
sampler.build_tree(3, z_propose,
p_sharp_left, p_sharp_right, rho,
H0, 1, n_leapfrog, log_sum_weight,
sum_metro_prob, logger);
EXPECT_EQ(7, sampler.rho_values.size());
EXPECT_EQ(2 * init_momentum, sampler.rho_values.at(0));
EXPECT_EQ(2 * init_momentum, sampler.rho_values.at(1));
EXPECT_EQ(4 * init_momentum, sampler.rho_values.at(2));
EXPECT_EQ(2 * init_momentum, sampler.rho_values.at(3));
EXPECT_EQ(2 * init_momentum, sampler.rho_values.at(4));
EXPECT_EQ(4 * init_momentum, sampler.rho_values.at(5));
EXPECT_EQ(8 * init_momentum, sampler.rho_values.at(6));
}
int librlc_z_repair(int k, int m, int packet_size,
char *available_data, int *data_list, int data_num,int chunk_len,
int node,
char **out_data)
{
int ret = 0;
z_coder_t z_code;
//z init
z_init(&z_code, m, k, packet_size);
// re repair
ret = z_repair(z_code.pzi, available_data, data_list, data_num,
chunk_len, node, out_data);
// z free
z_free(&z_code);
return ret;
}
static int z_consume(hpgs_z_ostream_stream *stream, int flags)
{
int cnt=stream->pptr-stream->buffer;
int zret;
if (stream->errflg)
return EOF;
if (!stream->zstream.next_out && z_init(stream)) return EOF;
if (cnt <= 0 && flags == Z_NO_FLUSH) return 0;
stream->zstream.avail_in=cnt;
stream->zstream.total_in=0;
stream->zstream.next_in=(Bytef *)stream->buffer;
do
{
stream->zstream.avail_out=Z_OSTREAM_XFER_SIZE;
stream->zstream.total_out=0;
stream->zstream.next_out=(Bytef *)stream->xfer;
zret=deflate (&stream->zstream,flags);
if (hpgs_ostream_write(stream->xfer,1,stream->zstream.total_out,stream->base) < stream->zstream.total_out)
{ stream->errflg = 1; return -1; }
}
while (zret == Z_OK &&
stream->zstream.avail_out == 0);
stream->pptr = stream->buffer;
if (stream->zstream.avail_in==0)
{
stream->total_bytes += cnt;
return 0;
}
else
{
stream->errflg = 1;
return -1;
}
}
TEST(McmcUnitENuts, transition_test) {
rng_t base_rng(4839294);
stan::mcmc::unit_e_point z_init(3);
z_init.q(0) = 1;
z_init.q(1) = -1;
z_init.q(2) = 1;
z_init.p(0) = -1;
z_init.p(1) = 1;
z_init.p(2) = -1;
std::stringstream output_stream;
stan::interface_callbacks::writer::stream_writer writer(output_stream);
std::stringstream error_stream;
stan::interface_callbacks::writer::stream_writer error_writer(error_stream);
std::fstream empty_stream("", std::fstream::in);
stan::io::dump data_var_context(empty_stream);
gauss3D_model_namespace::gauss3D_model model(data_var_context);
stan::mcmc::unit_e_nuts<gauss3D_model_namespace::gauss3D_model, rng_t>
sampler(model, base_rng);
sampler.z() = z_init;
sampler.init_hamiltonian(writer, error_writer);
sampler.set_nominal_stepsize(0.1);
sampler.set_stepsize_jitter(0);
sampler.sample_stepsize();
stan::mcmc::sample init_sample(z_init.q, 0, 0);
stan::mcmc::sample s = sampler.transition(init_sample, writer, error_writer);
EXPECT_EQ(4, sampler.depth_);
EXPECT_EQ((2 << 3) - 1, sampler.n_leapfrog_);
EXPECT_FALSE(sampler.divergent_);
EXPECT_FLOAT_EQ(1.8718261, s.cont_params()(0));
EXPECT_FLOAT_EQ(-0.74208695, s.cont_params()(1));
EXPECT_FLOAT_EQ( 1.5202962, s.cont_params()(2));
EXPECT_FLOAT_EQ(-3.1828632, s.log_prob());
EXPECT_FLOAT_EQ(0.99629009, s.accept_stat());
EXPECT_EQ("", output_stream.str());
EXPECT_EQ("", error_stream.str());
}
TEST(McmcNutsBaseNuts, transition) {
rng_t base_rng(0);
int model_size = 1;
double init_momentum = 1.5;
stan::mcmc::ps_point z_init(model_size);
z_init.q(0) = 0;
z_init.p(0) = init_momentum;
stan::mcmc::mock_model model(model_size);
stan::mcmc::mock_nuts sampler(model, base_rng);
sampler.set_nominal_stepsize(1);
sampler.set_stepsize_jitter(0);
sampler.sample_stepsize();
sampler.z() = z_init;
std::stringstream debug, info, warn, error, fatal;
stan::callbacks::stream_logger logger(debug, info, warn, error, fatal);
stan::mcmc::sample init_sample(z_init.q, 0, 0);
// Transition will expand trajectory until max_depth is hit
stan::mcmc::sample s = sampler.transition(init_sample, logger);
EXPECT_EQ(sampler.get_max_depth(), sampler.depth_);
EXPECT_EQ((2 << (sampler.get_max_depth() - 1)) - 1, sampler.n_leapfrog_);
EXPECT_FALSE(sampler.divergent_);
EXPECT_EQ(21 * init_momentum, s.cont_params()(0));
EXPECT_EQ(0, s.log_prob());
EXPECT_EQ(1, s.accept_stat());
EXPECT_EQ("", debug.str());
EXPECT_EQ("", info.str());
EXPECT_EQ("", warn.str());
EXPECT_EQ("", error.str());
EXPECT_EQ("", fatal.str());
}
TEST(McmcUnitENuts, tree_boundary_test) {
rng_t base_rng(4839294);
stan::mcmc::unit_e_point z_init(3);
z_init.q(0) = 1;
z_init.q(1) = -1;
z_init.q(2) = 1;
z_init.p(0) = -1;
z_init.p(1) = 1;
z_init.p(2) = -1;
std::stringstream output;
stan::interface_callbacks::writer::stream_writer writer(output);
std::stringstream error_stream;
stan::interface_callbacks::writer::stream_writer error_writer(error_stream);
std::fstream empty_stream("", std::fstream::in);
stan::io::dump data_var_context(empty_stream);
typedef gauss3D_model_namespace::gauss3D_model model_t;
model_t model(data_var_context);
// Compute expected tree boundaries
typedef stan::mcmc::unit_e_metric<model_t, rng_t> metric_t;
metric_t metric(model);
stan::mcmc::expl_leapfrog<metric_t> unit_e_integrator;
double epsilon = 0.1;
stan::mcmc::unit_e_point z_test = z_init;
metric.init(z_test, writer, error_writer);
unit_e_integrator.evolve(z_test, metric, epsilon, writer, error_writer);
Eigen::VectorXd p_sharp_forward_1 = metric.dtau_dp(z_test);
unit_e_integrator.evolve(z_test, metric, epsilon, writer, error_writer);
Eigen::VectorXd p_sharp_forward_2 = metric.dtau_dp(z_test);
unit_e_integrator.evolve(z_test, metric, epsilon, writer, error_writer);
unit_e_integrator.evolve(z_test, metric, epsilon, writer, error_writer);
Eigen::VectorXd p_sharp_forward_3 = metric.dtau_dp(z_test);
unit_e_integrator.evolve(z_test, metric, epsilon, writer, error_writer);
unit_e_integrator.evolve(z_test, metric, epsilon, writer, error_writer);
unit_e_integrator.evolve(z_test, metric, epsilon, writer, error_writer);
unit_e_integrator.evolve(z_test, metric, epsilon, writer, error_writer);
Eigen::VectorXd p_sharp_forward_4 = metric.dtau_dp(z_test);
z_test = z_init;
metric.init(z_test, writer, error_writer);
unit_e_integrator.evolve(z_test, metric, -epsilon, writer, error_writer);
Eigen::VectorXd p_sharp_backward_1 = metric.dtau_dp(z_test);
unit_e_integrator.evolve(z_test, metric, -epsilon, writer, error_writer);
Eigen::VectorXd p_sharp_backward_2 = metric.dtau_dp(z_test);
unit_e_integrator.evolve(z_test, metric, -epsilon, writer, error_writer);
unit_e_integrator.evolve(z_test, metric, -epsilon, writer, error_writer);
Eigen::VectorXd p_sharp_backward_3 = metric.dtau_dp(z_test);
unit_e_integrator.evolve(z_test, metric, -epsilon, writer, error_writer);
unit_e_integrator.evolve(z_test, metric, -epsilon, writer, error_writer);
unit_e_integrator.evolve(z_test, metric, -epsilon, writer, error_writer);
unit_e_integrator.evolve(z_test, metric, -epsilon, writer, error_writer);
Eigen::VectorXd p_sharp_backward_4 = metric.dtau_dp(z_test);
// Check expected tree boundaries to those dynamically geneated by NUTS
stan::mcmc::unit_e_nuts<model_t, rng_t> sampler(model, base_rng);
sampler.set_nominal_stepsize(epsilon);
sampler.set_stepsize_jitter(0);
sampler.sample_stepsize();
stan::mcmc::ps_point z_propose = z_init;
Eigen::VectorXd p_sharp_left = Eigen::VectorXd::Zero(z_init.p.size());
Eigen::VectorXd p_sharp_right = Eigen::VectorXd::Zero(z_init.p.size());
Eigen::VectorXd rho = z_init.p;
double log_sum_weight = -std::numeric_limits<double>::infinity();
double H0 = -0.1;
int n_leapfrog = 0;
double sum_metro_prob = 0;
// Depth 0 forward
sampler.z() = z_init;
sampler.init_hamiltonian(writer, error_writer);
sampler.build_tree(0, z_propose,
p_sharp_left, p_sharp_right, rho,
H0, 1, n_leapfrog, log_sum_weight,
sum_metro_prob,
writer, error_writer);
for (int n = 0; n < rho.size(); ++n)
EXPECT_FLOAT_EQ(p_sharp_forward_1(n), p_sharp_left(n));
for (int n = 0; n < rho.size(); ++n)
EXPECT_FLOAT_EQ(p_sharp_forward_1(n), p_sharp_right(n));
// Depth 1 forward
sampler.z() = z_init;
sampler.init_hamiltonian(writer, error_writer);
sampler.build_tree(1, z_propose,
p_sharp_left, p_sharp_right, rho,
H0, 1, n_leapfrog, log_sum_weight,
sum_metro_prob,
writer, error_writer);
for (int n = 0; n < rho.size(); ++n)
EXPECT_FLOAT_EQ(p_sharp_forward_1(n), p_sharp_left(n));
for (int n = 0; n < rho.size(); ++n)
EXPECT_FLOAT_EQ(p_sharp_forward_2(n), p_sharp_right(n));
// Depth 2 forward
sampler.z() = z_init;
sampler.init_hamiltonian(writer, error_writer);
sampler.build_tree(2, z_propose,
p_sharp_left, p_sharp_right, rho,
H0, 1, n_leapfrog, log_sum_weight,
sum_metro_prob,
writer, error_writer);
for (int n = 0; n < rho.size(); ++n)
EXPECT_FLOAT_EQ(p_sharp_forward_1(n), p_sharp_left(n));
for (int n = 0; n < rho.size(); ++n)
EXPECT_FLOAT_EQ(p_sharp_forward_3(n), p_sharp_right(n));
// Depth 3 forward
sampler.z() = z_init;
sampler.init_hamiltonian(writer, error_writer);
sampler.build_tree(3, z_propose,
p_sharp_left, p_sharp_right, rho,
H0, 1, n_leapfrog, log_sum_weight,
sum_metro_prob,
writer, error_writer);
for (int n = 0; n < rho.size(); ++n)
EXPECT_FLOAT_EQ(p_sharp_forward_1(n), p_sharp_left(n));
for (int n = 0; n < rho.size(); ++n)
EXPECT_FLOAT_EQ(p_sharp_forward_4(n), p_sharp_right(n));
// Depth 0 backward
sampler.z() = z_init;
sampler.init_hamiltonian(writer, error_writer);
sampler.build_tree(0, z_propose,
p_sharp_left, p_sharp_right, rho,
H0, -1, n_leapfrog, log_sum_weight,
sum_metro_prob,
writer, error_writer);
for (int n = 0; n < rho.size(); ++n)
EXPECT_FLOAT_EQ(p_sharp_backward_1(n), p_sharp_left(n));
for (int n = 0; n < rho.size(); ++n)
EXPECT_FLOAT_EQ(p_sharp_backward_1(n), p_sharp_right(n));
// Depth 1 backward
sampler.z() = z_init;
sampler.init_hamiltonian(writer, error_writer);
sampler.build_tree(1, z_propose,
p_sharp_left, p_sharp_right, rho,
H0, -1, n_leapfrog, log_sum_weight,
sum_metro_prob,
writer, error_writer);
for (int n = 0; n < rho.size(); ++n)
EXPECT_FLOAT_EQ(p_sharp_backward_1(n), p_sharp_left(n));
for (int n = 0; n < rho.size(); ++n)
EXPECT_FLOAT_EQ(p_sharp_backward_2(n), p_sharp_right(n));
// Depth 2 backward
sampler.z() = z_init;
sampler.init_hamiltonian(writer, error_writer);
sampler.build_tree(2, z_propose,
p_sharp_left, p_sharp_right, rho,
H0, -1, n_leapfrog, log_sum_weight,
sum_metro_prob,
writer, error_writer);
for (int n = 0; n < rho.size(); ++n)
EXPECT_FLOAT_EQ(p_sharp_backward_1(n), p_sharp_left(n));
for (int n = 0; n < rho.size(); ++n)
EXPECT_FLOAT_EQ(p_sharp_backward_3(n), p_sharp_right(n));
// Depth 3 backward
sampler.z() = z_init;
sampler.init_hamiltonian(writer, error_writer);
sampler.build_tree(3, z_propose,
p_sharp_left, p_sharp_right, rho,
H0, -1, n_leapfrog, log_sum_weight,
sum_metro_prob,
writer, error_writer);
for (int n = 0; n < rho.size(); ++n)
EXPECT_FLOAT_EQ(p_sharp_backward_1(n), p_sharp_left(n));
for (int n = 0; n < rho.size(); ++n)
EXPECT_FLOAT_EQ(p_sharp_backward_4(n), p_sharp_right(n));
}
TEST(McmcUnitENuts, build_tree_test) {
rng_t base_rng(4839294);
stan::mcmc::unit_e_point z_init(3);
z_init.q(0) = 1;
z_init.q(1) = -1;
z_init.q(2) = 1;
z_init.p(0) = -1;
z_init.p(1) = 1;
z_init.p(2) = -1;
std::stringstream output;
stan::interface_callbacks::writer::stream_writer writer(output);
std::stringstream error_stream;
stan::interface_callbacks::writer::stream_writer error_writer(error_stream);
std::fstream empty_stream("", std::fstream::in);
stan::io::dump data_var_context(empty_stream);
gauss3D_model_namespace::gauss3D_model model(data_var_context);
stan::mcmc::unit_e_nuts<gauss3D_model_namespace::gauss3D_model, rng_t>
sampler(model, base_rng);
sampler.z() = z_init;
sampler.init_hamiltonian(writer, error_writer);
sampler.set_nominal_stepsize(0.1);
sampler.set_stepsize_jitter(0);
sampler.sample_stepsize();
stan::mcmc::ps_point z_propose = z_init;
Eigen::VectorXd p_sharp_left = Eigen::VectorXd::Zero(z_init.p.size());
Eigen::VectorXd p_sharp_right = Eigen::VectorXd::Zero(z_init.p.size());
Eigen::VectorXd rho = z_init.p;
double log_sum_weight = -std::numeric_limits<double>::infinity();
double H0 = -0.1;
int n_leapfrog = 0;
double sum_metro_prob = 0;
bool valid_subtree = sampler.build_tree(3, z_propose,
p_sharp_left, p_sharp_right, rho,
H0, 1, n_leapfrog, log_sum_weight,
sum_metro_prob,
writer, error_writer);
EXPECT_EQ(0.1, sampler.get_nominal_stepsize());
EXPECT_TRUE(valid_subtree);
EXPECT_FLOAT_EQ(-11.401228, rho(0));
EXPECT_FLOAT_EQ(11.401228, rho(1));
EXPECT_FLOAT_EQ(-11.401228, rho(2));
EXPECT_FLOAT_EQ(-0.022019938, sampler.z().q(0));
EXPECT_FLOAT_EQ(0.022019938, sampler.z().q(1));
EXPECT_FLOAT_EQ(-0.022019938, sampler.z().q(2));
EXPECT_FLOAT_EQ(-1.4131583, sampler.z().p(0));
EXPECT_FLOAT_EQ(1.4131583, sampler.z().p(1));
EXPECT_FLOAT_EQ(-1.4131583, sampler.z().p(2));
EXPECT_EQ(8, n_leapfrog);
EXPECT_FLOAT_EQ(std::log(0.36134657), log_sum_weight);
EXPECT_FLOAT_EQ(0.36134657, sum_metro_prob);
EXPECT_EQ("", output.str());
EXPECT_EQ("", error_stream.str());
}
void op_restart(void)
{
if(automap_unexplore())
return;
z_init(current_zfile);
}
