std::vector<READ> vecStrToReadObjs(const VecStr & strs, const std::string & stubName){
std::vector<READ> ans;
for(const auto & strPos : iter::range(strs.size())){
ans.emplace_back(READ(seqInfo(stubName + "." + leftPadNumStr(strPos, strs.size()), strs[strPos])));
}
return ans;
}
bool TableReader::getNextRow(VecStr & row){
std::string currentLine = "";
row.clear();
if(njh::files::crossPlatGetline(*in_, currentLine)){
row = tokenizeString(currentLine, tabOpts_.inDelim_, true);
if(row.size() != header_.nCol()){
std::stringstream ss;
ss << __PRETTY_FUNCTION__ << ", error the row has a different number of columns than the first line" << "\n";
ss << "rowSize: " << row.size() << ", firstLineSize: " << header_.nCol() << "\n";
ss << "row: " << currentLine << "\n";
throw std::runtime_error{ss.str()};
}
return true;
}
return false;
}
VecStr TableReader::extractCols(const VecStr & row, const VecStr & cols) const{
VecStr ret;
ret.reserve(cols.size());
for(const auto & col : cols){
ret.emplace_back(row[header_.getColPos(col)]);
}
return ret;
}
std::vector<uint32_t> getPositionsMatchingPattern(const VecStr& vec,
const std::regex & pattern){
std::vector<uint32_t> positions;
for(const auto pos : iter::range(vec.size())){
std::smatch match;
if(std::regex_match(vec[pos], match, pattern) ){
positions.emplace_back(pos);
}
}
return positions;
}
// open files to plot transient
void open_tran_plot_files(Nodelist & nodelist,
vector<FILE *> & fplot) {
string name;
// open plot transient files
for(size_t i=0; i<g_plot_tran_node.size(); i++) {
name = g_plot_tran_node[i];
string of = g_basename + "_" + name + "_t.dat";
cout<<"Node \""<<name<<"\" transient plot : "<<of<<endl;
FILE * ofs=fopen(of.c_str(),"w");
fplot.push_back(ofs);
}
}
CharacterVector raggedToWide(const VecVecStr& ragged, int max_per_pt,
const VecStr &visitIds) {
#ifdef ICD9_DEBUG_TRACE
Rcpp::Rcout << "visitIds = ";
// printIt(visitIds); // broken, not sure why.
#endif
VecStr::size_type distinct_visits = ragged.size();
CharacterVector out(distinct_visits * max_per_pt, NA_STRING); // optionally default empty strings? NA? User can do this for now.
#ifdef ICD9_DEBUG
if (distinct_visits==0) {
Rcpp::Rcout << "no visits. returning blank data\n";
return CharacterVector::create();
}
if (distinct_visits != visitIds.size()) {
Rcpp::Rcout << "visit and ragged sizes differ. visits = " << visitIds.size() <<
", ragged size = " << distinct_visits << ": returning blank data\n";
return CharacterVector::create();
}
#endif
for (VecVecStr::size_type row_it = 0; row_it < distinct_visits; ++row_it) {
const VecStr& this_row = ragged[row_it];
VecStr::size_type this_row_len = this_row.size();
for (VecStr::size_type col_it = 0; col_it < this_row_len; ++col_it) {
// write in row major format, but this means transpose needed later
VecVecStr::size_type out_idx = row_it + (distinct_visits * col_it);
out[out_idx] = this_row[col_it];
}
}
#ifdef ICD9_DEBUG
Rcpp::Rcout << "writing dimensions\n";
#endif
// set dimensions in reverse (row major for parallel step)
out.attr("dim") = Dimension(distinct_visits, max_per_pt);
#ifdef ICD9_DEBUG
Rcpp::Rcout << "writing labels\n";
#endif
CharacterVector nonames;
rownames(out) = wrap(visitIds);
return out;
}
bool areAllOccupiedBySuperstring(Array2D<VecStr> const& occupied,
std::string str,
Coord const& coord,
Direction const& dir)
{
/**
* @brief Given the array of squares in the wordsearch that are occupied,
* we check to see if the word str is "allowed" to be at the coord
* of ld and have direction dir. See wsSolveDoc.h for more information
* on what's "allowed" and what's not.
*/
//Assert that you remain in the bounds; this is a "private" function, and
//you should never leave the bounds when wsSolve() is called.
assert((coord.pX + (str.size() - 1) * dir.dX >= 0) &&
(coord.pX + (str.size() - 1) * dir.dX < occupied.getWidth()) &&
(coord.pY + (str.size() - 1) * dir.dY >= 0) &&
(coord.pY + (str.size() - 1) * dir.dY < occupied.getHeight()));
//The string's length can't be 0.
assert(str.size() != 0);
//First check if the square that the first letter of str occupies is occupied
//by any superstring of str. If not, exit; if so, make a list of them.
VecStr firstVecStr = occupied(coord.pX, coord.pY);
if (firstVecStr.size() == 0)
return false;
//Executes iff above code didn't return false.
VecStr possibleSuperstrList;
for (unsigned i = 0; i != firstVecStr.size(); ++i)
{
//The below statement is equivalent to "if str is not a substring of
//firstVecStr[i].
if (firstVecStr[i].find(str) == std::string::npos)
return false;
else
possibleSuperstrList.push_back(firstVecStr[i]);
}
//If the string is only one letter long, and we didn't return false yet, it means
//that the string is on a spot occupied by one of its superstrings. Hence, we
//return true.
if (str.size() == 1)
return true;
//Something important to note is that str can only be a substring of any
//superstring of str if its first is contained by a superstring of str.
//Therefore, the set of all possible superstrings of str that overlap with str
//entirely has already been determined. In the following code, we either find a
//square which is empty or does not contain a superstring of str (and therefore
//we return false) or find a square in which some element of possibleSuperstrList
//is not found on the square (implying that that element is not a superstring of
//str that overlaps with str entirely; make sure you see why); we therefore
//remove that element from possibleSuperStrList. In the end, any remaining elements
//in possibleSuperstrList is definitely a superstring of str that overlaps with
//str entirely; hence, if it is empty by the end, this function returns false,
//and if it isn't empty, this function returns true.
for (unsigned i = 1; i < str.size(); ++i)
{
//Vector obtained at the current position in the array.
VecStr vecStrCurrent = occupied(coord.pX + i * dir.dX, coord.pY + i * dir.dY);
//List of superstrings of str on the current square.
VecStr superstrListCurrent;
//If the vector is empty, the position is unoccupied.
if (vecStrCurrent.size() == 0)
return false;
//See if str is a substring of any strings currently held in vecStrCurrent.
for (unsigned j = 0; j != vecStrCurrent.size(); ++j)
{
//The below statement is equivalent to "if str is not a substring of
//vecStrCurrent[i].
if (vecStrCurrent[j].find(str) == std::string::npos)
return false;
else
superstrListCurrent.push_back(vecStrCurrent[j]);
}
//Get rid of all the elements of possibleSuperstrList that don't appear in
//vecSuperStrListCurrent. We do this by creating a new vector containing all
//elements that DO appear in vecSuperStrListCurrent, and then copy
//possibleSuperstrList to the new one.
VecStr newPossibleSuperstrList;
for (unsigned j = 0; j != possibleSuperstrList.size(); ++j)
{
for (unsigned k = 0; k != superstrListCurrent.size(); ++k)
{
if (possibleSuperstrList[j] == superstrListCurrent[k])
{
newPossibleSuperstrList.push_back(possibleSuperstrList[j]);
break;
}
}
}
possibleSuperstrList = newPossibleSuperstrList;
//If it's empty, you're done.
if (possibleSuperstrList.size() == 0)
return false;
}
//Reached if and only if the above code doesn't execute.
return true;
}
void processArgsFile(string filename, VecPlayerType& players, bool& alwaysCheckPayoffs, string& domainString,
string& problemString, int& nGames) {
const bool Verbose = true;
VecStr args;
ifstream infile(filename.c_str(), std::ios::in);
if (!infile) {
cerr << "Error reading file: " << filename << std::endl;
exit(1);
}
string oneline;
while (!infile.eof()) {
getline(infile, oneline);
if (oneline == "")
break;
std::istringstream linestring(oneline);
string nextArg;
linestring >> nextArg; // dummy text at the front of a line
linestring >> nextArg; // actual arg
args.push_back(nextArg);
}
StringToPlayerType playerTypes = GameModerator::getPlayerTypes();
for (unsigned i = 0; i < args.size(); i++) {
if (Verbose)
cout << i << " " << args[i] << "\n";
switch (i) {
case 0:
players[0] = playerTypes[args[0]];
break;
case 1:
players[1] = playerTypes[args[1]];
break;
case 2:
players[2] = playerTypes[args[2]];
break;
case 3:
assignGame(atoi(args[3].c_str()), alwaysCheckPayoffs, domainString, problemString);
break;
case 4:
nGames = atoi(args[4].c_str());
break;
case 5:
GameModerator::manySamples = atoi(args[5].c_str());
break;
case 6:
GameModerator::fewSamples = atoi(args[6].c_str());
break;
case 7:
GameModerator::maxSize = atoi(args[7].c_str());
break;
}
}
if (Verbose) {
cout << "PT0: " << GameModerator::typeString(players[0]) << std::endl;
cout << "PT1: " << GameModerator::typeString(players[1]) << std::endl;
cout << "PT2: " << GameModerator::typeString(players[2]) << std::endl;
cout << "Game: " << domainString << " " << problemString << std::endl;
cout << "nGames: " << nGames << std::endl;
cout << "maxSamples: " << GameModerator::manySamples << std::endl;
cout << "minSamples: " << GameModerator::fewSamples << std::endl;
cout << "infoSet size: " << GameModerator::maxSize << std::endl;
}
}