void print_sample_params(RNG& rng, stan::mcmc::sample& sample, stan::mcmc::base_mcmc& sampler, M& model) { if(!_sample_stream) return; std::vector<double> values; sample.get_sample_params(values); sampler.get_sampler_params(values); std::vector<double> model_values; model.write_array(rng, const_cast<std::vector<double>&>(sample.cont_params()), const_cast<std::vector<int>&>(sample.disc_params()), model_values, true, true); // FIXME: add ostream for msgs! values.insert(values.end(), model_values.begin(), model_values.end()); (*_sample_stream) << values.at(0); for (size_t i = 1; i < values.size(); ++i) { (*_sample_stream) << "," << values.at(i); } (*_sample_stream) << std::endl; }
void output_sample_params(RNG& rng, stan::mcmc::sample& s, stan::mcmc::base_mcmc* sampler_ptr, M& model, std::vector<Rcpp::NumericVector>& chains, bool is_warmup, std::vector<Rcpp::NumericVector>& sampler_params, std::vector<Rcpp::NumericVector>& iter_params, std::vector<double>& sum_pars, double& sum_lp, const std::vector<size_t>& qoi_idx, int iter_save_i, std::ostream* pstream) { std::vector<double> values; s.get_sample_params(values); std::vector<double> sampler_values; sampler_ptr -> get_sampler_params(sampler_values); std::vector<double> param_values; model.write_array(rng, const_cast<std::vector<double>&>(s.cont_params()), const_cast<std::vector<int>&>(s.disc_params()), param_values, true, true, pstream); // values in param_values are column-major. size_t z = 0; if (!is_warmup) { for (z = 0; z < param_values.size(); z++) sum_pars[z] += param_values[z]; sum_lp += values.at(index_for_lp_); } for (z = 0; z < sample_names_.size(); z++) { iter_params[z][iter_save_i] = values[z]; } for (z = 0; z < qoi_idx.size() - 1; ++z) { chains[z][iter_save_i] = param_values[qoi_idx[z]]; } chains[z][iter_save_i] = values.at(index_for_lp_); for (z = 0; z < sampler_values.size(); z++) sampler_params[z][iter_save_i] = sampler_values[z]; if (!psample_stream_) return; (*psample_stream_) << values.at(0); for (size_t i = 1; i < values.size(); ++i) { (*psample_stream_) << "," << values[i]; } for (size_t i = 0; i < sampler_values.size(); ++i) (*psample_stream_) << "," << sampler_values[i]; for (size_t i = 0; i < param_values.size(); ++i) (*psample_stream_) << "," << param_values[i]; (*psample_stream_) << std::endl; }
/** * Print diagnostic params to the diagnostic stream. * * @param sample unconstrained sample * @param sampler sampler * * @pre sample and sampler are consistent * @post none. * @sideeffects diagnostic_stream_ is appended with csv values of the * sample's get_sample_params(), the sampler's get_sampler_params(), * and get_sampler_diagnostics() */ void write_diagnostic_params(stan::mcmc::sample& sample, stan::mcmc::base_mcmc* sampler) { std::vector<double> values; sample.get_sample_params(values); sampler->get_sampler_params(values); sampler->get_sampler_diagnostics(values); diagnostic_writer_(values); }
/** * Outputs parameter string names. First outputs the names stored in * the sample object (stan::mcmc::sample), then uses the sampler provided * to output sampler specific names, then adds the model constrained * parameter names. * * The names are written to the sample_stream as comma separated values * with a newline at the end. * * @param sample a sample (unconstrained) that works with the model * @param sampler a stan::mcmc::base_mcmc object * @param model the model * * @pre none * @post none * @sideeffects sample_stream_ is written to with comma separated values * with a newline at the end */ void write_sample_names(stan::mcmc::sample& sample, stan::mcmc::base_mcmc* sampler, M& model) { std::vector<std::string> names; sample.get_sample_param_names(names); sampler->get_sampler_param_names(names); model.constrained_param_names(names, true, true); sample_writer_(names); }
void write_sample_params(RNG& rng, stan::mcmc::sample& sample, stan::mcmc::base_mcmc& sampler, M& model) { std::vector<double> values; sample.get_sample_params(values); sampler.get_sampler_params(values); Eigen::VectorXd model_values; model.write_array(rng, const_cast<Eigen::VectorXd&>(sample.cont_params()), model_values, true, true, msg_stream_); for (int i = 0; i < model_values.size(); ++i) values.push_back(model_values(i)); sample_writer_(values); }
void output_diagnostic_params(stan::mcmc::sample& s, stan::mcmc::base_mcmc* sampler_ptr) { if (!pdiagnostic_stream_) return; std::vector<double> values; s.get_sample_params(values); sampler_ptr -> get_sampler_params(values); sampler_ptr -> get_sampler_diagnostics(values); // FIXME,col/row-major order?? (*pdiagnostic_stream_) << values.at(0); for (size_t i = 1; i < values.size(); ++i) { (*pdiagnostic_stream_) << "," << values.at(i); } (*pdiagnostic_stream_) << std::endl; }
/** * Print diagnostic names * * @param sample unconstrained sample * @param sampler sampler * @param model model * * @pre sample, sampler, and model are consistent. * @post none * @sideeffects diagnostic_stream_ is appended with comma * separated names with newline at the end */ void write_diagnostic_names(stan::mcmc::sample sample, stan::mcmc::base_mcmc* sampler, M& model) { std::vector<std::string> names; sample.get_sample_param_names(names); sampler->get_sampler_param_names(names); std::vector<std::string> model_names; model.unconstrained_param_names(model_names, false, false); sampler->get_sampler_diagnostic_names(model_names, names); diagnostic_writer_(names); }
/* * @param iter_param_names * @param sampler_param_names */ void set_output_names(stan::mcmc::sample& s, stan::mcmc::base_mcmc* sampler_ptr, M& model, std::vector<std::string>& iter_param_names, std::vector<std::string>& sampler_param_names) { sample_names_.clear(); s.get_sample_param_names(sample_names_); index_for_lp_ = find_index(sample_names_, std::string("lp__")); sampler_names_.clear(); sampler_ptr -> get_sampler_param_names(sampler_names_); param_names_.clear(); model.constrained_param_names(param_names_, true, true); iter_param_names = sample_names_; sampler_param_names = sampler_names_; }
void print_diagnostic_params(stan::mcmc::sample& sample, stan::mcmc::base_mcmc* sampler) { if(!_diagnostic_stream) return; std::vector<double> values; sample.get_sample_params(values); sampler->get_sampler_params(values); sampler->get_sampler_diagnostics(values); (*_diagnostic_stream) << values.at(0); for (size_t i = 1; i < values.size(); ++i) { (*_diagnostic_stream) << "," << values.at(i); } (*_diagnostic_stream) << std::endl; }
void output_diagnostic_names(stan::mcmc::sample& s, stan::mcmc::base_mcmc* sampler_ptr, M& model) { if (!pdiagnostic_stream_) return; std::vector<std::string> names; s.get_sample_param_names(names); sampler_ptr -> get_sampler_param_names(names); std::vector<std::string> model_names; model.unconstrained_param_names(model_names, false, false); sampler_ptr -> get_sampler_diagnostic_names(model_names, names); (*pdiagnostic_stream_) << names.at(0); for (size_t i = 1; i < names.size(); ++i) { (*pdiagnostic_stream_) << "," << names.at(i); } (*pdiagnostic_stream_) << std::endl; }
void print_sample_names(stan::mcmc::sample& sample, stan::mcmc::base_mcmc* sampler, M& model) { if(!_sample_stream) return; std::vector<std::string> names; sample.get_sample_param_names(names); sampler->get_sampler_param_names(names); model.constrained_param_names(names, true, true); (*_sample_stream) << names.at(0); for (size_t i = 1; i < names.size(); ++i) { (*_sample_stream) << "," << names.at(i); } (*_sample_stream) << std::endl; }