int longToRagged(const SEXP& icd9df, VecVecStr& ragged, VecStr& visitIds,
const std::string visitId, const std::string icd9Field =
"icd9", bool aggregate = true) {
#ifdef ICD9_VALGRIND
CALLGRIND_START_INSTRUMENTATION;
#endif
SEXP icds = PROTECT(getRListOrDfElement(icd9df, icd9Field.c_str()));
SEXP vsexp = PROTECT(getRListOrDfElement(icd9df, visitId.c_str()));
const int approx_cmb_per_visit = 15; // just an estimate. Prob best to overestimate.
int vlen = Rf_length(icds);
visitIds.reserve(vlen / approx_cmb_per_visit);
ragged.reserve(vlen / approx_cmb_per_visit);
int max_per_pt = 1;
if (TYPEOF(vsexp) != STRSXP)
Rcpp::stop("need string input to longToRagged\n");
#ifdef ICD9_DEBUG
Rcpp::Rcout << "longToRagged SEXP is STR\n";
#endif
const char* lastVisitId = "";
for (int i = 0; i < vlen; ++i) {
// always STRING? may get numeric, integer, factor? Can always handle this on R side
const char* icd = CHAR(STRING_ELT(icds, i));
const char* vi = CHAR(STRING_ELT(vsexp, i));
if (strcmp(lastVisitId, vi) != 0
&& (!aggregate
|| std::find(visitIds.rbegin(), visitIds.rend(), vi)
== visitIds.rend())) {
VecStr vcodes;
vcodes.reserve(approx_cmb_per_visit); // estimate of number of codes per patient.
vcodes.push_back(icd); // new vector of ICD codes with this first item
ragged.push_back(vcodes); // and add that vector to the intermediate structure
visitIds.push_back(vi);
} else {
#ifdef ICD9_DEBUG
if (ragged.size()==0) {
Rcout << "ragged size is ZERO! aborting\n";
break;
}
#endif
ragged[ragged.size() - 1].push_back(icd); // augment vec for current visit and N/V/E type // EXPENSIVE.
int len = ragged[ragged.size() - 1].size(); // get new count of cmb for one patient
if (len > max_per_pt)
max_per_pt = len;
}
#ifdef ICD9_DEBUG_TRACE
Rcout << "ragged size is " << ragged.size() << "\n";
#endif
lastVisitId = vi;
} // end loop through all visit-code input data
#ifdef ICD9_VALGRIND
CALLGRIND_STOP_INSTRUMENTATION;
// CALLGRIND_DUMP_STATS;
#endif
UNPROTECT(2); // do sooner if possible?
return max_per_pt;
}
VecStr alignToSeqStrings(const std::vector<READ>& reads, const REF& reference,
aligner& alignObj, bool local, bool usingQuality) {
VecStr output;
output.push_back(reference.seqBase_.seq_);
for (const auto read : reads) {
alignObj.alignCache(reference, read, local);
output.push_back(alignObj.alignObjectB_.seqBase_.seq_);
}
return output;
}
VecStr findLongestSharedSeqFromReads(const std::vector<T>& reads) {
VecStr seqs;
for (const auto& rIter : reads) {
seqs.push_back(rIter.seqBase_.seq_);
}
return seqUtil::findLongestShardedMotif(seqs);
}
VecStr ParamModelBase::Keys() const
{
VecStr vs;
const size_t num_pars = _parameters.size();
for (size_t i=0; i<num_pars; ++i)
vs.push_back(Key(i));
return vs;
}
const VecStr fastPermuteVectorOneLength(std::string vec) {
VecStr ans;
int numOfPermutes = Factorial((int)vec.size());
ans.reserve(numOfPermutes);
do {
ans.push_back(vec);
} while (std::next_permutation(vec.begin(), vec.end()));
return ans;
}
VecStr getStringsContains(const VecStr& vec, const std::string& contains) {
VecStr ans;
for (const auto& iter : vec) {
if (iter.find(contains) != std::string::npos) {
ans.push_back(iter);
}
}
return ans;
}
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;
}
}