int
ipmi_sensors_simple_output_setup (ipmi_sensors_state_data_t *state_data)
{
assert (state_data);
if (!state_data->prog_data->args->legacy_output
&& !state_data->prog_data->args->comma_separated_output)
{
if (calculate_column_widths (state_data->pstate,
state_data->sdr_ctx,
state_data->prog_data->args->sensor_types,
state_data->prog_data->args->sensor_types_length,
state_data->prog_data->args->record_ids,
state_data->prog_data->args->record_ids_length,
state_data->prog_data->args->non_abbreviated_units,
state_data->prog_data->args->shared_sensors,
0, /* count_event_only_records */
0, /* count_device_locator_records */
0, /* count_oem_records */
state_data->prog_data->args->entity_sensor_names,
&(state_data->column_width)) < 0)
return (-1);
}
return (0);
}
diag::Writer &
PrintTable::verbose_print(
diag::Writer & dout) const
{
calculate_column_widths();
dout << m_title << diag::dendl;
for (Table::const_iterator row_it = m_header.begin(); row_it != m_header.end(); ++row_it) {
dout << "";
printRow(dout.getStream(), *row_it);
dout << diag::dendl;
}
if (m_header.size() > 0) {
dout << "";
printHeaderBar(dout.getStream());
dout << diag::dendl;
}
for (Table::const_iterator row_it = m_table.begin(); row_it != m_table.end(); ++row_it) {
dout << "";
printRow(dout.getStream(), *row_it);
dout << diag::dendl;
}
return dout;
}
int
ipmi_oem_ibm_get_led (ipmi_oem_state_data_t *state_data)
{
struct ipmi_oem_ibm_get_led_sdr_callback sdr_callback_arg;
struct sensor_column_width column_width;
struct ipmi_oem_data oem_data;
int rv = -1;
assert (state_data);
assert (!state_data->prog_data->args->oem_options_count);
if (sdr_cache_create_and_load (state_data->sdr_ctx,
state_data->pstate,
state_data->ipmi_ctx,
state_data->hostname,
&state_data->prog_data->args->common_args) < 0)
goto cleanup;
if (calculate_column_widths (state_data->pstate,
state_data->sdr_ctx,
NULL,
0,
NULL,
0,
0, /* non_abbreviated_units */
0, /* shared_sensors */
0, /* count_event_only_records */
0, /* count_device_locator_records */
1, /* count_oem_records */
0, /* entity_sensor_names */
&column_width) < 0)
goto cleanup;
if (ipmi_get_oem_data (state_data->pstate,
state_data->ipmi_ctx,
&oem_data) < 0)
goto cleanup;
sdr_callback_arg.state_data = state_data;
sdr_callback_arg.column_width = &column_width;
sdr_callback_arg.oem_data = &oem_data;
sdr_callback_arg.header_output_flag = 0;
if (ipmi_sdr_cache_iterate (state_data->sdr_ctx,
_get_led_sdr_callback,
&sdr_callback_arg) < 0)
{
pstdout_fprintf (state_data->pstate,
stderr,
"ipmi_sdr_cache_iterate: %s\n",
ipmi_sdr_ctx_errormsg (state_data->sdr_ctx));
goto cleanup;
}
rv = 0;
cleanup:
return (rv);
}
diag::Writer &
PrintTable::verbose_print(
diag::Writer & dout) const
{
// const ColumnWidthVector &column_width = calculate_column_widths();
// for (Table::const_iterator row_it = m_header.begin(); row_it != m_header.end(); ++row_it) {
// printRow(os, *row_it);
// os << '\n';
// }
// if (m_header.size() > 0)
// printHeaderBar(os);
// for (Table::const_iterator row_it = m_table.begin(); row_it != m_table.end(); ++row_it) {
// int i = 0;
// for (Row::const_iterator cell_it = (*row_it).begin(); cell_it != (*row_it).end(); ++cell_it, ++i)
// if ((*cell_it).m_flags & Cell::SPAN)
// dout << (*cell_it).m_string;
// else
// dout << std::setw(column_width[i]) << (*cell_it).m_string;
// dout << dendl;
// }
calculate_column_widths();
dout << m_title << std::endl;
for (Table::const_iterator row_it = m_header.begin(); row_it != m_header.end(); ++row_it) {
dout << "";
printRow(dout.getStream(), *row_it);
dout << diag::dendl;
}
if (m_header.size() > 0) {
dout << "";
printHeaderBar(dout.getStream());
dout << diag::dendl;
}
for (Table::const_iterator row_it = m_table.begin(); row_it != m_table.end(); ++row_it) {
dout << "";
printRow(dout.getStream(), *row_it);
dout << diag::dendl;
}
return dout;
}
std::ostream &
PrintTable::print(
std::ostream & os) const
{
if (m_flags & COMMA_SEPARATED_VALUES)
csvPrint(os);
else {
if (m_flags & PRINT_TRANSPOSED)
transpose_table();
calculate_column_widths();
if (!m_title.empty()) {
int prespaces = 0;
if(m_title.length() < m_tableWidth)
prespaces = (m_tableWidth - m_title.length())/2;;
os << m_commentPrefix;
os << std::left << std::setw(prespaces) << "" << m_title << '\n';
}
for (Table::const_iterator row_it = m_header.begin(); row_it != m_header.end(); ++row_it) {
os << m_commentPrefix;
printRow(os, *row_it);
os << '\n';
}
if (m_header.size() > 0) {
os << m_commentPrefix;
printHeaderBar(os);
os << '\n';
}
for (Table::const_iterator row_it = m_table.begin(); row_it != m_table.end(); ++row_it) {
os << std::left << std::setw(m_commentPrefix.size()) << "";
printRow(os, *row_it);
os << '\n';
}
}
return os;
}
/**
* The Stan print function.
*
* @param argc Number of arguments
* @param argv Arguments
*
* @return 0 for success,
* non-zero otherwise
*/
int main(int argc, const char* argv[]) {
if (argc == 1) {
print_usage();
return 0;
}
// Parse any arguments specifying filenames
std::ifstream ifstream;
std::vector<std::string> filenames;
for (int i = 1; i < argc; i++) {
if (std::string(argv[i]).find("--autocorr=") != std::string::npos)
continue;
if (std::string(argv[i]).find("--sig_figs=") != std::string::npos)
continue;
if (std::string("--help") == std::string(argv[i])) {
print_usage();
return 0;
}
ifstream.open(argv[i]);
if (ifstream.good()) {
filenames.push_back(argv[i]);
ifstream.close();
} else {
std::cout << "File " << argv[i] << " not found" << std::endl;
}
}
if (!filenames.size()) {
std::cout << "No valid input files, exiting." << std::endl;
return 0;
}
// Parse specified files
Eigen::VectorXd warmup_times(filenames.size());
Eigen::VectorXd sampling_times(filenames.size());
Eigen::VectorXi thin(filenames.size());
ifstream.open(filenames[0].c_str());
stan::io::stan_csv stan_csv = stan::io::stan_csv_reader::parse(ifstream);
warmup_times(0) = stan_csv.timing.warmup;
sampling_times(0) = stan_csv.timing.sampling;
stan::mcmc::chains<> chains(stan_csv);
ifstream.close();
thin(0) = stan_csv.metadata.thin;
for (std::vector<std::string>::size_type chain = 1;
chain < filenames.size(); chain++) {
ifstream.open(filenames[chain].c_str());
stan_csv = stan::io::stan_csv_reader::parse(ifstream);
chains.add(stan_csv);
ifstream.close();
thin(chain) = stan_csv.metadata.thin;
warmup_times(chain) = stan_csv.timing.warmup;
sampling_times(chain) = stan_csv.timing.sampling;
}
double total_warmup_time = warmup_times.sum();
double total_sampling_time = sampling_times.sum();
// Compute largest variable name length
const int skip = 0;
std::string model_name = stan_csv.metadata.model;
size_t max_name_length = 0;
for (int i = skip; i < chains.num_params(); i++)
if (chains.param_name(i).length() > max_name_length)
max_name_length = chains.param_name(i).length();
for (int i = 0; i < 2; i++)
if (chains.param_name(i).length() > max_name_length)
max_name_length = chains.param_name(i).length();
// Prepare values
int n = 9;
Eigen::MatrixXd values(chains.num_params(), n);
values.setZero();
Eigen::VectorXd probs(3);
probs << 0.05, 0.5, 0.95;
for (int i = 0; i < chains.num_params(); i++) {
double sd = chains.sd(i);
double n_eff = chains.effective_sample_size(i);
values(i,0) = chains.mean(i);
values(i,1) = sd / sqrt(n_eff);
values(i,2) = sd;
Eigen::VectorXd quantiles = chains.quantiles(i,probs);
for (int j = 0; j < 3; j++)
values(i,3+j) = quantiles(j);
values(i,6) = n_eff;
values(i,7) = n_eff / total_sampling_time;
values(i,8) = chains.split_potential_scale_reduction(i);
}
// Prepare header
Eigen::Matrix<std::string, Eigen::Dynamic, 1> headers(n);
headers <<
"Mean", "MCSE", "StdDev",
"5%", "50%", "95%",
"N_Eff", "N_Eff/s", "R_hat";
// Set sig figs
Eigen::VectorXi column_sig_figs(n);
int sig_figs = 2;
for (int k = 1; k < argc; k++)
if (std::string(argv[k]).find("--sig_figs=") != std::string::npos)
sig_figs = atoi(std::string(argv[k]).substr(11).c_str());
// Compute column widths
Eigen::VectorXi column_widths(n);
Eigen::Matrix<std::ios_base::fmtflags, Eigen::Dynamic, 1> formats(n);
column_widths = calculate_column_widths(values, headers, sig_figs, formats);
// Initial output
std::cout << "Inference for Stan model: " << model_name << std::endl
<< chains.num_chains() << " chains: each with iter=(" << chains.num_kept_samples(0);
for (int chain = 1; chain < chains.num_chains(); chain++)
std::cout << "," << chains.num_kept_samples(chain);
std::cout << ")";
// Timing output
std::cout << "; warmup=(" << chains.warmup(0);
for (int chain = 1; chain < chains.num_chains(); chain++)
std::cout << "," << chains.warmup(chain);
std::cout << ")";
std::cout << "; thin=(" << thin(0);
for (int chain = 1; chain < chains.num_chains(); chain++)
std::cout << "," << thin(chain);
std::cout << ")";
std::cout << "; " << chains.num_samples() << " iterations saved."
<< std::endl << std::endl;
std::string warmup_unit = "seconds";
if (total_warmup_time / 3600 > 1) {
total_warmup_time /= 3600;
warmup_unit = "hours";
} else if (total_warmup_time / 60 > 1) {
total_warmup_time /= 60;
warmup_unit = "minutes";
}
std::cout << "Warmup took ("
<< std::fixed
<< std::setprecision(compute_precision(warmup_times(0), sig_figs, false))
<< warmup_times(0);
for (int chain = 1; chain < chains.num_chains(); chain++)
std::cout << ", " << std::fixed
<< std::setprecision(compute_precision(warmup_times(chain), sig_figs, false))
<< warmup_times(chain);
std::cout << ") seconds, ";
std::cout << std::fixed
<< std::setprecision(compute_precision(total_warmup_time, sig_figs, false))
<< total_warmup_time << " " << warmup_unit << " total" << std::endl;
std::string sampling_unit = "seconds";
if (total_sampling_time / 3600 > 1) {
total_sampling_time /= 3600;
sampling_unit = "hours";
} else if (total_sampling_time / 60 > 1) {
total_sampling_time /= 60;
sampling_unit = "minutes";
}
std::cout << "Sampling took ("
<< std::fixed
<< std::setprecision(compute_precision(sampling_times(0), sig_figs, false))
<< sampling_times(0);
for (int chain = 1; chain < chains.num_chains(); chain++)
std::cout << ", " << std::fixed
<< std::setprecision(compute_precision(sampling_times(chain), sig_figs, false))
<< sampling_times(chain);
std::cout << ") seconds, ";
std::cout << std::fixed
<< std::setprecision(compute_precision(total_sampling_time, sig_figs, false))
<< total_sampling_time << " " << sampling_unit << " total" << std::endl;
std::cout << std::endl;
// Header output
std::cout << std::setw(max_name_length + 1) << "";
for (int i = 0; i < n; i++) {
std::cout << std::setw(column_widths(i)) << headers(i);
}
std::cout << std::endl;
// Value output
for (int i = skip; i < chains.num_params(); i++) {
if (!is_matrix(chains.param_name(i))) {
std::cout << std::setw(max_name_length + 1) << std::left << chains.param_name(i);
std::cout << std::right;
for (int j = 0; j < n; j++) {
std::cout.setf(formats(j), std::ios::floatfield);
std::cout << std::setprecision(
compute_precision(values(i,j), sig_figs, formats(j) == std::ios_base::scientific))
<< std::setw(column_widths(j)) << values(i, j);
}
std::cout << std::endl;
} else {
std::vector<int> dims = dimensions(chains, i);
std::vector<int> index(dims.size(), 1);
int max = 1;
for (int j = 0; j < dims.size(); j++)
max *= dims[j];
for (int k = 0; k < max; k++) {
int param_index = i + matrix_index(index, dims);
std::cout << std::setw(max_name_length + 1) << std::left
<< chains.param_name(param_index);
std::cout << std::right;
for (int j = 0; j < n; j++) {
std::cout.setf(formats(j), std::ios::floatfield);
std::cout
<< std::setprecision(compute_precision(values(param_index,j),
sig_figs,
formats(j) == std::ios_base::scientific))
<< std::setw(column_widths(j)) << values(param_index, j);
}
std::cout << std::endl;
next_index(index, dims);
}
i += max-1;
}
}
/// Footer output
std::cout << std::endl;
std::cout << "Samples were drawn using " << stan_csv.metadata.algorithm
<< " with " << stan_csv.metadata.engine << "." << std::endl
<< "For each parameter, N_Eff is a crude measure of effective sample size," << std::endl
<< "and R_hat is the potential scale reduction factor on split chains (at " << std::endl
<< "convergence, R_hat=1)." << std::endl
<< std::endl;
// Print autocorrelation, if desired
for (int k = 1; k < argc; k++) {
if (std::string(argv[k]).find("--autocorr=") != std::string::npos) {
const int c = atoi(std::string(argv[k]).substr(11).c_str());
if (c < 0 || c >= chains.num_chains()) {
std::cout << "Bad chain index " << c << ", aborting autocorrelation display." << std::endl;
break;
}
Eigen::MatrixXd autocorr(chains.num_params(), chains.num_samples(c));
for (int i = 0; i < chains.num_params(); i++) {
autocorr.row(i) = chains.autocorrelation(c, i);
}
// Format and print header
std::cout << "Displaying the autocorrelations for chain " << c << ":" << std::endl;
std::cout << std::endl;
const int n_autocorr = autocorr.row(0).size();
int lag_width = 1;
int number = n_autocorr;
while ( number != 0) { number /= 10; lag_width++; }
std::cout << std::setw(lag_width > 4 ? lag_width : 4) << "Lag";
for (int i = 0; i < chains.num_params(); ++i) {
std::cout << std::setw(max_name_length + 1) << std::right << chains.param_name(i);
}
std::cout << std::endl;
// Print body
for (int n = 0; n < n_autocorr; ++n) {
std::cout << std::setw(lag_width) << std::right << n;
for (int i = 0; i < chains.num_params(); ++i) {
std::cout << std::setw(max_name_length + 1) << std::right << autocorr(i, n);
}
std::cout << std::endl;
}
}
}
return 0;
}
