void fill_in_counts( int order, int radix, int** counts, int* string, int string_len )
{
int i, j, index, max_lookback;
int max_index = matrix_size( order, radix );
for ( i = 0; i < string_len; i++ )
{
max_lookback = min( order, i ) + 1;
for ( j = 0; j < max_lookback; j++ )
{
index = matrix_index( j, radix, string, i );
if ( index == -1 )
{
continue;
}
assert( index >= 0 && index < max_index );
counts[ j ][ index ] += 1;
}
}
}
bool score_string_positions( int order, int radix, real* score_matrix,
int* string, float* target, int start, int length )
{
int i, index;
real score = 0;
int valid_tuples = 0;
int stop = start + length;
for ( i = start + order; i < stop; i++ )
{
index = matrix_index( order, radix, string, i );
// Skip tuples containing invalid symbols
if ( index == -1 )
{
continue;
}
else
{
valid_tuples++;
}
target[i] = score_matrix[ index ];
}
}
//
// find percentage of diference
//
float cellDifference(matrix_t* matrix1, int x1, int y1, int x2, int y2)
{
element_t *one, *two;
float oneAvg, twoAvg;
//get matrix position
one = matrix_index(matrix1, x1, y1);
//find element average
oneAvg = elementAverage(one);
//get matrix position
two = matrix_index(matrix1, x2, y2);
//find element average
twoAvg = elementAverage(two);
//calculate percentage
if (oneAvg != 0)
return abs(oneAvg - twoAvg)/oneAvg * 100;
else
return 100;
}
float MyCost(matrix_t *x, matrix_t *J, matrix_t *H, void *p) {
int i;
float c = 0.0f;
// Weighted sphere function.
for (i = 0; i < x->m; ++i) {
float w = (float)i;
c += w*x->v[i]*x->v[i];
J->v[i] = 2.0f*w*x->v[i];
H->v[matrix_index(H,i,i)] = 2.0f*w;
}
return c;
}
//
// find edges
//
matrix_t* findEdges(matrix_t* matrix1, float allowedDifference)
{
matrix_t* result;
int x,y;
// sanity check parameters
if(!matrix_create(&result, matrix1->rows, matrix1->cols))
{
perror("failed to create result");
return 0;
}
for (y = 0; y < matrix1->rows; ++y)
{
for (x = 0; x < matrix1->cols; ++x)
{
// check parameters
char tooDifferent = 0;
if (y > 0)
tooDifferent |=
cellDifference(matrix1, x, y, x, y - 1) > allowedDifference;
if (y < matrix1->rows)
tooDifferent |=
cellDifference(matrix1, x, y, x, y + 1) > allowedDifference;
if (x > 0)
tooDifferent |=
cellDifference(matrix1, x, y, x - 1, y) > allowedDifference;
if (x < matrix1->cols)
tooDifferent |=
cellDifference(matrix1, x, y, x + 1, y) > allowedDifference;
//get matrix position
element_t* res = matrix_index(result, x, y);
res->red = res->green = res->blue =
tooDifferent ? 1 : 0;
}
}
return result;
}
std::vector<int> dimensions(stan::mcmc::chains<>& chains, const int start_index) {
std::vector<int> dims;
int dim;
std::string name = base_param_name(chains, start_index);
int last_matrix_element = start_index;
while (last_matrix_element+1 < chains.num_params()) {
if (base_param_name(chains, last_matrix_element+1) == name)
last_matrix_element++;
else
break;
}
std::stringstream ss(matrix_index(chains, last_matrix_element));
ss.get();
ss >> dim;
dims.push_back(dim);
while (ss.get() == ',') {
ss >> dim;
dims.push_back(dim);
}
return dims;
}
bool score_string( int order, int radix, real* score_matrix,
int* string, int start, int length, real* rval )
{
int i, index;
real score = 0;
int valid_tuples = 0;
int stop = start + length;
for ( i = start + order; i < stop; i++ )
{
index = matrix_index( order, radix, string, i );
// Skip tuples containing invalid symbols
if ( index == -1 )
{
continue;
}
else
{
valid_tuples++;
}
score += score_matrix[ index ];
}
if ( valid_tuples > 0 )
{
*rval = score / (real) valid_tuples;
return true;
}
else
{
*rval = 0;
return false;
}
}
/**
* 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;
}
//
// program entry point
//
int main(int argc, char *argv[])
{
FILE *input, *output;
matrix_t *matrix1, *result;
element_t *item;
int rows, cols, x, y;
float allowedDifference, *averages;
// open input file for read
input = fopen("in.dat", "r");
if(input == NULL){
perror("failed to open in.dat for read");
return EXIT_FAILURE;
}
// read rows and columns from input file
fscanf(input, "%d %d\n", &rows, &cols);
// create matrix1 from input file
if(!matrix_create(&matrix1, rows, cols)){
perror("failed to create matrix1");
fclose(input);
return EXIT_FAILURE;
}
// create result from input file
if(!matrix_create(&result, rows, cols)){
perror("failed to create result");
fclose(input);
return EXIT_FAILURE;
}
// create array for averages
if((averages = (float *)malloc(sizeof(float) * cols * rows)) == NULL){
perror("failed to create averages array");
fclose(input);
return EXIT_FAILURE;
}
// open output file for write
output = fopen("out.dat", "w");
if(output == NULL){
perror("failed to open out.dat for write");
fclose(input);
return EXIT_FAILURE;
}
for(y = 0; y < rows; y++){
for(x = 0; x < cols; x++){
// get matrix position
item = matrix_index(matrix1, x, y);
// read the elements
fscanf(input, "%d %d %d ",
&item->red, &item->green, &item->blue);
// sanity check parameters
if((item->red < 0 || item->red > 255) || (item->green < 0 || item->green > 255)
|| (item->blue < 0 || item->blue > 255)){
perror("Value must be between 0-255");
matrix_free(&matrix1);
fclose(input);
return EXIT_FAILURE;
}
// average
averages[y * cols + x] = elementAverage(item);
}
}
// print matrix1 to screen
for(y = 0; y < rows; y++){
for(x = 0; x < cols; x++){
item = matrix_index(matrix1, x, y);
printf("matrix1[%d, %d] = { %3d, %3d, %3d }\n", x, y, item->red, item->green, item->blue);
}
}
printf("\n");
// print matrix1 to file
for(y = 0; y < rows; y++){
for(x = 0; x < cols; x++){
item = matrix_index(matrix1, x, y);
fprintf(output, "matrix1[%d, %d] = { %3d, %3d, %3d }\n", x, y, item->red, item->green, item->blue);
}
}
printf("\n");
// print averages to screen
for(y = 0; y < rows; y++){
for(x = 0; x < cols; x++){
printf("averages[%d, %d] = %f\n", x, y, averages[y * cols + x]);
}
}
printf("\n");
// print averages to file
for(y = 0; y < rows; y++){
for(x = 0; x < cols; x++){
fprintf(output, "averages[%d, %d] = %f\n", x, y, averages[y * cols + x]);
}
}
// get percentage
printf("enter allowed difference:\n");
fflush(stdout);
scanf("%f", &allowedDifference);
result = findEdges(matrix1, allowedDifference);
printf("\n");
// print result to screen
for(y = 0; y < rows; y++){
for(x = 0; x < cols; x++){
item = matrix_index(result, x, y);
printf("result[%d, %d] = { %3d, %3d, %3d }\n", x, y, item->red, item->green, item->blue);
}
}
printf("\n");
// print result to file
for(y = 0; y < rows; y++){
for(x = 0; x < cols; x++){
item = matrix_index(result, x, y);
fprintf(output,"result[%d, %d] = { %3d, %3d, %3d }\n", x, y, item->red, item->green, item->blue);
}
}
// free memory allocated to matrices
matrix_free(&matrix1);
matrix_free(&result);
// close previously opened files
fclose(output);
fclose(input);
system("pause");
return EXIT_SUCCESS;
}
