std::unique_ptr<ImageIO::Base> MRtrix::create (Header& H) const
{
File::OFStream out (H.name(), std::ios::out | std::ios::binary);
out << "mrtrix image\n";
write_mrtrix_header (H, out);
bool single_file = Path::has_suffix (H.name(), ".mif");
int64_t offset = 0;
out << "file: ";
if (single_file) {
offset = out.tellp() + int64_t(18);
offset += ((4 - (offset % 4)) % 4);
out << ". " << offset << "\nEND\n";
}
else out << Path::basename (H.name().substr (0, H.name().size()-4) + ".dat") << "\n";
out.close();
std::unique_ptr<ImageIO::Base> io_handler (new ImageIO::Default (H));
if (single_file) {
File::resize (H.name(), offset + footprint(H));
io_handler->files.push_back (File::Entry (H.name(), offset));
}
else {
std::string data_file (H.name().substr (0, H.name().size()-4) + ".dat");
File::create (data_file, footprint(H));
io_handler->files.push_back (File::Entry (data_file));
}
return io_handler;
}
SuffixArray::SuffixArray(const std::string& base_name, bool print) :
ok(false),
data(0), sa(0), original_sa(0), ranks(0), data_size(0),
sequences(0)
{
std::ifstream data_file(base_name.c_str(), std::ios_base::binary);
if(!data_file)
{
std::cerr << "Error: Cannot open data file " << base_name << std::endl;
return;
}
this->data_size = fileSize(data_file);
this->data = new uchar[this->data_size];
data_file.read((char*)(this->data), data_size);
data_file.close();
std::string sa_name = base_name + SA_EXTENSION;
std::ifstream sa_file(sa_name.c_str(), std::ios_base::binary);
if(!sa_file)
{
std::cerr << "Error: Cannot open suffix array file " << sa_name << std::endl;
return;
}
sa_file.read((char*)&(this->sequences), sizeof(uint));
this->sa = new uint[this->data_size];
sa_file.read((char*)(this->sa), this->data_size * sizeof(uint));
sa_file.close();
this->original_sa = this->sa; this->sa += this->sequences;
this->ok = true;
}
static void
cmd_include(void)
{
char *pth, *fnm = NULL;
int fnm_len;
#ifndef NO_DEPRECATED
prefix *root_store;
#endif
int ch_store;
pth = path_from_fnm(file.filename);
read_string(&fnm, &fnm_len);
#ifndef NO_DEPRECATED
/* Since *begin / *end nesting cannot cross file boundaries we only
* need to preserve the prefix if the deprecated *prefix command
* can be used */
root_store = root;
root = pcs->Prefix; /* Root for include file is current prefix */
#endif
ch_store = ch;
data_file(pth, fnm);
#ifndef NO_DEPRECATED
root = root_store; /* and restore root */
#endif
ch = ch_store;
s_free(&fnm);
osfree(pth);
}
bool AmConfigReader::getMD5(const string& path, string& md5hash, bool lowercase) {
std::ifstream data_file(path.c_str(), std::ios::in | std::ios::binary);
if (!data_file) {
DBG("could not read file '%s'\n", path.c_str());
return false;
}
// that one is clever...
// (see http://www.gamedev.net/community/forums/topic.asp?topic_id=353162 )
string file_data((std::istreambuf_iterator<char>(data_file)),
std::istreambuf_iterator<char>());
if (file_data.empty()) {
return false;
}
MD5_CTX md5ctx;
MD5Init(&md5ctx);
MD5Update(&md5ctx, (unsigned char*)file_data.c_str(), file_data.length());
unsigned char _md5hash[16];
MD5Final(_md5hash, &md5ctx);
md5hash = "";
for (size_t i=0;i<16;i++) {
md5hash+=char2hex(_md5hash[i], lowercase);
}
return true;
}
/*
* Hook and mod_cache callback functions
*/
static int create_entity(cache_handle_t *h, request_rec *r, const char *key, apr_off_t len)
{
disk_cache_conf *conf = ap_get_module_config(r->server->module_config,
&disk_cache_module);
cache_object_t *obj;
disk_cache_object_t *dobj;
if (conf->cache_root == NULL) {
return DECLINED;
}
/* Allocate and initialize cache_object_t and disk_cache_object_t */
h->cache_obj = obj = apr_pcalloc(r->pool, sizeof(*obj));
obj->vobj = dobj = apr_pcalloc(r->pool, sizeof(*dobj));
obj->key = apr_pstrdup(r->pool, key);
dobj->name = obj->key;
dobj->prefix = NULL;
/* Save the cache root */
dobj->root = apr_pstrndup(r->pool, conf->cache_root, conf->cache_root_len);
dobj->root_len = conf->cache_root_len;
dobj->datafile = data_file(r->pool, conf, dobj, key);
dobj->hdrsfile = header_file(r->pool, conf, dobj, key);
dobj->tempfile = apr_pstrcat(r->pool, conf->cache_root, AP_TEMPFILE, NULL);
return OK;
}
bool
the_Printing_manager::Load_image_data( std::string& _file_name,
std::string& _image_data_id )
{
std::string prefix = "Data/images/";
std::string suffix = ".data";
Image_data* image_data_ptr = nullptr;
try
{
std::ifstream data_file( prefix + _file_name + suffix );
if( data_file.is_open() && data_file.good())
{
image_data_ptr = this->Parser_image_data( data_file );
auto pair = m_image_data_map.insert( std::make_pair( _image_data_id, image_data_ptr ));
if( ! pair.second )
throw std::invalid_argument( "(xx) Printer ERROR! When LOADING 'Image-Data'. The ID: '"+ _image_data_id +"' is allready in use! " );
data_file.close();
}
else
throw std::ios::failure( "(xx) Printer ERROR! When opening 'Image-Data' file: '"+ prefix + _file_name + suffix +"'! " );
}
catch( const std::exception& e )
{
delete image_data_ptr;
std::cerr <<"PRINTER ERROR :: When parsing the 'Image-Data' file: '"<< prefix << _file_name << suffix <<"'!\n";
std::cerr <<"\t"<< e.what() <<'\n';
return false;
}
return true;
}
void
SuffixArray::writeTo(const std::string& base_name, bool write_data) const
{
if(!this->ok) { return; }
if(write_data)
{
std::ofstream data_file(base_name.c_str(), std::ios_base::binary);
if(!data_file)
{
std::cerr << "Error: Cannot open data file " << base_name << std::endl;
return;
}
data_file.write((char*)(this->data), this->data_size);
data_file.close();
}
std::string sa_name = base_name + SA_EXTENSION;
std::ofstream sa_file(sa_name.c_str(), std::ios_base::binary);
if(!sa_file)
{
std::cerr << "Error: Cannot open suffix array file " << sa_name << std::endl;
return;
}
sa_file.write((char*)&(this->sequences), sizeof(uint));
sa_file.write((char*)(this->original_sa), this->data_size * sizeof(uint));
sa_file.close();
}
int Base::Destroy(const char * _filename) {
ifstream data_file(_filename);
if(data_file.good()) {
if((remove(_filename)) != 0) {
cout << "Destroy(): " << "ERROR: Can't remove " << _filename << endl;
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
if (argc < 3) {
print_usage(argv[0]);
exit(1);
}
if (argc == 4) {
if (strncmp(argv[3], "-verbose", 8) == 0 ||
strncmp(argv[3], "-v", 2) == 0) {
verbose = true;
} else {
print_usage(argv[0]);
exit(1);
}
}
std::fstream data_file(argv[1]);
if (data_file.peek() == std::fstream::traits_type::eof()) {
exit(1);
}
int dimensions;
int number_of_points;
int clusters = atoi(argv[2]);
data_file >> dimensions;
data_file >> number_of_points;
std::vector<DataPoint> points;
for (int n = 0; n < number_of_points; ++n) {
double *attributes = new double[dimensions];
for (int i = 0; i < dimensions; ++i) {
data_file >> attributes[i];
}
DataPoint point;
point.n = dimensions;
point.attr = attributes;
point.distance = std::numeric_limits<double>::infinity();
points.push_back(point);
}
if (verbose) {
std::cout << "Finding " << clusters << " clusters" << std::endl;
std::cout << "Points read: " << points.size() << std::endl;
print_data_points(points);
}
kmeans(points, clusters);
}
int main( int argc, char *argv[] )
{
char *rev_file;
if ( argc > 1 )
rev_file = argv[ 1 ];
else
rev_file = "CHECKREV.DAT";
cout << "Data file: " << rev_file << "\n";
ifstream data_file( rev_file );
if ( data_file.fail() )
cerr << "Error opening data file!\n";
else
check_files( data_file );
return( 0 );
}
// Print the basic model
void createProperties(const bfs::path & example_model_path)
{
Json::Value root;
Json::Value & records = root["records"];
records.resize(2);
// Add time series
records[0]["name"] = "test_ts";
records[0]["ending"] = "open";
records[0]["E_A"] = "";
records[0]["E_B"] = "";
records[0]["select"] = true;
records[0]["recid"] = 0;
records[0]["records"].resize(2);
records[0]["records"][0]["V_B"] = "[0,1)";
records[0]["records"][0]["recid"] = 0;
records[0]["records"][0]["id"] = "A";
records[0]["records"][1]["V_B"] = "(1,2]";
records[0]["records"][1]["recid"] = 1;
records[0]["records"][1]["id"] = "B";
// Add a cycle
records[1]["name"] = "test_cycle";
records[1]["ending"] = "cyclic";
records[1]["E_A"] = "";
records[1]["E_B"] = "";
records[1]["select"] = true;
records[1]["recid"] = 1;
records[1]["records"].resize(3);
records[1]["records"][0]["V_B"] = "[0,1)";
records[1]["records"][0]["recid"] = 0;
records[1]["records"][0]["id"] = "A";
records[1]["records"][1]["V_B"] = "[0,1)";
records[1]["records"][1]["recid"] = 1;
records[1]["records"][1]["id"] = "B";
records[1]["records"][2]["V_B"] = "[1,1]";
records[1]["records"][2]["recid"] = 2;
records[1]["records"][2]["id"] = "C";
Json::StyledWriter writer;
ofstream data_file((example_model_path / DATA_FOLDER / PROPERTIES_FILENAME).string(), ios::out);
string data = writer.write(root);
data_file << data;
}
int main(){
const int DATA_SIZE = 15;
const char *file = "test.dat";
const char *out_f = "total.txt";
int data_array[DATA_SIZE];
std::ifstream data_file(file);
if(data_file.bad()){
std::cerr << "Errore nella lettura del file "<<file<<'\n';
return(8);
}
for(int i = 0; i < DATA_SIZE; ++i){
data_file >> data_array[i];
}
int total = 0;
for(unsigned int i = 0; i <= (sizeof(data_array)/sizeof(data_array[0]));++i){
std::cout << "Riga:" << i << " vale " << data_array[i] << '\n';
total += data_array[i];
}
std::ofstream out_file(out_f, std::ios::out|std::ios::app|std::ios::ate);
if(out_file.bad()){
std::cerr << "Impossibile scrivere sul file " << out_file << '\n';
return (8);
}
out_file << "Il totale è " << total << '\n';
std::cout << "Totale:" << total << '\n';
return (0);
}
std::vector<std::string> AbstractCachedMeshReader<ELEMENT_DIM, SPACE_DIM>::GetRawDataFromFile(
const std::string& rFileName)
{
// Open raw data file
std::vector<std::string> raw_data;
std::ifstream data_file(rFileName.c_str());
// Checks that input file has been opened correctly. If not throws an
// exception that should be caught by the user.
if (!data_file.is_open())
{
EXCEPTION("Could not open data file " + rFileName);
}
// Read each line in turn
std::string raw_line;
getline(data_file, raw_line);
while (data_file)
{
// Remove comments (everything from a hash to the end of the line)
// If there is no hash, then hashLocation = string::npos = -1 = 4294967295 = UINT_MAX
// (so it works with unsigneds but is a little nasty)
long hash_location = raw_line.find('#', 0);
if (hash_location >= 0)
{
raw_line = raw_line.substr(0, hash_location);
}
// Remove blank lines. This is unnecessary, since the tokenizer will
// ignore blank lines anyway.
long not_blank_location = raw_line.find_first_not_of(" \t", 0);
if (not_blank_location >= 0)
{
raw_data.push_back(raw_line);
}
// Move onto next line
getline(data_file, raw_line);
}
data_file.close(); // Closes the data file
return raw_data;
}
void VectorSpaceModel::guardarDiccionario(){
ofstream data_file("dic.dat", std::ios::binary);
const unsigned int maxPalabra=16;
mapaDelDiccionario::iterator externo;
float idf;
unsigned char * buf_ptr = new unsigned char [16];
unsigned char * buf_grabar=buf_ptr;
for (externo=miDiccionario->diccionario.begin(); externo!=miDiccionario->diccionario.end(); externo++){
fill_n(buf_ptr, 16,0);
idf=log10((TipoGuardado)cantDocs / (TipoGuardado)externo->second.size());
//externo->first es una palabra
strncpy((char *) buf_ptr, externo->first.c_str(), maxPalabra);
data_file.write((char *)&idf, 4);
data_file.write((char *) buf_grabar, 16);
}
data_file.close();
delete [] buf_ptr;
}
RefPtr<Handler::Base> MRtrix::create (Header& H) const
{
if (!File::is_tempfile (H.name()))
File::create (H.name());
std::ofstream out (H.name().c_str(), std::ios::out | std::ios::binary);
if (!out)
throw Exception ("error creating file \"" + H.name() + "\":" + strerror (errno));
out << "mrtrix image\n";
write_mrtrix_header (H, out);
bool single_file = Path::has_suffix (H.name(), ".mif");
int64_t offset = 0;
out << "file: ";
if (single_file) {
offset = out.tellp() + int64_t(18);
offset += ((4 - (offset % 4)) % 4);
out << ". " << offset << "\nEND\n";
}
else out << Path::basename (H.name().substr (0, H.name().size()-4) + ".dat") << "\n";
out.close();
RefPtr<Handler::Base> handler (new Handler::Default (H));
if (single_file) {
File::resize (H.name(), offset + Image::footprint(H));
handler->files.push_back (File::Entry (H.name(), offset));
}
else {
std::string data_file (H.name().substr (0, H.name().size()-4) + ".dat");
File::create (data_file, Image::footprint(H));
handler->files.push_back (File::Entry (data_file));
}
return handler;
}
static apr_status_t store_headers(cache_handle_t *h, request_rec *r, cache_info *info)
{
disk_cache_conf *conf = ap_get_module_config(r->server->module_config,
&disk_cache_module);
apr_status_t rv;
apr_size_t amt;
disk_cache_object_t *dobj = (disk_cache_object_t*) h->cache_obj->vobj;
disk_cache_info_t disk_info;
struct iovec iov[2];
/* This is flaky... we need to manage the cache_info differently */
h->cache_obj->info = *info;
if (r->headers_out) {
const char *tmp;
tmp = apr_table_get(r->headers_out, "Vary");
if (tmp) {
apr_array_header_t* varray;
apr_uint32_t format = VARY_FORMAT_VERSION;
/* If we were initially opened as a vary format, rollback
* that internal state for the moment so we can recreate the
* vary format hints in the appropriate directory.
*/
if (dobj->prefix) {
dobj->hdrsfile = dobj->prefix;
dobj->prefix = NULL;
}
mkdir_structure(conf, dobj->hdrsfile, r->pool);
rv = apr_file_mktemp(&dobj->tfd, dobj->tempfile,
APR_CREATE | APR_WRITE | APR_BINARY | APR_EXCL,
r->pool);
if (rv != APR_SUCCESS) {
return rv;
}
amt = sizeof(format);
apr_file_write(dobj->tfd, &format, &amt);
amt = sizeof(info->expire);
apr_file_write(dobj->tfd, &info->expire, &amt);
varray = apr_array_make(r->pool, 6, sizeof(char*));
tokens_to_array(r->pool, tmp, varray);
store_array(dobj->tfd, varray);
apr_file_close(dobj->tfd);
dobj->tfd = NULL;
rv = safe_file_rename(conf, dobj->tempfile, dobj->hdrsfile,
r->pool);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_WARNING, rv, r->server,
"disk_cache: rename tempfile to varyfile failed: %s -> %s",
dobj->tempfile, dobj->hdrsfile);
apr_file_remove(dobj->tempfile, r->pool);
return rv;
}
dobj->tempfile = apr_pstrcat(r->pool, conf->cache_root, AP_TEMPFILE, NULL);
tmp = regen_key(r->pool, r->headers_in, varray, dobj->name);
dobj->prefix = dobj->hdrsfile;
dobj->hashfile = NULL;
dobj->datafile = data_file(r->pool, conf, dobj, tmp);
dobj->hdrsfile = header_file(r->pool, conf, dobj, tmp);
}
}
rv = apr_file_mktemp(&dobj->hfd, dobj->tempfile,
APR_CREATE | APR_WRITE | APR_BINARY |
APR_BUFFERED | APR_EXCL, r->pool);
if (rv != APR_SUCCESS) {
return rv;
}
disk_info.format = DISK_FORMAT_VERSION;
disk_info.date = info->date;
disk_info.expire = info->expire;
disk_info.entity_version = dobj->disk_info.entity_version++;
disk_info.request_time = info->request_time;
disk_info.response_time = info->response_time;
disk_info.status = info->status;
disk_info.name_len = strlen(dobj->name);
iov[0].iov_base = (void*)&disk_info;
iov[0].iov_len = sizeof(disk_cache_info_t);
iov[1].iov_base = (void*)dobj->name;
iov[1].iov_len = disk_info.name_len;
rv = apr_file_writev(dobj->hfd, (const struct iovec *) &iov, 2, &amt);
if (rv != APR_SUCCESS) {
return rv;
}
if (r->headers_out) {
apr_table_t *headers_out;
headers_out = ap_cache_cacheable_hdrs_out(r->pool, r->headers_out,
r->server);
if (!apr_table_get(headers_out, "Content-Type")
&& r->content_type) {
apr_table_setn(headers_out, "Content-Type",
ap_make_content_type(r, r->content_type));
}
headers_out = apr_table_overlay(r->pool, headers_out,
r->err_headers_out);
rv = store_table(dobj->hfd, headers_out);
if (rv != APR_SUCCESS) {
return rv;
}
}
/* Parse the vary header and dump those fields from the headers_in. */
/* FIXME: Make call to the same thing cache_select calls to crack Vary. */
if (r->headers_in) {
apr_table_t *headers_in;
headers_in = ap_cache_cacheable_hdrs_out(r->pool, r->headers_in,
r->server);
rv = store_table(dobj->hfd, headers_in);
if (rv != APR_SUCCESS) {
return rv;
}
}
apr_file_close(dobj->hfd); /* flush and close */
/* Remove old file with the same name. If remove fails, then
* perhaps we need to create the directory tree where we are
* about to write the new headers file.
*/
rv = apr_file_remove(dobj->hdrsfile, r->pool);
if (rv != APR_SUCCESS) {
mkdir_structure(conf, dobj->hdrsfile, r->pool);
}
rv = safe_file_rename(conf, dobj->tempfile, dobj->hdrsfile, r->pool);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_WARNING, rv, r->server,
"disk_cache: rename tempfile to hdrsfile failed: %s -> %s",
dobj->tempfile, dobj->hdrsfile);
apr_file_remove(dobj->tempfile, r->pool);
return rv;
}
dobj->tempfile = apr_pstrcat(r->pool, conf->cache_root, AP_TEMPFILE, NULL);
ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
"disk_cache: Stored headers for URL %s", dobj->name);
return APR_SUCCESS;
}
std::string loadFromFile(const std::string &path) {
std::ifstream data_file(path.c_str());
std::string result((std::istreambuf_iterator<char>(data_file)), std::istreambuf_iterator<char>());
data_file.close();
return result;
}
static int open_entity(cache_handle_t *h, request_rec *r, const char *key)
{
apr_uint32_t format;
apr_size_t len;
const char *nkey;
apr_status_t rc;
static int error_logged = 0;
disk_cache_conf *conf = ap_get_module_config(r->server->module_config,
&disk_cache_module);
apr_finfo_t finfo;
cache_object_t *obj;
cache_info *info;
disk_cache_object_t *dobj;
int flags;
h->cache_obj = NULL;
/* Look up entity keyed to 'url' */
if (conf->cache_root == NULL) {
if (!error_logged) {
error_logged = 1;
ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
"disk_cache: Cannot cache files to disk without a CacheRoot specified.");
}
return DECLINED;
}
/* Create and init the cache object */
h->cache_obj = obj = apr_pcalloc(r->pool, sizeof(cache_object_t));
obj->vobj = dobj = apr_pcalloc(r->pool, sizeof(disk_cache_object_t));
info = &(obj->info);
/* Open the headers file */
dobj->prefix = NULL;
/* Save the cache root */
dobj->root = apr_pstrndup(r->pool, conf->cache_root, conf->cache_root_len);
dobj->root_len = conf->cache_root_len;
dobj->hdrsfile = header_file(r->pool, conf, dobj, key);
flags = APR_READ|APR_BINARY|APR_BUFFERED;
rc = apr_file_open(&dobj->hfd, dobj->hdrsfile, flags, 0, r->pool);
if (rc != APR_SUCCESS) {
return DECLINED;
}
/* read the format from the cache file */
len = sizeof(format);
apr_file_read_full(dobj->hfd, &format, len, &len);
if (format == VARY_FORMAT_VERSION) {
apr_array_header_t* varray;
apr_time_t expire;
len = sizeof(expire);
apr_file_read_full(dobj->hfd, &expire, len, &len);
varray = apr_array_make(r->pool, 5, sizeof(char*));
rc = read_array(r, varray, dobj->hfd);
if (rc != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ERR, rc, r->server,
"disk_cache: Cannot parse vary header file: %s",
dobj->hdrsfile);
return DECLINED;
}
apr_file_close(dobj->hfd);
nkey = regen_key(r->pool, r->headers_in, varray, key);
dobj->hashfile = NULL;
dobj->prefix = dobj->hdrsfile;
dobj->hdrsfile = header_file(r->pool, conf, dobj, nkey);
flags = APR_READ|APR_BINARY|APR_BUFFERED;
rc = apr_file_open(&dobj->hfd, dobj->hdrsfile, flags, 0, r->pool);
if (rc != APR_SUCCESS) {
return DECLINED;
}
}
else if (format != DISK_FORMAT_VERSION) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
"cache_disk: File '%s' has a version mismatch. File had version: %d.",
dobj->hdrsfile, format);
return DECLINED;
}
else {
apr_off_t offset = 0;
/* This wasn't a Vary Format file, so we must seek to the
* start of the file again, so that later reads work.
*/
apr_file_seek(dobj->hfd, APR_SET, &offset);
nkey = key;
}
obj->key = nkey;
dobj->key = nkey;
dobj->name = key;
dobj->datafile = data_file(r->pool, conf, dobj, nkey);
dobj->tempfile = apr_pstrcat(r->pool, conf->cache_root, AP_TEMPFILE, NULL);
/* Open the data file */
flags = APR_READ|APR_BINARY;
#ifdef APR_SENDFILE_ENABLED
flags |= APR_SENDFILE_ENABLED;
#endif
rc = apr_file_open(&dobj->fd, dobj->datafile, flags, 0, r->pool);
if (rc != APR_SUCCESS) {
/* XXX: Log message */
return DECLINED;
}
rc = apr_file_info_get(&finfo, APR_FINFO_SIZE, dobj->fd);
if (rc == APR_SUCCESS) {
dobj->file_size = finfo.size;
}
/* Read the bytes to setup the cache_info fields */
rc = file_cache_recall_mydata(dobj->hfd, info, dobj, r);
if (rc != APR_SUCCESS) {
/* XXX log message */
return DECLINED;
}
/* Initialize the cache_handle callback functions */
ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
"disk_cache: Recalled cached URL info header %s", dobj->name);
return OK;
}
void input_manager::load(const std::string &file_name, bool is_user_preferences)
{
std::ifstream data_file(file_name.c_str(), std::ifstream::in | std::ifstream::binary);
if(!data_file.good()) {
// Only throw if this is the first file to load, that file _must_ exist,
// otherwise the keybindings can not be read at all.
if (action_contexts.empty()) {
throw "Could not read " + file_name;
}
return;
}
JsonIn jsin(data_file);
//Crawl through once and create an entry for every definition
jsin.start_array();
while (!jsin.end_array()) {
// JSON object representing the action
JsonObject action = jsin.get_object();
const std::string action_id = action.get_string("id");
const std::string context = action.get_string("category", default_context_id);
t_actions &actions = action_contexts[context];
if (!is_user_preferences && action.has_member("name")) {
// Action names are not user preferences. Some experimental builds
// post-0.A had written action names into the user preferences
// config file. Any names that exist in user preferences will be
// ignored.
actions[action_id].name = action.get_string("name");
}
// Iterate over the bindings JSON array
JsonArray bindings = action.get_array("bindings");
t_input_event_list events;
while (bindings.has_more()) {
JsonObject keybinding = bindings.next_object();
std::string input_method = keybinding.get_string("input_method");
input_event new_event;
if(input_method == "keyboard") {
new_event.type = CATA_INPUT_KEYBOARD;
} else if(input_method == "gamepad") {
new_event.type = CATA_INPUT_GAMEPAD;
} else if(input_method == "mouse") {
new_event.type = CATA_INPUT_MOUSE;
}
if (keybinding.has_array("key")) {
JsonArray keys = keybinding.get_array("key");
while (keys.has_more()) {
new_event.sequence.push_back(
get_keycode(keys.next_string())
);
}
} else { // assume string if not array, and throw if not string
new_event.sequence.push_back(
get_keycode(keybinding.get_string("key"))
);
}
events.push_back(new_event);
}
// An invariant of this class is that user-created, local keybindings
// with an empty set of input_events do not exist in the
// action_contexts map. In prior versions of this class, this was not
// true, so users of experimental builds post-0.A will have empty
// local keybindings saved in their keybindings.json config.
//
// To be backwards compatible with keybindings.json from prior
// experimental builds, we will detect user-created, local keybindings
// with empty input_events and disregard them. When keybindings are
// later saved, these remnants won't be saved.
if (!is_user_preferences ||
!events.empty() ||
context == default_context_id ||
actions.count(action_id) > 0) {
// In case this is the second file containing user preferences,
// this replaces the default bindings with the user's preferences.
action_attributes &attributes = actions[action_id];
attributes.input_events = events;
if (action.has_member("is_user_created")) {
attributes.is_user_created = action.get_bool("is_user_created");
}
}
}
}
extern CDECL int
main(int argc, char **argv)
{
int d;
time_t tmUserStart = time(NULL);
clock_t tmCPUStart = clock();
{
/* FIXME: localtime? */
struct tm * t = localtime(&tmUserStart);
int y = t->tm_year + 1900;
current_days_since_1900 = days_since_1900(y, t->tm_mon + 1, t->tm_mday);
}
/* Always buffer by line for aven's benefit. */
setvbuf(stdout, NULL, _IOLBF, 0);
msg_init(argv);
#if OS_WIN32 || OS_UNIX_MACOSX
pj_set_finder(msg_proj_finder);
#endif
pcs = osnew(settings);
pcs->next = NULL;
pcs->Translate = ((short*) osmalloc(ossizeof(short) * 257)) + 1;
pcs->meta = NULL;
pcs->proj = NULL;
pcs->declination = HUGE_REAL;
pcs->convergence = 0.0;
/* Set up root of prefix hierarchy */
root = osnew(prefix);
root->up = root->right = root->down = NULL;
root->stn = NULL;
root->pos = NULL;
root->ident = NULL;
root->min_export = root->max_export = 0;
root->sflags = BIT(SFLAGS_SURVEY);
root->filename = NULL;
nosurveyhead = NULL;
stnlist = NULL;
cLegs = cStns = cComponents = 0;
totadj = total = totplan = totvert = 0.0;
for (d = 0; d <= 2; d++) {
min[d] = HUGE_REAL;
max[d] = -HUGE_REAL;
pfxHi[d] = pfxLo[d] = NULL;
}
/* at least one argument must be given */
cmdline_init(argc, argv, short_opts, long_opts, NULL, help, 1, -1);
while (1) {
int opt = cmdline_getopt();
if (opt == EOF) break;
switch (opt) {
case 'p':
/* Ignore for compatibility with older versions. */
break;
case 'o': {
osfree(fnm_output_base); /* in case of multiple -o options */
/* can be a directory (in which case use basename of leaf input)
* or a file (in which case just trim the extension off) */
if (fDirectory(optarg)) {
/* this is a little tricky - we need to note the path here,
* and then add the leaf later on (in datain.c) */
fnm_output_base = base_from_fnm(optarg);
fnm_output_base_is_dir = 1;
} else {
fnm_output_base = base_from_fnm(optarg);
}
break;
}
case 'q':
if (fQuiet) fMute = 1;
fQuiet = 1;
break;
case 's':
fSuppress = 1;
break;
case 'v': {
int v = atoi(optarg);
if (v < IMG_VERSION_MIN || v > IMG_VERSION_MAX)
fatalerror(/*3d file format versions %d to %d supported*/88,
IMG_VERSION_MIN, IMG_VERSION_MAX);
img_output_version = v;
break;
}
case 'w':
f_warnings_are_errors = 1;
break;
case 'z': {
/* Control which network optimisations are used (development tool) */
static int first_opt_z = 1;
char c;
if (first_opt_z) {
optimize = 0;
first_opt_z = 0;
}
/* Lollipops, Parallel legs, Iterate mx, Delta* */
while ((c = *optarg++) != '\0')
if (islower((unsigned char)c)) optimize |= BITA(c);
break;
case 1:
fLog = fTrue;
break;
#if OS_WIN32
case 2:
atexit(pause_on_exit);
break;
#endif
}
}
}
if (fLog) {
char *fnm;
if (!fnm_output_base) {
char *p;
p = baseleaf_from_fnm(argv[optind]);
fnm = add_ext(p, EXT_LOG);
osfree(p);
} else if (fnm_output_base_is_dir) {
char *p;
fnm = baseleaf_from_fnm(argv[optind]);
p = use_path(fnm_output_base, fnm);
osfree(fnm);
fnm = add_ext(p, EXT_LOG);
osfree(p);
} else {
fnm = add_ext(fnm_output_base, EXT_LOG);
}
if (!freopen(fnm, "w", stdout))
fatalerror(/*Failed to open output file “%s”*/47, fnm);
osfree(fnm);
}
if (!fMute) {
const char *p = COPYRIGHT_MSG;
puts(PRETTYPACKAGE" "VERSION);
while (1) {
const char *q = p;
p = strstr(p, "(C)");
if (p == NULL) {
puts(q);
break;
}
fwrite(q, 1, p - q, stdout);
fputs(msg(/*©*/0), stdout);
p += 3;
}
}
atexit(delete_output_on_error);
/* end of options, now process data files */
while (argv[optind]) {
const char *fnm = argv[optind];
if (!fExplicitTitle) {
char *lf;
lf = baseleaf_from_fnm(fnm);
if (survey_title) s_catchar(&survey_title, &survey_title_len, ' ');
s_cat(&survey_title, &survey_title_len, lf);
osfree(lf);
}
/* Select defaults settings */
default_all(pcs);
data_file(NULL, fnm); /* first argument is current path */
optind++;
}
validate();
solve_network(/*stnlist*/); /* Find coordinates of all points */
validate();
/* close .3d file */
if (!img_close(pimg)) {
char *fnm = add_ext(fnm_output_base, EXT_SVX_3D);
fatalerror(img_error2msg(img_error()), fnm);
}
if (fhErrStat) safe_fclose(fhErrStat);
out_current_action(msg(/*Calculating statistics*/120));
if (!fMute) do_stats();
if (!fQuiet) {
/* clock() typically wraps after 72 minutes, but there doesn't seem
* to be a better way. Still 72 minutes means some cave!
* We detect if clock() could have wrapped and suppress CPU time
* printing in this case.
*/
double tmUser = difftime(time(NULL), tmUserStart);
double tmCPU;
clock_t now = clock();
#define CLOCK_T_WRAP \
(sizeof(clock_t)<sizeof(long)?(1ul << (CHAR_BIT * sizeof(clock_t))):0)
tmCPU = (now - (unsigned long)tmCPUStart)
/ (double)CLOCKS_PER_SEC;
if (now < tmCPUStart)
tmCPU += CLOCK_T_WRAP / (double)CLOCKS_PER_SEC;
if (tmUser >= tmCPU + CLOCK_T_WRAP / (double)CLOCKS_PER_SEC)
tmCPU = 0;
/* tmUser is integer, tmCPU not - equivalent to (ceil(tmCPU) >= tmUser) */
if (tmCPU + 1 > tmUser) {
printf(msg(/*CPU time used %5.2fs*/140), tmCPU);
} else if (tmCPU == 0) {
if (tmUser != 0.0) {
printf(msg(/*Time used %5.2fs*/141), tmUser);
} else {
fputs(msg(/*Time used unavailable*/142), stdout);
}
} else {
printf(msg(/*Time used %5.2fs (%5.2fs CPU time)*/143), tmUser, tmCPU);
}
putnl();
}
if (msg_warnings || msg_errors) {
if (msg_errors || (f_warnings_are_errors && msg_warnings)) {
printf(msg(/*There were %d warning(s) and %d error(s) - no output files produced.*/113),
msg_warnings, msg_errors);
putnl();
return EXIT_FAILURE;
}
printf(msg(/*There were %d warning(s).*/16), msg_warnings);
putnl();
}
return EXIT_SUCCESS;
}
int main(int argc, char* argv[]) {
std::ios_base::sync_with_stdio(false);
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
while (true) {
int c = getopt_long(argc, argv, "h", long_options, 0);
if (c == -1) {
break;
}
switch (c) {
case 'h':
print_help();
exit(0);
default:
exit(2);
}
}
int remaining_args = argc - optind;
if (remaining_args != 2) {
std::cerr << "Usage: " << argv[0] << " OSMFILE DIR\n";
exit(2);
}
std::string dir(argv[optind+1]);
int result = ::mkdir(dir.c_str(), 0777);
if (result == -1 && errno != EEXIST) {
std::cerr << "Problem creating directory '" << dir << "': " << strerror(errno) << "\n";
exit(2);
}
std::string data_file(dir + "/data.osm.ser");
int data_fd = ::open(data_file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
if (data_fd < 0) {
std::cerr << "Can't open data file '" << data_file << "': " << strerror(errno) << "\n";
exit(2);
}
offset_index_type node_index;
offset_index_type way_index;
offset_index_type relation_index;
osmium::handler::DiskStore disk_store_handler(data_fd, node_index, way_index, relation_index);
map_type map_node2way;
map_type map_node2relation;
map_type map_way2relation;
map_type map_relation2relation;
osmium::handler::ObjectRelations object_relations_handler(map_node2way, map_node2relation, map_way2relation, map_relation2relation);
osmium::io::Reader reader(argv[1]);
osmium::io::Header header = reader.open();
while (osmium::memory::Buffer buffer = reader.read()) {
disk_store_handler(buffer);
object_relations_handler(buffer);
}
{
std::string index_file(dir + "/nodes.idx");
int fd = ::open(index_file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
if (fd < 0) {
std::cerr << "Can't open nodes index file '" << index_file << "': " << strerror(errno) << "\n";
exit(2);
}
node_index.dump_as_list(fd);
close(fd);
}
{
std::string index_file(dir + "/ways.idx");
int fd = ::open(index_file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
if (fd < 0) {
std::cerr << "Can't open ways index file '" << index_file << "': " << strerror(errno) << "\n";
exit(2);
}
way_index.dump_as_list(fd);
close(fd);
}
{
std::string index_file(dir + "/relations.idx");
int fd = ::open(index_file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
if (fd < 0) {
std::cerr << "Can't open relations index file '" << index_file << "': " << strerror(errno) << "\n";
exit(2);
}
relation_index.dump_as_list(fd);
close(fd);
}
{
map_node2way.sort();
std::string index_file(dir + "/node2way.map");
int fd = ::open(index_file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
if (fd < 0) {
std::cerr << "Can't open node->way map file '" << index_file << "': " << strerror(errno) << "\n";
exit(2);
}
map_node2way.dump_as_list(fd);
close(fd);
}
{
map_node2relation.sort();
std::string index_file(dir + "/node2rel.map");
int fd = ::open(index_file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
if (fd < 0) {
std::cerr << "Can't open node->rel map file '" << index_file << "': " << strerror(errno) << "\n";
exit(2);
}
map_node2relation.dump_as_list(fd);
close(fd);
}
{
map_way2relation.sort();
std::string index_file(dir + "/way2rel.map");
int fd = ::open(index_file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
if (fd < 0) {
std::cerr << "Can't open way->rel map file '" << index_file << "': " << strerror(errno) << "\n";
exit(2);
}
map_way2relation.dump_as_list(fd);
close(fd);
}
{
map_relation2relation.sort();
std::string index_file(dir + "/rel2rel.map");
int fd = ::open(index_file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
if (fd < 0) {
std::cerr << "Can't open rel->rel map file '" << index_file << "': " << strerror(errno) << "\n";
exit(2);
}
map_relation2relation.dump_as_list(fd);
close(fd);
}
google::protobuf::ShutdownProtobufLibrary();
}
void IOPolly::obsFromTextFile (std::string filePath, int angle_unit_type)
{
// The input file
std::ifstream data_file (filePath.c_str());
// testa a abertura do ficheiro
if (!data_file.is_open())
{
std::cerr << "Error: Could not open " << filePath << "\n";
exit (8); //faz parte da cstdlib
}
std::string current_line; // alberga cada linha do ficheiro
double horizontal_dir, vertical_dir; // alberga os valores angulares convertidos para rad
SIUnits *ang_conv = new SIUnits(); // responsavel pelas conversoes
while(!data_file.eof())
{
std::getline(data_file, current_line); // recolhe a linha
if (!current_line.empty()) // se n leu uma linha em branco
{
std::vector<std::string> elements; // linha nos seus elementos
// faz o split ah string para elements
std::istringstream iss(current_line);
std::copy(std::istream_iterator<std::string>(iss),
std::istream_iterator<std::string>(),
std::back_inserter<std::vector<std::string> >(elements));
if(elements.size() == 2)
{
//cria uma estacao
addStation(TCStations->getEnzPoint(elements[0]),
std::atof(elements[1].c_str()));
}
else if(elements.size() == 5)
{
//cria um reading
switch(angle_unit_type) // conversao dos angulos
{
case 1:
horizontal_dir = std::atof(elements[1].c_str());
vertical_dir = std::atof(elements[2].c_str());
break;
case 2:
horizontal_dir = ang_conv->degree2rad (std::atof(elements[1].c_str()));
vertical_dir = ang_conv->degree2rad (std::atof(elements[2].c_str()));
break;
case 3:
horizontal_dir = ang_conv->gon2rad (std::atof(elements[1].c_str()));
vertical_dir = ang_conv->gon2rad (std::atof(elements[2].c_str()));
break;
}
addReading((*(--(obs->end()))).from,
TCStations->getEnzPoint(elements[0]), horizontal_dir,
vertical_dir, std::atof(elements[3].c_str()),
std::atof(elements[4].c_str()));
}
}
}
delete ang_conv;
data_file.close();
}
//
// generate
//
int CUTS_Dmac_File_Vertical_Generator::
generate (ACE_CString & db_file, int round)
{
ifstream data_file (db_file.c_str ());
this->row_count_ = 0;
if (data_file.is_open())
{
CUTS_DMAC_UTILS::sequence_details word_index;
vertical_list_t vertical_list;
std::set <std::string> word_list;
std::set <std::string>::iterator it1;
std::string delim (this->delims_.c_str ());
int count = 1;
// Read line by line and tokenize
while (data_file.good ())
{
std::string row;
getline (data_file, row);
CUTS_Dmac_Vertical_Format * format =
new CUTS_Dmac_Vertical_Format ();
this->tokenize (row, word_list, delim, format);
format->tid (count);
vertical_list.push_back (format);
count++;
}
this->row_count_ = count - 1;
int number = 1;
// print the vertical list to the file
for (it1 = word_list.begin (); it1 != word_list.end (); it1++)
{
word_index.insert (std::pair <std::string, int> (*it1, number));
number++;
}
std::stringstream output_file;
std::ofstream output;
output_file << round << ".data";
output.open (output_file.str ().c_str ());
v_iter it2;
for (it2 = vertical_list.begin (); it2 != vertical_list.end (); it2++)
{
((CUTS_Dmac_Vertical_Format *)(*it2))->populate (word_index);
((CUTS_Dmac_Vertical_Format *)(*it2))->print_row_words (output);
}
output.close ();
data_file.close ();
return 1;
}
else
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%T (%t) - %M - failed to open %s\n"),
db_file.c_str ()),
-1);
}
}
int main(int argc, char *argv[]) {
namespace po=boost::program_options;
po::options_description desc("Well-mixed SIR with demographics.");
int64_t individual_cnt=100000;
int64_t infected_cnt=individual_cnt*0.1;
int64_t recovered_cnt=individual_cnt*0.8;
int run_cnt=1;
size_t rand_seed=1;
// Time is in years.
std::vector<Parameter> parameters;
parameters.emplace_back(Parameter{SIRParam::Beta0, "beta0", 400,
"main infection rate"});
parameters.emplace_back(Parameter{SIRParam::Beta1, "beta1", 0.6,
"seasonality ratio"});
parameters.emplace_back(Parameter{SIRParam::SeasonalPhase, "phase", 0,
"seasonality phase start between (0,1]"});
parameters.emplace_back(Parameter{SIRParam::Gamma, "gamma", 365/14.0,
"recovery rate"});
parameters.emplace_back(Parameter{SIRParam::Birth, "birth", 1/70.0,
"crude rate, before multiplying by number of individuals"});
parameters.emplace_back(Parameter{SIRParam::Mu, "mu", 1/70.0,
"death rate"});
double end_time=30.0;
bool exacttraj=true;
bool exactinfect=false;
int thread_cnt=1;
std::string log_level;
std::string data_file("sirexp.h5");
bool save_file=false;
std::string translation_file;
bool test=false;
desc.add_options()
("help", "show help message")
("threadcnt,j",
po::value<int>(&thread_cnt)->default_value(thread_cnt),
"number of threads")
("runcnt",
po::value<int>(&run_cnt)->default_value(run_cnt),
"number of runs")
("size,s",
po::value<int64_t>(&individual_cnt)->default_value(individual_cnt),
"size of the population")
("infected,i",
po::value<int64_t>(&infected_cnt),
"number of infected")
("recovered,r",
po::value<int64_t>(&recovered_cnt),
"number of recovered")
("seed",
po::value<size_t>(&rand_seed)->default_value(rand_seed),
"seed for random number generator")
("endtime",
po::value<double>(&end_time)->default_value(end_time),
"how many years to run")
("exacttraj",
po::value<bool>(&exacttraj)->default_value(exacttraj),
"save trajectory only when it changes by a certain amount")
("exactinfect",
po::value<bool>(&exactinfect)->default_value(exactinfect),
"set true to use exact distribution for seasonal infection")
("datafile",
po::value<std::string>(&data_file)->default_value(data_file),
"Write to this data file.")
("save",
po::value<bool>(&save_file)->default_value(save_file),
"Add data to file instead of erasing it with new data.")
("loglevel", po::value<std::string>(&log_level)->default_value("info"),
"Set the logging level to trace, debug, info, warning, error, or fatal.")
("translate",
po::value<std::string>(&translation_file)->default_value(""),
"write file relating place ids to internal ids")
("info", "show provenance of program")
;
for (auto& p : parameters) {
desc.add_options()(p.name.c_str(),
po::value<double>(&p.value)->default_value(p.value),
p.description.c_str());
}
po::variables_map vm;
auto parsed_options=po::parse_command_line(argc, argv, desc);
po::store(parsed_options, vm);
po::notify(vm);
if (vm.count("help")) {
std::cout << desc << std::endl;
return 0;
}
std::map<std::string,std::string> compile_info {
{"VERSION", VERSION}, {"COMPILETIME", COMPILETIME},
{"CONFIG", CFG}
};
if (vm.count("info")) {
for (auto& kv : compile_info) {
std::cout << kv.second << "\n\n";
}
return 0;
}
afidd::LogInit(log_level);
if (test) {
double tolerance=TestSeasonal(0.6);
std::cout << "Seasonal tolerance " << tolerance << std::endl;
}
std::map<SIRParam,double*> params;
for (auto& pm : parameters) {
params[pm.kind]=&pm.value;
}
// Birthrate is not frequency-dependent. It scales differently
// which creates a fixed point in the phase plane.
(*params[SIRParam::Birth])*=individual_cnt;
if (std::abs(*params[SIRParam::Beta1])>1) {
std::cout << "beta1 should be fractional, between 0 and 1: beta1=" <<
*params[SIRParam::Beta1] << std::endl;
return -4;
}
if (vm.count("infected") and !vm.count("recovered") ||
!vm.count("infected") and vm.count("recovered")) {
std::cout << "You have so set the total and I and R, not just some of them."
<< std::endl;
return -3;
} else if (!vm.count("infected") && !vm.count("recovered")) {
double b=*params[SIRParam::Beta0];
double m=*params[SIRParam::Mu];
double g=*params[SIRParam::Gamma];
double B=*params[SIRParam::Birth];
// Long-time averages for fixed forcing for ODE model.
int64_t susceptible_start=std::floor((m+g)*individual_cnt/b);
infected_cnt=std::floor(individual_cnt*(b-m-g)*m/(b*(m+g)));
recovered_cnt=individual_cnt-(susceptible_start+infected_cnt);
}
int64_t susceptible_cnt=individual_cnt-(infected_cnt+recovered_cnt);
assert(susceptible_cnt>0);
if (susceptible_cnt<0) {
BOOST_LOG_TRIVIAL(error)<<"Number of susceptibles is "<<susceptible_cnt;
return -2;
}
std::vector<int64_t> sir_init{susceptible_cnt, infected_cnt, recovered_cnt};
BOOST_LOG_TRIVIAL(info)<<"Starting with sir="<<sir_init[0]<<" "<<sir_init[1]
<<" "<<sir_init[2];
for (auto& showp : parameters) {
BOOST_LOG_TRIVIAL(info)<<showp.name<<" "<<showp.value;
}
HDFFile file(data_file);
if (!file.Open(!save_file)) {
BOOST_LOG_TRIVIAL(error)<<"could not open output file: "<<data_file;
return -1;
}
file.WriteExecutableData(compile_info, parsed_options, sir_init);
auto runnable=[=](RandGen& rng, size_t single_seed, size_t idx)->void {
std::shared_ptr<TrajectoryObserver> observer=0;
if (exacttraj) {
observer=std::make_shared<TrajectorySave>();
} else {
observer=std::make_shared<PercentTrajectorySave>();
}
SIR_run(end_time, sir_init, parameters, *observer, rng, exactinfect);
file.SaveTrajectory(parameters, single_seed, idx, observer->Trajectory());
};
Ensemble<decltype(runnable)> ensemble(runnable, thread_cnt, run_cnt,
rand_seed);
ensemble.Run();
BOOST_LOG_TRIVIAL(debug)<<"Finished running ensemble.";
file.Close();
return 0;
}
int main(const int argc, const char* const argv[]) {
if (argc != 4) {
std::cerr << err << "Exactly three arguments are needed, the data-file,\n"
" the instance-directory, and the number of files.\n";
return errcode_parameter;
}
const std::string data_filename = argv[1];
std::ifstream data_file(data_filename.c_str());
if (not data_file) {
std::cerr << err << "Could not open data-file \"" << data_filename << "\".\n";
return errcode_data;
}
const std::string dirname = argv[2];
const std::string decisions_filename = dirname + "/decisions";
std::ifstream decisions_file(decisions_filename.c_str());
if (not decisions_file) {
std::cerr << err << "Could not open decisions-file \"" << decisions_filename << "\".\n";
return errcode_decisions_file;
}
count_type N;
{std::stringstream read_number;
read_number << argv[3];
read_number >> N;
if (not read_number) {
std::cerr << err << "The third argument must be a natural number of appropriate size.\n";
return errcode_N;
}
}
typedef std::vector<indexvector_type> table_t;
table_t T; T.reserve(N);
for (count_type i = 0; i < N; ++i) {
index_type number_decisions = 0;
decisions_file >> number_decisions;
if (not decisions_file) {
std::cerr << err << "Reading error for number of decisions in \"" << decisions_filename << "\".\n";
return errcode_number_decisions;
}
indexvector_type I(number_decisions);
for (index_type j = 0; j < number_decisions; ++j) {
decisions_file >> I[j];
if (not decisions_file) {
std::cerr << err << "Reading error in \"" << decisions_filename << "\".\n";
return errcode_reading_decisions;
}
}
T.push_back(I);
}
assert(T.size() == N);
data_file.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
for (count_type counter = 1; counter <= N; ++counter) {
count_type running_number;
data_file >> running_number;
count_type file_number;
data_file >> file_number;
index_type number_assignments;
data_file >> number_assignments;
data_file.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
if (not data_file) {
std::cerr << err << "Reading error in \"" << data_filename << "\".\n";
return errcode_reading_data;
}
if (running_number != counter) {
std::cerr << err << "A non-consecutive running-number " << running_number << " in \"" << data_filename << "\".\n";
return errcode_running_number;
}
if (file_number == 0) {
std::cerr << err << "A file-index of 0 in \"" << data_filename << "\".\n";
return errcode_file_number_0;
}
if (file_number > N) {
std::cerr << err << "A file-index " << file_number << " in \""
<< data_filename << "\", which is greater than the parameter " << N
<< ".\n";
return errcode_file_number_N;
}
std::stringstream pa_name;
pa_name << dirname << "/" << file_number;
std::ifstream pa(pa_name.str().c_str());
pa.ignore(std::numeric_limits<std::streamsize>::max(),' ');
literalvector_type P(number_assignments);
for (index_type i = 0; i < number_assignments; ++i) pa >> P[i];
if (not pa) {
std::cerr << err << "Reading error for \"" << pa_name << "\".\n";
return errcode_reading_pa;
}
const indexvector_type& I = T[file_number-1];
const index_type number_decisions = I.size();
for (index_type i = 0; i < number_decisions; ++i) {
const index_type j = I[i];
if (j >= number_assignments) {
std::cerr << err << "For running number " << running_number <<
" in file " << data_filename << "\n the index " << j <<
" is more than the number " << number_assignments <<
" of assignments.\n";
return errcode_index;
}
std::cout << P[j];
if (i < number_decisions-1) std::cout << " ";
}
std::cout << "\n";
}
}
int main(int argc, char** argv)
{
if (argc < 5) {
std::cout << "Usage: patt_rec [data_matrix.txt] [pattern_matrix.txt] [mode 0: serial, 1: parallel] [number of threads]" << std::endl;
return 1;
}
int data_n_rows, data_n_cols;
std::ifstream data_file(argv[1]);
if (!data_file) error_exit("Data file not found!");
data_file >> data_n_rows >> data_n_cols;
int data[data_n_rows][data_n_cols];
for (int i = 0; i < data_n_rows; ++i)
{
for (int j = 0; j < data_n_cols; ++j)
{
data_file >> data[i][j];
}
}
int pattern_n_rows, pattern_n_cols;
std::ifstream pattern_file(argv[2]);
if (!pattern_file) error_exit("Pattern file not found");
pattern_file >> pattern_n_rows >> pattern_n_cols;
int pattern[pattern_n_rows][pattern_n_cols];
std::vector<int> pattern_elements;
for (int i = 0; i < pattern_n_rows; ++i)
{
for (int j = 0; j < pattern_n_cols; ++j)
{
pattern_file >> pattern[i][j];
pattern_elements.push_back(pattern[i][j]);
}
}
std::nth_element(pattern_elements.begin(),
pattern_elements.begin() + pattern_elements.size()/2,
pattern_elements.end());
const int median_pattern = pattern_elements[pattern_elements.size()/2];
std::vector<std::tuple<int, int, double>> matches;
double size_of_pattern_matrix = (double) pattern_n_cols * pattern_n_rows; //Evil C way.
bool is_parallel {atoi(argv[3]) == 1}; //Absolutly horribly... but works. Should be checked with a stream.
double time_start = omp_get_wtime();
int num_of_threads = atoi(argv[4]);
int chunk_size = data_n_rows / (num_of_threads * 10);
#pragma omp parallel for num_threads(num_of_threads) if(is_parallel) schedule(guided, chunk_size)
for (int i = 0; i < data_n_rows - pattern_n_rows; ++i) {
std::cout << omp_get_thread_num() << std::endl;
for (int j = 0; j < data_n_cols - pattern_n_cols; ++j) {
double current_goodness = 0;
std::vector<int>submatrix_elements;
for (int m_i = 0; m_i < pattern_n_rows; ++m_i) {
for (int m_j = 0; m_j < pattern_n_cols; ++m_j) {
int diff = absolute_value(data[i+m_i][j+m_j] - pattern[m_i][m_j]);
current_goodness += (double)diff;
submatrix_elements.push_back(data[i+m_i][j+m_j]);
if (diff > 9)
goto BREAK_OUUUUUUUT;
}
}
std::nth_element(submatrix_elements.begin(),
submatrix_elements.begin() + submatrix_elements.size()/2,
submatrix_elements.end());
if (absolute_value(submatrix_elements[submatrix_elements.size()/2] - median_pattern) > 2)
goto BREAK_OUUUUUUUT;
current_goodness /= size_of_pattern_matrix;
#pragma omp critical
matches.push_back(std::make_tuple(i, j, current_goodness));
BREAK_OUUUUUUUT : ;
}
}
double time_end = omp_get_wtime();
std::cout << "Took " << (time_end - time_start) << " seconds" << std::endl;
std::cout << "Matches (row, col, goodness)" << std::endl;
double min_goodness {std::numeric_limits<double>::max()}, max_goodness {std::numeric_limits<double>::min()}, average_goodness {0};
for (auto p : matches) {
std::cout << "(" << std::get<0>(p) << ", " << std::get<1>(p) << ", " << std::get<2>(p) << ")" << std::endl;
double current_goodness = std::get<2>(p);
if (current_goodness < min_goodness) min_goodness = current_goodness;
if (current_goodness > max_goodness) max_goodness = current_goodness;
average_goodness += current_goodness;
}
std::cout << "Min goodness: " << min_goodness << std::endl
<< "Max goodness: " << max_goodness << std::endl
<< "Average goodness: " << average_goodness / matches.size() << std::endl;
return 0;
}
int main(int argc, char* argv[]) {
if(argc<2) {
std::cout << "Usage: " << argv[0] << "data location" << std::endl;
}
// Things to initialize to parse the file.
std::string line;
std::ifstream data_file (argv[1]);
// Just to count the number of lines.
std::ifstream data_file_count (argv[1]);
int v_count = std::count(std::istreambuf_iterator<char>(data_file_count), std::istreambuf_iterator<char>(), '\n');
data_file_count.close();
int i=0;
std::vector<std::string> file_by_line[v_count];
std::string names[v_count];
std::vector<std::string> temp;
printf("%d\n",v_count);
// Store names, load up the split vectors.
if(data_file.is_open()) {
while(getline(data_file,line)) {
temp = split(line,' ');
names[i] = temp[0];
temp.erase(temp.begin());
file_by_line[i] = temp;
i++;
}
data_file.close();
}
// Finally, build the adjacency matrix.
int adj_matrix[v_count*v_count];
for(int i=0; i<v_count; i++) {
for(int j=0; j<v_count; j++) {
adj_matrix[i*v_count+j] = atoi( file_by_line[i][j].c_str() );
std::cout << adj_matrix[i*v_count+j] << " ";
}
std::cout << std::endl;
}
std::cout << "--------------------" << std::endl;
int dist[v_count*v_count];
for(int i=0; i<v_count; i++) {
for(int j=0; j<v_count; j++) {
if(adj_matrix[i*v_count+j] == 0 && i!=j) {
dist[i*v_count+j] = 1000;
}
else {
dist[i*v_count+j] = adj_matrix[i*v_count+j];
}
}
}
do_floyd_warshall(v_count, dist);
for(int i=0; i<v_count; i++) {
for(int j=0; j<v_count; j++) {
std::cout << dist[i*v_count+j] << " ";
}
std::cout << std::endl;
}
return 0;
}