bool Room::loadRoom(ifstream &ifs)
{
if(!ifs.is_open())
{
cout << "Could not open file." << endl;
return false;
}
ifs >> roomWidth;
ifs >> roomHeight;
ifs >> encounterLvl; //cout << encounterLvl; system("pause");
ifs.get();
string temp;
for(int y = 0; y < roomHeight; y++)
{
getline(ifs, temp);
for(int x = 0; x < roomWidth; x++)
{
room[x][y].setAppearance(temp[x]);
if(temp[x] == '#')
{
room[x][y].setDoor(false);
room[x][y].setSolid(true);
room[x][y].setBoss(false);
}
else if(temp[x] == 'D')
{
room[x][y].setDoor(true);
room[x][y].setSolid(false);
room[x][y].setBoss(false);
room[x][y].setDoorLoc(x, y);
if(numDoors < MAX_DOORS)
{
doors[numDoors] = &room[x][y];
numDoors++;
}
}
else if(temp[x] == 'S')
{
room[x][y].setAppearance(' ');
room[x][y].setDoor(false);
room[x][y].setSolid(false);
room[x][y].setBoss(false);
playerLoc.X = x-1;
playerLoc.Y = y;
}
else if(temp[x] >= '0' && temp[x] <= '8')
{
room[x][y].setAppearance(' ');
room[x][y].setDoor(false);
room[x][y].setSolid(false);
room[x][y].setBoss(false);
room[x][y].setEncounterChance((temp[x] - 48)*10);
}
else if(temp[x] == '9')
{
room[x][y].setAppearance(' ');
room[x][y].setDoor(false);
room[x][y].setSolid(false);
room[x][y].setBoss(false);
room[x][y].setEncounterChance(100);
}
else if(temp[x] == 'B')
{
room[x][y].setAppearance(234);
room[x][y].setDoor(false);
room[x][y].setBoss(true);
room[x][y].setSolid(false);
room[x][y].setEncounterChance(0);
}
}
}
for(int i = 0; i < numDoors; i++)
{
int r, d;
ifs >> r ;
ifs >> d;
doors[i]->setDestRoom(r, d);
}
return true;
}
void lexically_analyze(ifstream &code_file, ofstream &lex_file, ofstream &symbol_file)
{
if ( ! code_file.is_open())
throw "File not found";
std::unordered_set<string> symbols;
std::vector<token_lexeme_pair> token_lexemes;
int line_number = 1;
DFA dfaz[10];
initialize(dfaz[0], dfaz[1], dfaz[2], dfaz[3], dfaz[4], dfaz[5], dfaz[6], dfaz[7], dfaz[8], dfaz[9]);
int curr_dfa = 0;
int consecutive_break_count = 0; // To check for symbols not in the language.
std::string _subject((std::istreambuf_iterator<char>(code_file)), (std::istreambuf_iterator<char>()));
for (unsigned int _index = 0; _index < _subject.size(); _index++) {
if (_subject[_index] == '\n')
line_number++;
if (consecutive_break_count == DFA_COUNT || _subject[_index] == ' ' || _subject[_index] == '\n' || _subject[_index] == '\t' || _subject[_index] == '\0') {
consecutive_break_count = 0;
continue;
}
int i = _index;
string str;
int last_state = 0;
for (unsigned int j = i; ; j++) {
// DFA breaks.
int result = dfaz[curr_dfa].simulate_symbol(_subject[j]);
if (result == dfaz[curr_dfa].get_reserved_state()) {
if (last_state) { // Keep the 'str' string because a token has been found.
consecutive_break_count = 0;
_index = j - 1; // Continue where this DFA broke.
}
else { // Return to original position.
str.clear();
_index = i - 1;
consecutive_break_count++;
}
break;
}
// DFA enters into a neutral state.
if (result == 0) {
if (_subject[j] == '\n')
line_number++;
str.push_back(_subject[j]);
last_state = 0;
}
// DFA enters into an accept state.
if (result == 1) {
_index = j;
str.push_back(_subject[j]);
last_state = 1;
}
}
// Token found.
if (str.size() > 0) {
if (dfaz[curr_dfa].getName() == "identifier" && check_keyword(str)) {
token_lexemes.push_back(token_lexeme_pair("keyword", str, line_number));
}
else {
token_lexemes.push_back(token_lexeme_pair(dfaz[curr_dfa].getName(), str, line_number));
}
if (dfaz[curr_dfa].getName() == "identifier" && !check_keyword(str)) {
symbols.insert(str);
}
}
// Change DFA.
curr_dfa++;
if (curr_dfa == DFA_COUNT)
curr_dfa = 0;
}
for (const auto& elem : symbols) {
symbol_file << elem <<endl;
}
lex_file << setw(15);
for (std::vector<token_lexeme_pair>::iterator it = token_lexemes.begin(); it != token_lexemes.end(); it++) {
lex_file.width(30);
lex_file << "(" + it->name + ", '" + it->lexeme + "') ";
lex_file.width(20);
lex_file<< "Line: " + std::to_string(it->line_number) << endl;
}
}
void Labeler::readWordEmbeddings(const string& inFile, NRMat<dtype>& wordEmb) {
static ifstream inf;
if (inf.is_open()) {
inf.close();
inf.clear();
}
inf.open(inFile.c_str());
static string strLine, curWord;
static int wordId;
//find the first line, decide the wordDim;
while (1) {
if (!my_getline(inf, strLine)) {
break;
}
if (!strLine.empty())
break;
}
int unknownId = m_wordAlphabet.from_string(unknownkey);
static vector<string> vecInfo;
split_bychar(strLine, vecInfo, ' ');
int wordDim = vecInfo.size() - 1;
std::cout << "word embedding dim is " << wordDim << std::endl;
m_options.wordEmbSize = wordDim;
wordEmb.resize(m_wordAlphabet.size(), wordDim);
wordEmb = 0.0;
curWord = normalize_to_lowerwithdigit(vecInfo[0]);
wordId = m_wordAlphabet.from_string(curWord);
hash_set<int> indexers;
dtype sum[wordDim];
int count = 0;
bool bHasUnknown = false;
if (wordId >= 0) {
count++;
if (unknownId == wordId)
bHasUnknown = true;
indexers.insert(wordId);
for (int idx = 0; idx < wordDim; idx++) {
dtype curValue = atof(vecInfo[idx + 1].c_str());
sum[idx] = curValue;
wordEmb[wordId][idx] = curValue;
}
} else {
for (int idx = 0; idx < wordDim; idx++) {
sum[idx] = 0.0;
}
}
while (1) {
if (!my_getline(inf, strLine)) {
break;
}
if (strLine.empty())
continue;
split_bychar(strLine, vecInfo, ' ');
if (vecInfo.size() != wordDim + 1) {
std::cout << "error embedding file" << std::endl;
}
curWord = normalize_to_lowerwithdigit(vecInfo[0]);
wordId = m_wordAlphabet.from_string(curWord);
if (wordId >= 0) {
count++;
if (unknownId == wordId)
bHasUnknown = true;
indexers.insert(wordId);
for (int idx = 0; idx < wordDim; idx++) {
dtype curValue = atof(vecInfo[idx + 1].c_str());
sum[idx] += curValue;
wordEmb[wordId][idx] += curValue;
}
}
}
if (!bHasUnknown) {
for (int idx = 0; idx < wordDim; idx++) {
wordEmb[unknownId][idx] = sum[idx] / count;
}
count++;
std::cout << unknownkey << " not found, using averaged value to initialize." << std::endl;
}
int oovWords = 0;
int totalWords = 0;
for (int id = 0; id < m_wordAlphabet.size(); id++) {
if (indexers.find(id) == indexers.end()) {
oovWords++;
for (int idx = 0; idx < wordDim; idx++) {
wordEmb[id][idx] = wordEmb[unknownId][idx];
}
}
totalWords++;
}
std::cout << "OOV num is " << oovWords << ", total num is " << m_wordAlphabet.size() << ", embedding oov ratio is " << oovWords * 1.0 / m_wordAlphabet.size()
<< std::endl;
}
//========================setData=====================================
// Sets this Object's description to the line of characters extracted
// from the infile stream. If the description is longer than
// MAX_SIZE the trailing data will be omitted.
//
// Preconditions: The give ifstream is open.
//
// Postconditions: my_desc is set to the first MAX_SIZE of chars in
// the infile.
//====================================================================
void Object::setData (ifstream &infile)
{
if (infile.is_open())
infile.getline (my_desc, MAX_SIZE + 1);
}
bool crush_player::read (ifstream & file_stream)
{
if (file_stream.is_open () == 0)
{
return false;
}
int string_size = 0;
char name [PLAYER_NAME_LEN];
char team_name [TEAM_NAME_LEN];
memset (name, 0, PLAYER_NAME_LEN);
memset (team_name, 0, TEAM_NAME_LEN);
file_stream.read ((char*) &string_size, 4);
if (string_size > PLAYER_NAME_LEN)
{
return false;
}
file_stream.read ((char*) name, string_size);
m_name = name;
m_name.resize (string_size);
file_stream.read ((char*) &string_size, 4);
if (string_size > TEAM_NAME_LEN)
{
return false;
}
file_stream.read ((char*) team_name, string_size);
m_team_name = team_name;
m_team_name.resize (string_size);
file_stream.read ((char*) &m_last_crush_week, 4);
file_stream.read ((char*) &m_last_crush_season, 4);
file_stream.read ((char*) &m_dead, 4);
file_stream.read ((char*) &m_first_crush_week, 4);
file_stream.read ((char*) &m_first_crush_season, 4);
file_stream.read ((char*) &m_jersey_color, 1);
file_stream.read ((char*) &m_trim_color, 1);
file_stream.read ((char*) &m_ap, 1);
file_stream.read ((char*) &m_checking, 1);
file_stream.read ((char*) &m_strength, 1);
file_stream.read ((char*) &m_toughness, 1);
file_stream.read ((char*) &m_reflexes, 1);
file_stream.read ((char*) &m_jump, 1);
file_stream.read ((char*) &m_hands, 1);
file_stream.read ((char*) &m_dodge, 1);
file_stream.read ((char*) &m_total_value, 2);
file_stream.read ((char*) &m_points_to_spend, 2);
file_stream.read ((char*) &m_race, sizeof (race_type));
file_stream.read ((char*) &m_best_rushing_tiles, 2);
file_stream.read ((char*) &m_best_goals_scored, 2);
file_stream.read ((char*) &m_best_kills_for, 2);
file_stream.read ((char*) &m_best_injuries_for, 2);
file_stream.read ((char*) &m_best_checks_thrown, 2);
file_stream.read ((char*) &m_best_checks_landed, 2);
file_stream.read ((char*) &m_best_rushing_attempts, 2);
file_stream.read ((char*) &m_best_sacks_for, 2);
file_stream.read ((char*) &m_rushing_tiles, 2);
file_stream.read ((char*) &m_goals_scored, 2);
file_stream.read ((char*) &m_kills_for, 2);
file_stream.read ((char*) &m_injuries_for, 2);
file_stream.read ((char*) &m_checks_thrown, 2);
file_stream.read ((char*) &m_checks_landed, 2);
file_stream.read ((char*) &m_rushing_attempts, 2);
file_stream.read ((char*) &m_sacks_for, 2);
file_stream.read ((char*) &m_total_rushing_tiles, 2);
file_stream.read ((char*) &m_total_goals_scored, 2);
file_stream.read ((char*) &m_total_kills_for, 2);
file_stream.read ((char*) &m_total_injuries_for, 2);
file_stream.read ((char*) &m_total_checks_thrown, 2);
file_stream.read ((char*) &m_total_checks_landed, 2);
file_stream.read ((char*) &m_total_rushing_attempts, 2);
file_stream.read ((char*) &m_total_sacks_for, 2);
int historical_week_list_size;
file_stream.read ((char*) &historical_week_list_size, 4);
for (int historical_week_index = 0; historical_week_index < historical_week_list_size; historical_week_index++)
{
crush_player_historical_week_ptr current_week = new crush_player_historical_week;
current_week->read (file_stream);
m_crush_player_historical_week_list.push_back (current_week);
}
return true;
}
bool yylexopen(const char filename[])
{
fin.open(filename, ios_base::in);
return fin.is_open();
}
void chkpt_t::deserialize_binary(ifstream& ifs)
{
if(!ifs.is_open()) {
cerr << "Could not open input stream for chkpt file" << endl;;
W_FATAL(fcINTERNAL);
}
ifs.read((char*)&highest_tid, sizeof(tid_t));
size_t buf_tab_size;
ifs.read((char*)&buf_tab_size, sizeof(size_t));
for(uint i=0; i<buf_tab_size; i++) {
PageID pid;
ifs.read((char*)&pid, sizeof(PageID));
buf_tab_entry_t entry;
ifs.read((char*)&entry, sizeof(buf_tab_entry_t));
DBGOUT1(<<"pid[]="<<pid<< " , " <<
"rec_lsn[]="<<entry.rec_lsn<< " , " <<
"page_lsn[]="<<entry.page_lsn);
// buf_tab[pid] = entry;
mark_page_dirty(pid, entry.page_lsn, entry.rec_lsn);
}
size_t xct_tab_size;
ifs.read((char*)&xct_tab_size, sizeof(size_t));
for(uint i=0; i<xct_tab_size; i++) {
tid_t tid;
ifs.read((char*)&tid, sizeof(tid_t));
xct_tab_entry_t entry;
ifs.read((char*)&entry.state, sizeof(smlevel_0::xct_state_t));
ifs.read((char*)&entry.last_lsn, sizeof(lsn_t));
ifs.read((char*)&entry.first_lsn, sizeof(lsn_t));
DBGOUT1(<<"tid[]="<<tid<<" , " <<
"state[]="<<entry.state<< " , " <<
"last_lsn[]="<<entry.last_lsn<<" , " <<
"first_lsn[]="<<entry.first_lsn);
if (entry.state != smlevel_0::xct_ended) {
mark_xct_active(tid, entry.first_lsn, entry.last_lsn);
if (is_xct_active(tid)) {
size_t lock_tab_size;
ifs.read((char*)&lock_tab_size, sizeof(size_t));
for(uint j=0; j<lock_tab_size; j++) {
lock_info_t lock_entry;
ifs.read((char*)&lock_entry, sizeof(lock_info_t));
// entry.locks.push_back(lock_entry);
add_lock(tid, lock_entry.lock_mode, lock_entry.lock_hash);
DBGOUT1(<< " lock_mode[]="<<lock_entry.lock_mode
<< " , lock_hash[]="<<lock_entry.lock_hash);
}
}
// xct_tab[tid] = entry;
}
}
bool LightFile::open(ifstream &file, const char *filename) {
file.open(filename, ios::in);
return file.is_open();
}
virtual bool hasNext()
{
if (readFile.is_open()==false) return false;
getline (readFile,line);
return (readFile.eof()==false);
}
///////////////////////////////////////////////////////////////////////////////
// Name: PromptUserInput
// Author: Scott Olmstead
// Description: Prompts the user as to what file they would like to open.
// Then, based on their choice, opens the input and output files
// associated with that choice.
///////////////////////////////////////////////////////////////////////////////
void PromptUserInput(ofstream& outputFile,
ifstream& inputFile)
{
int index;
int choice;
//Output a file list title to the console window
cout << "File Names" << endl;
//Output a divider to the console window
OutputDivider((ofstream&)cout,'-',CONSOLE_WIDTH);
//Output the choices to the to console window
for(index = 0; index < FILE_COUNT; index++)
{
//Output the current file name to the console window
cout << index + 1 << ". " << INPUT_NAMES[index]
<< endl;
}
//Output a divider to the console window
OutputDivider((ofstream&)cout,'=',CONSOLE_WIDTH);
//Prompt the user to enter a file number via console
cout << "Enter the number of which file you would like to use: ";
//Get choice from the keyboard via console
cin >> choice;
//Output whitespace to the console window
cout << endl;
//If choice is out of range, select default
if(!(choice > 0 && choice <= FILE_COUNT))
{
//Output a divider to the console window
OutputDivider((ofstream&)cout,'.', 30);
//Output an error message to the console window
cout << "Choice " << choice
<< " is out of range." << endl;
//Let the user know the default was selected
// by outputting message to console window
cout << "Opening default file choice, 1"
<< endl;
//Set the default choice(1)
choice = 1;
}
//Open the input file
inputFile.open(INPUT_NAMES[choice - 1]);
//Open output file
outputFile.open(OUTPUT_NAMES[choice - 1]);
//If the input file is open
if(inputFile.is_open())
{
//Output a message to the console window saying the input file
// was opened
cout << "SUCCESS! The file " << INPUT_NAMES[choice - 1]
<< " was opened successfully. " << endl;
}
//If the input file is not open
else
{
//Output a message to the console window stating the file could not
// be opened.
cout << "ERROR: The file " << INPUT_NAMES[choice - 1]
<< " could not be opened. " << endl
<< " This program will not produce expected results";
}
//Output a message to the console window stating what the
// output file is named.
cout << endl << "Writing output to: " << OUTPUT_NAMES[choice - 1]
<< endl;
//Output a divider to the console window
OutputDivider((ofstream&)cout,'_', CONSOLE_WIDTH);
}
if(fileName.size() == 0){
// The string is a list of node numbers
stringstream ss(Teuchos::getValue<string>(it->second));
int nodeID;
while(ss.good()){
ss >> nodeID;
// Convert from 1-based node numbering (Exodus II) to 0-based node numbering (Epetra and all the rest of Peridigm)
TEUCHOS_TEST_FOR_EXCEPT_MSG(nodeID < 1, "**** Error: Node number 0 detected in nodeset definition; node numbering must begin with 1.\n");
nodeList.push_back(nodeID - 1);
}
}
else{
// The string is the name of a file containing the node numbers
ifstream inFile(fileName.c_str());
TEUCHOS_TEST_FOR_EXCEPT_MSG(!inFile.is_open(), "**** Error opening node set text file: " + fileName + "\n");
while(inFile.good()){
string str;
getline(inFile, str);
boost::trim(str);
// Ignore comment lines, otherwise parse
if( !(str[0] == '#' || str[0] == '/' || str[0] == '*' || str.size() == 0) ){
istringstream iss(str);
vector<int> nodeNumbers;
copy(istream_iterator<int>(iss),
istream_iterator<int>(),
back_inserter<vector<int> >(nodeNumbers));
for(unsigned int i=0 ; i<nodeNumbers.size() ; ++i){
// Convert from 1-based node numbering (Exodus II) to 0-based node numbering (Epetra and all the rest of Peridigm)
TEUCHOS_TEST_FOR_EXCEPT_MSG(nodeNumbers[i] < 1, "**** Error: Node number 0 detected in nodeset file; node numbering must begin with 1.\n");
nodeList.push_back(nodeNumbers[i] - 1);
void init (string simfilename) {
/* intialization reads the simfile and populates the internal parameters
simfilename = name of the simulation parameter file
*/
cfile.open(simfilename.c_str());
if (!cfile.is_open()) {
cout << "ERROR: cannot find simfile!" << endl;
exit (10);
}
// populate the internal parameters
string returnstring; // string that gets returned for conversion to numbers
returnstring = find_header_element ("ydim", false);
ydim = atoi (returnstring.c_str());
returnstring = find_header_element ("xdim", false);
xdim = atoi (returnstring.c_str());
returnstring = find_header_element ("cellsize", false);
cellsize = atof (returnstring.c_str());
returnstring = find_header_element ("yll_corner", false);
yll_corner = atof (returnstring.c_str());
returnstring = find_header_element ("xll_corner", false);
xll_corner = atof (returnstring.c_str());
returnstring = find_header_element ("max_iterations", false);
max_iterations = atoi (returnstring.c_str());
returnstring = find_header_element ("len_timestep", false);
len_timestep = atof (returnstring.c_str());
returnstring = find_header_element ("global_basal_pres", false);
global_basal_pres = atof (returnstring.c_str());
returnstring = find_header_element ("viscosity", false);
viscosity = atof (returnstring.c_str());
returnstring = find_header_element ("Q_advection_global", false);
Q_advection_global = atof (returnstring.c_str());
returnstring = find_header_element ("Q_advection_stochasticity", false);
Q_advection_stochasticity = atof (returnstring.c_str());
returnstring = find_header_element ("Q_squish_coef", false);
Q_squish_coef = atof (returnstring.c_str());
returnstring = find_header_element ("ice_advection", false);
ice_advection = atof (returnstring.c_str());
// entrainment variables
returnstring = find_header_element ("entrainment_cavity", false);
entrainment_cavity = atof (returnstring.c_str());
returnstring = find_header_element ("entrainment_zero", false);
entrainment_zero = atof (returnstring.c_str());
returnstring = find_header_element ("entrainment_slp_1", false);
entrainment_slp_1 = atof (returnstring.c_str());
returnstring = find_header_element ("entrainment_vtx_2", false);
entrainment_vtx_2 = atof (returnstring.c_str());
returnstring = find_header_element ("entrainment_slp_2", false);
entrainment_slp_2 = atof (returnstring.c_str());
// basement erosion properties
returnstring = find_header_element ("abrasion_from_N_slope", false);
abrasion_from_N_slope = atof (returnstring.c_str());
returnstring = find_header_element ("abrasion_from_N_zero", false);
abrasion_from_N_zero = atof (returnstring.c_str());
returnstring = find_header_element ("abrasion_from_iceload", false);
abrasion_from_iceload = atof (returnstring.c_str());
returnstring = find_header_element ("global_bsmt_erodibility", false);
global_bsmt_erodibility = atof (returnstring.c_str());
returnstring = find_header_element ("iceload_surf_return_fraction", false);
iceload_surf_return_fraction = atof (returnstring.c_str());
// sediment bleed properties
returnstring = find_header_element ("iceload_bleed", false);
iceload_bleed = atof (returnstring.c_str());
returnstring = find_header_element ("surf_bleed", false);
surf_bleed = atof (returnstring.c_str());
// R script parameters
Rscript_path = find_header_element ("Rscript_path", true);
progress_utility_name = find_header_element ("progress_utility_name", true);
returnstring = find_header_element ("on_the_fly_progress_updates", false);
if (returnstring == "yes") {
on_the_fly_progress_updates = true;
} else {
on_the_fly_progress_updates = false;
}
// boundaries
boundaries_ns = find_header_element ("boundaries_ns", false);
boundaries_ew = find_header_element ("boundaries_ew", false);
returnstring = find_header_element ("interim_file_output_interval", false);
interim_file_output_interval = atoi (returnstring.c_str());
file_output_prefix = find_header_element ("file_output_prefix", true);
init_type = find_header_element ("init_type", false);
returnstring = find_header_element ("flat_init_basement_elev", false);
flat_init_basement_elev = atof (returnstring.c_str());
returnstring = find_header_element ("flat_init_sedfill_elev", false);
flat_init_sedfill_elev = atof (returnstring.c_str());
returnstring = find_header_element ("init_iceload", false);
init_iceload = atof (returnstring.c_str());
returnstring = find_header_element ("init_erodibility", false);
init_erodibility = atof (returnstring.c_str());
existing_surf_file = find_header_element ("existing_surf_file", true);
existing_bsmt_file = find_header_element ("existing_bsmt_file", true);
existing_erodibility_file = find_header_element ("existing_erodibility_file", true);
cfile.close();
}