void edit_based_on_flags(t_mod *data)
{
if (data->precision == 1 && data->procent == 0)
{
if (data->specifier != 's' && data->specifier != 'c')
{
stock_precision(data);
compute_precision(data);
}
else
edit_strings_precision(data);
}
if (data->hash_mod == 1)
case_hash(data);
if (data->width == 1)
stock_width(data);
if (data->zero_mod == 1)
case_zero(data);
if (data->plus_mod == 1)
case_plus(data);
if (data->dot_mod == 1)
case_dot(data);
compute_width(data);
if (data->space_mod == 1 && data->plus_mod == 0)
case_space(data);
edit_wide_flags(data);
edit_wildcard(data);
}
int main(int argc, char* argv[])
{
try {
flann::Matrix<float> query;
flann::Matrix<int> match;
flann::load_from_file(query, "sift100K.h5","query");
flann::load_from_file(match, "sift100K.h5","match");
// flann::load_from_file(gt_dists, "sift100K.h5","dists");
flann::mpi::Client<float, float> index("localhost","9999");
int nn = 1;
flann::Matrix<int> indices(new int[query.rows*nn], query.rows, nn);
flann::Matrix<float> dists(new float[query.rows*nn], query.rows, nn);
start_timer("Performing search...\n");
index.knnSearch(query, indices, dists, nn, flann::SearchParams(64));
printf("Search done (%g seconds)\n", stop_timer());
printf("Checking results\n");
float precision = compute_precision(match, indices);
printf("Precision is: %g\n", precision);
}
catch (std::exception& e) {
std::cerr << "Exception: " << e.what() << "\n";
}
return 0;
}
DESIGN_mrf::DESIGN_mrf(datamatrix & dm,datamatrix & iv,
GENERAL_OPTIONS * o,DISTR * dp,FC_linear * fcl,
const MAP::map & m,vector<ST::string> & op,
vector<ST::string> & vn)
: DESIGN(o,dp,fcl)
{
if (errors==false)
{
read_options(op,vn);
discrete = true;
ma = m;
type = Mrf;
nrpar = ma.get_nrregions();
consecutive=true;
Zout = datamatrix(nrpar,1,1);
index_Zout = statmatrix<int>(Zout.rows(),1);
index_Zout.indexinit();
}
if (errors==false)
init_data(dm,iv);
if (errors==false)
{
compute_penalty();
XWX = envmatdouble(0,nrpar);
XWres = datamatrix(nrpar,1);
Wsum = datamatrix(nrpar,1,1);
compute_precision(1.0);
compute_basisNull();
identity=true;
}
/*
ofstream out("c:\\bayesx\\trunk\\testh\\results\\dm.raw");
dm.prettyPrint(out);
ofstream out2("c:\\bayesx\\trunk\\testh\\results\\iv.raw");
iv.prettyPrint(out2);
*/
}
int main(int argc, char** argv)
{
boost::mpi::environment env(argc, argv);
boost::mpi::communicator world;
int nn = 1;
// flann::Matrix<float> dataset;
flann::Matrix<float> query;
flann::Matrix<int> match;
IF_RANK0 start_timer("Loading data...\n");
flann::load_from_file(query, "sift100K.h5","query");
flann::load_from_file(match, "sift100K.h5","match");
flann::Matrix<int> indices(new int[query.rows*nn], query.rows, nn);
flann::Matrix<float> dists(new float[query.rows*nn], query.rows, nn);
// construct an randomized kd-tree index using 4 kd-trees
flann::mpi::Index<flann::L2<float> > index("sift100K.h5", "dataset", flann::KDTreeIndexParams(4));
IF_RANK0 printf("Loading data done (%g seconds)\n", stop_timer());
IF_RANK0 printf("Index size: (%d,%d)\n", index.size(), index.veclen());
start_timer("Building index...\n");
index.buildIndex();
printf("Building index done (%g seconds)\n", stop_timer());
// do a knn search, using 128 checks
IF_RANK0 start_timer("Performing search...\n");
index.knnSearch(query, indices, dists, nn, flann::SearchParams(128));
IF_RANK0 printf("Search done (%g seconds)\n", stop_timer());
IF_RANK0 {
printf("Indices size: (%d,%d)\n", indices.rows, indices.cols);
printf("Checking results\n");
float precision = compute_precision(match, indices);
printf("Precision is: %g\n", precision);
}
delete[] query.data;
delete[] indices.data;
delete[] dists.data;
delete[] match.data;
return 0;
}
/**
* 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;
}
void print_histogram(FILE *fout, HISTOGRAM *h, int rez, int indent)
{
int numb; /* The number of bins that have data. */
int minb=0; /* The lowest index of a bin with data. */
int maxb=0; /* The highest index of a bin with data. */
register int cm, cs;
int prec = 6; /* the field width used to print the bin size */
int proc = 6; /* the field width used to print the frequency */
int single;
register int ib;
#ifdef DEBUG
printf("h->cnt = %d\n",h->cnt);
printf("h->filled = %d\n",h->filled);
#endif
if (h->cnt == 0)
{ return ;}
#ifdef DEBUG3
{
int is;
for (is = 0; is < MIN((h->cnt),(h->nsample)); is++) {
DataType *data;
fprintf(fout," %d : %d ",is,h->thescore[is]);
if(h->datasize) {
#ifdef USE_CUSTOM_INDEXING
data = (h->indexdata)(h->sample_data,is);
#else
assert(is >= 0 && is < h->nbucket);
data = getData(h->sample_data,h->datasize,is);
#endif
(h->printdata)(fout,data);
}
fprintf(fout,"\n");
}
}
#endif
if (! h->filled)
{ fill(h);}
numb = 0;
for (ib = 0; ib < h->nbucket; ib++) {
int icnt;
icnt = h->bucket_cnt[ib];
if(icnt > 0)
{ if (numb == 0) minb = ib;
numb += 1;
maxb = ib;
#ifdef DEBUG3
fprintf(fout," %d : %d ",ib, icnt);
if(h->datasize) {
DataType *data;
#if 0
data = (h->indexdata)(h->bucket_data,ib);
#else
assert(ib >= 0 && ib < h->nbucket);
data = getData(h->bucket_data,h->datasize,ib);
#endif
(h->printdata)(fout,data);
}
fprintf(fout,"\n");
#endif
}
}
#ifdef DEBUG
h->bucket_width = (h->hgh-h->low-1)/(h->nbucket) + 1;
printf("numb,minb,maxb = %d,%d,%d\n",numb,minb,maxb);
printf("h->sync,h->low,h->bucket_width = %d,%d,%d\n",
h->sync,h->low,h->bucket_width);
#endif
cm = compute_cm(h, rez, numb);
cs = (h->sync - h->low)/h->bucket_width;
// printf("1* cm,cs = %d,%d\n",cm,cs);
if (cs > 0) {
cs = cs%cm - cm;
} else {
cs = - ( (-cs)%cm );
}
// printf("2* cm,cs = %d,%d\n",cm,cs);
cs += ((h->nbucket - cs)/cm+1)*cm;
// printf("3* cm,cs = %d,%d\n",cm,cs);
#ifdef DEBUG
printf("cm,cs = %d,%d\n",cm,cs);
#endif
#ifdef NEVER
prec = compute_precision(h,minb,maxb);
proc = compute_proc(h,cs,cm);
#endif
single = (cm*h->bucket_width == 1);
single = FALSE;
if (single)
{ if (prec >= indent) indent = prec+1; }
else
{ if (2*prec + 3 >= indent) indent = 2*prec+4; }
if(h->datasize) {
assert(cm == 1);
}
for (ib = cs; ib+cm >= 1; ib -= cm) {
int j;
int sum_of_cnt = 0;
int min_score, max_score;
#ifdef NEXT
(h->cleardata)(h->temp_data);
min_score = (h->low) + ib*(h->bucket_width);
max_score = (h->low) + (ib+cm)*(h->bucket_width) - 1;
#endif
min_score = h->bucket_min[ib];
max_score = h->bucket_max[ib];
min_score = MAX(min_score,h->min);
max_score = MIN(max_score,h->max);
for (j = 0; j < cm; j++) {
if( (ib+j >= 0) && (ib+j < h->nbucket) )
{
sum_of_cnt += h->bucket_cnt[ib+j];
min_score = MIN(min_score,h->bucket_min[ib+j]);
max_score = MAX(max_score,h->bucket_max[ib+j]);
if(h->datasize) {
DataType *data;
#ifdef USE_CUSTOM_INDEXING
data = (h->indexdata)(h->bucket_data,ib+j);
#else
assert((ib+j) >= 0 && (ib+j) < h->nbucket);
data = getData(h->bucket_data,h->datasize,ib+j);
#endif
// fprintf(stderr,"* j = %d ib + j = %d data = 0x%x min %d max %d\n", j,ib + j,
// data, min_score, max_score);
if( j == 0 ) {
#ifdef USE_CUSTOM_INDEXING
(h->setdata)(h->temp_data,0,data);
#else
memcpy(h->temp_data, data, h->datasize);
//setData(h->temp_data, h->datasize, 0, data);
#endif
} else {
(h->aggregate)(h->temp_data,0,data);
}
}
}
if(h->datasize) {
if( ib == cs ) {
#ifdef USE_CUSTOM_INDEXING
(h->setdata)(h->scan_data,0,h->temp_data);
#else
memcpy(h->scan_data, h->temp_data, h->datasize);
// setData(h->scan_data, h->datasize, 0, h->temp_data);
#endif
} else {
(h->aggregate)(h->scan_data,0,h->temp_data);
}
}
if (sum_of_cnt > 0)
{
// fprintf(stderr,"* single %d min %d max %d sum_of_cnt = %d\n",
//single, min_score, max_score, sum_of_cnt);
if(single || (min_score == max_score)) {
fprintf(fout, "%*s%*d: %*d ",indent-prec,
"",prec,min_score,proc,sum_of_cnt);
if(h->datasize) {
(h->printdata)(fout,h->temp_data,h->scan_data,h->aggr_data);
}
fprintf(fout,"\n");
} else {
fprintf(fout,"%*s%*d - %*d: %*d ",
indent-2*prec-3,"",
prec,min_score,prec,max_score,proc,sum_of_cnt);
if(h->datasize) {
(h->printdata)(fout,h->temp_data,h->scan_data,h->aggr_data);
}
fprintf(fout,"\n");
}
}
}
}
}
double Real_timer::precision() const {
// computes precision upon first call
// returns -1.0 if timer system call fails.
static double prec = compute_precision();
return prec;
}
