set<string> types;
types.insert("fasta");
+ types.insert("summary");
types.insert("accnos");
types.insert("column");
types.insert("design");
if (biomfile != "") { mothurOut("biom=" + biomfile); mothurOutEndLine(); }
if (counttablefile != "") { mothurOut("count=" + counttablefile); mothurOutEndLine(); }
if (processors != "1") { mothurOut("processors=" + processors); mothurOutEndLine(); }
+ if (summaryfile != "") { mothurOut("summary=" + summaryfile); mothurOutEndLine(); }
}
catch(exception& e) {
if (flowfile != "") { return true; }
if (biomfile != "") { return true; }
if (counttablefile != "") { return true; }
+ if (summaryfile != "") { return true; }
if (processors != "1") { return true; }
return hasCurrent;
flowfile = "";
biomfile = "";
counttablefile = "";
+ summaryfile = "";
processors = "1";
}
catch(exception& e) {
}
}
/*********************************************************************************************/
+void MothurOut::mothurOutJustToScreen(string output) {
+ try {
+
+#ifdef USE_MPI
+ int pid;
+ MPI_Comm_rank(MPI_COMM_WORLD, &pid);
+
+ if (pid == 0) { //only one process should output to screen
+#endif
+ logger() << output;
+
+#ifdef USE_MPI
+ }
+#endif
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "MothurOut");
+ exit(1);
+ }
+}
+/*********************************************************************************************/
void MothurOut::mothurOutEndLine() {
try {
#ifdef USE_MPI
//double vm, rss;
//mem_usage(vm, rss);
- mothurOut("[ERROR]: ");
- mothurOut(toString(e.what()));
- mothurOut(" has occurred in the " + object + " class function " + function + ". Please contact Pat Schloss at mothur.bugs@gmail.com, and be sure to include the mothur.logFile with your inquiry.");
- mothurOutEndLine();
+ string errorType = toString(e.what());
+
+ int pos = errorType.find("bad_alloc");
+ mothurOut("[ERROR]: ");
+ mothurOut(errorType);
+
+ if (pos == string::npos) { //not bad_alloc
+ mothurOut(" has occurred in the " + object + " class function " + function + ". Please contact Pat Schloss at mothur.bugs@gmail.com, and be sure to include the mothur.logFile with your inquiry.");
+ mothurOutEndLine();
+ }else { //bad alloc
+ if (object == "cluster"){
+ mothurOut(" has occurred in the " + object + " class function " + function + ". This error indicates your computer is running out of memory. There are two common causes for this, file size and format.\n\nFile Size:\nThe cluster command loads your distance matrix into RAM, and your distance file is most likely too large to fit in RAM. There are two options to help with this. The first is to use a cutoff. By using a cutoff mothur will only load distances that are below the cutoff. If that is still not enough, there is a command called cluster.split, http://www.mothur.org/wiki/cluster.split which divides the distance matrix, and clusters the smaller pieces separately. You may also be able to reduce the size of the original distance matrix by using the commands outlined in the Schloss SOP, http://www.mothur.org/wiki/Schloss_SOP. \n\nWrong Format:\nThis error can be caused by trying to read a column formatted distance matrix using the phylip parameter. By default, the dist.seqs command generates a column formatted distance matrix. To make a phylip formatted matrix set the dist.seqs command parameter output to lt. \n\nIf you are uable to resolve the issue, please contact Pat Schloss at mothur.bugs@gmail.com, and be sure to include the mothur.logFile with your inquiry.");
+ }else if (object == "shhh.flows"){
+ mothurOut(" has occurred in the " + object + " class function " + function + ". This error indicates your computer is running out of memory. The shhh.flows command is very memory intensive. This error is most commonly caused by trying to process a dataset too large, using multiple processors, or failing to run trim.flows before shhh.flows. If you are running our 32bit version, your memory usage is limited to 4G. If you have more than 4G of RAM and are running a 64bit OS, using our 64bit version may resolve your issue. If you are using multiple processors, try running the command with processors=1, the more processors you use the more memory is required. Running trim.flows with an oligos file, and then shhh.flows with the file option may also resolve the issue. If for some reason you are unable to run shhh.flows with your data, a good alternative is to use the trim.seqs command using a 50-bp sliding window and to trim the sequence when the average quality score over that window drops below 35. Our results suggest that the sequencing error rates by this method are very good, but not quite as good as by shhh.flows and that the resulting sequences tend to be a bit shorter. If you are uable to resolve the issue, please contact Pat Schloss at mothur.bugs@gmail.com, and be sure to include the mothur.logFile with your inquiry. ");
+ }else {
+ mothurOut(" has occurred in the " + object + " class function " + function + ". This error indicates your computer is running out of memory. This is most commonly caused by trying to process a dataset too large, using multiple processors, or a file format issue. If you are running our 32bit version, your memory usage is limited to 4G. If you have more than 4G of RAM and are running a 64bit OS, using our 64bit version may resolve your issue. If you are using multiple processors, try running the command with processors=1, the more processors you use the more memory is required. Also, you may be able to reduce the size of your dataset by using the commands outlined in the Schloss SOP, http://www.mothur.org/wiki/Schloss_SOP. If you are uable to resolve the issue, please contact Pat Schloss at mothur.bugs@gmail.com, and be sure to include the mothur.logFile with your inquiry.");
+ }
+ }
}
/*********************************************************************************************/
//The following was originally from http://stackoverflow.com/questions/669438/how-to-get-memory-usage-at-run-time-in-c
exit(1);
}
}
+/***********************************************************************/
+int MothurOut::openOutputFileBinaryAppend(string fileName, ofstream& fileHandle){
+ try {
+ fileName = getFullPathName(fileName);
+
+ fileHandle.open(fileName.c_str(), ios::app | ios::binary);
+ if(!fileHandle) {
+ mothurOut("[ERROR]: Could not open " + fileName); mothurOutEndLine();
+ return 1;
+ }
+ else {
+ return 0;
+ }
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "openOutputFileAppend");
+ exit(1);
+ }
+}
+
/***********************************************************************/
void MothurOut::gobble(istream& f){
try {
bool MothurOut::dirCheck(string& dirName){
try {
+ if (dirName == "") { return false; }
+
string tag = "";
#ifdef USE_MPI
int pid;
//test to make sure directory exists
dirName = getFullPathName(dirName);
- string outTemp = dirName + tag + "temp";
+ string outTemp = dirName + tag + "temp"+ toString(time(NULL));
ofstream out;
out.open(outTemp.c_str(), ios::trunc);
if(!out) {
}
}
+//**********************************************************************************************************************
+
+map<string, vector<string> > MothurOut::parseClasses(string classes){
+ try {
+ map<string, vector<string> > parts;
+
+ //treatment<Early|Late>-age<young|old>
+ vector<string> pieces; splitAtDash(classes, pieces); // -> treatment<Early|Late>, age<young|old>
+
+ for (int i = 0; i < pieces.size(); i++) {
+ string category = ""; string value = "";
+ bool foundOpen = false;
+ for (int j = 0; j < pieces[i].length(); j++) {
+ if (control_pressed) { return parts; }
+
+ if (pieces[i][j] == '<') { foundOpen = true; }
+ else if (pieces[i][j] == '>') { j += pieces[i].length(); }
+ else {
+ if (!foundOpen) { category += pieces[i][j]; }
+ else { value += pieces[i][j]; }
+ }
+ }
+ vector<string> values; splitAtChar(value, values, '|');
+ parts[category] = values;
+ }
+
+ return parts;
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "parseClasses");
+ exit(1);
+ }
+}
/***********************************************************************/
string MothurOut::hasPath(string longName){
}
for (int i = index; i >= 0; i--) {
- newFileName = dirs[i] + "\\\\" + newFileName;
+ newFileName = dirs[i] + "\\" + newFileName;
}
return newFileName;
exit(1);
}
}
+/***********************************************************************/
+int MothurOut::openInputFileBinary(string fileName, ifstream& fileHandle){
+ try {
+
+ //get full path name
+ string completeFileName = getFullPathName(fileName);
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
+#ifdef USE_COMPRESSION
+ // check for gzipped or bzipped file
+ if (endsWith(completeFileName, ".gz") || endsWith(completeFileName, ".bz2")) {
+ string tempName = string(tmpnam(0));
+ mkfifo(tempName.c_str(), 0666);
+ int fork_result = fork();
+ if (fork_result < 0) {
+ cerr << "Error forking.\n";
+ exit(1);
+ } else if (fork_result == 0) {
+ string command = (endsWith(completeFileName, ".gz") ? "zcat " : "bzcat ") + completeFileName + string(" > ") + tempName;
+ cerr << "Decompressing " << completeFileName << " via temporary named pipe " << tempName << "\n";
+ system(command.c_str());
+ cerr << "Done decompressing " << completeFileName << "\n";
+ mothurRemove(tempName);
+ exit(EXIT_SUCCESS);
+ } else {
+ cerr << "waiting on child process " << fork_result << "\n";
+ completeFileName = tempName;
+ }
+ }
+#endif
+#endif
+
+ fileHandle.open(completeFileName.c_str(), ios::binary);
+ if(!fileHandle) {
+ mothurOut("[ERROR]: Could not open " + completeFileName); mothurOutEndLine();
+ return 1;
+ }
+ else {
+ //check for blank file
+ gobble(fileHandle);
+ if (fileHandle.eof()) { mothurOut("[ERROR]: " + completeFileName + " is blank. Please correct."); mothurOutEndLine(); }
+
+ return 0;
+ }
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "openInputFileBinary");
+ exit(1);
+ }
+}
+/***********************************************************************/
+int MothurOut::openInputFileBinary(string fileName, ifstream& fileHandle, string noerror){
+ try {
+
+ //get full path name
+ string completeFileName = getFullPathName(fileName);
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
+#ifdef USE_COMPRESSION
+ // check for gzipped or bzipped file
+ if (endsWith(completeFileName, ".gz") || endsWith(completeFileName, ".bz2")) {
+ string tempName = string(tmpnam(0));
+ mkfifo(tempName.c_str(), 0666);
+ int fork_result = fork();
+ if (fork_result < 0) {
+ cerr << "Error forking.\n";
+ exit(1);
+ } else if (fork_result == 0) {
+ string command = (endsWith(completeFileName, ".gz") ? "zcat " : "bzcat ") + completeFileName + string(" > ") + tempName;
+ cerr << "Decompressing " << completeFileName << " via temporary named pipe " << tempName << "\n";
+ system(command.c_str());
+ cerr << "Done decompressing " << completeFileName << "\n";
+ mothurRemove(tempName);
+ exit(EXIT_SUCCESS);
+ } else {
+ cerr << "waiting on child process " << fork_result << "\n";
+ completeFileName = tempName;
+ }
+ }
+#endif
+#endif
+
+ fileHandle.open(completeFileName.c_str(), ios::binary);
+ if(!fileHandle) {
+ //mothurOut("[ERROR]: Could not open " + completeFileName); mothurOutEndLine();
+ return 1;
+ }
+ else {
+ //check for blank file
+ gobble(fileHandle);
+ //if (fileHandle.eof()) { mothurOut("[ERROR]: " + completeFileName + " is blank. Please correct."); mothurOutEndLine(); }
+
+ return 0;
+ }
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "openInputFileBinary - no error");
+ exit(1);
+ }
+}
+
/***********************************************************************/
int MothurOut::renameFile(string oldName, string newName){
}
}
+/***********************************************************************/
+int MothurOut::openOutputFileBinary(string fileName, ofstream& fileHandle){
+ try {
+
+ string completeFileName = getFullPathName(fileName);
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
+#ifdef USE_COMPRESSION
+ // check for gzipped file
+ if (endsWith(completeFileName, ".gz") || endsWith(completeFileName, ".bz2")) {
+ string tempName = string(tmpnam(0));
+ mkfifo(tempName.c_str(), 0666);
+ cerr << "Compressing " << completeFileName << " via temporary named pipe " << tempName << "\n";
+ int fork_result = fork();
+ if (fork_result < 0) {
+ cerr << "Error forking.\n";
+ exit(1);
+ } else if (fork_result == 0) {
+ string command = string(endsWith(completeFileName, ".gz") ? "gzip" : "bzip2") + " -v > " + completeFileName + string(" < ") + tempName;
+ system(command.c_str());
+ exit(0);
+ } else {
+ completeFileName = tempName;
+ }
+ }
+#endif
+#endif
+ fileHandle.open(completeFileName.c_str(), ios::trunc | ios::binary);
+ if(!fileHandle) {
+ mothurOut("[ERROR]: Could not open " + completeFileName); mothurOutEndLine();
+ return 1;
+ }
+ else {
+ return 0;
+ }
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "openOutputFileBinary");
+ exit(1);
+ }
+
+}
/**************************************************************************************************/
int MothurOut::appendFiles(string temp, string filename) {
try{
ifstream input;
//open output file in append mode
- openOutputFileAppend(filename, output);
- int ableToOpen = openInputFile(temp, input, "no error");
+ openOutputFileBinaryAppend(filename, output);
+ int ableToOpen = openInputFileBinary(temp, input, "no error");
//int ableToOpen = openInputFile(temp, input);
int numLines = 0;
exit(1);
}
}
+/**************************************************************************************************/
+int MothurOut::appendBinaryFiles(string temp, string filename) {
+ try{
+ ofstream output;
+ ifstream input;
+
+ //open output file in append mode
+ openOutputFileBinaryAppend(filename, output);
+ int ableToOpen = openInputFileBinary(temp, input, "no error");
+
+ if (ableToOpen == 0) { //you opened it
+
+ char buffer[4096];
+ while (!input.eof()) {
+ input.read(buffer, 4096);
+ output.write(buffer, input.gcount());
+ }
+ input.close();
+ }
+
+ output.close();
+
+ return ableToOpen;
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "appendBinaryFiles");
+ exit(1);
+ }
+}
+/**************************************************************************************************/
+int MothurOut::appendFilesWithoutHeaders(string temp, string filename) {
+ try{
+ ofstream output;
+ ifstream input;
+
+ //open output file in append mode
+ openOutputFileAppend(filename, output);
+ int ableToOpen = openInputFile(temp, input, "no error");
+ //int ableToOpen = openInputFile(temp, input);
+
+ int numLines = 0;
+ if (ableToOpen == 0) { //you opened it
+
+ string headers = getline(input); gobble(input);
+ if (debug) { mothurOut("[DEBUG]: skipping headers " + headers +'\n'); }
+
+ char buffer[4096];
+ while (!input.eof()) {
+ input.read(buffer, 4096);
+ output.write(buffer, input.gcount());
+ //count number of lines
+ for (int i = 0; i < input.gcount(); i++) { if (buffer[i] == '\n') {numLines++;} }
+ }
+ input.close();
+ }
+
+ output.close();
+
+ return numLines;
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "appendFiles");
+ exit(1);
+ }
+}
/**************************************************************************************************/
string MothurOut::sortFile(string distFile, string outputDir){
try {
char c = inFASTA.get(); count++;
if (c == '>') {
positions.push_back(count-1);
- //cout << count << endl;
+ if (debug) { mothurOut("[DEBUG]: numSeqs = " + toString(positions.size()) + " count = " + toString(count) + ".\n"); }
}
}
inFASTA.close();
num = positions.size();
-
- /*FILE * pFile;
- long size;
+ if (debug) { mothurOut("[DEBUG]: num = " + toString(num) + ".\n"); }
+ FILE * pFile;
+ unsigned long long size;
//get num bytes in file
pFile = fopen (filename.c_str(),"rb");
fseek (pFile, 0, SEEK_END);
size=ftell (pFile);
fclose (pFile);
- }*/
+ }
- unsigned long long size = positions[(positions.size()-1)];
+ /*unsigned long long size = positions[(positions.size()-1)];
ifstream in;
openInputFile(filename, in);
if(in.eof()) { break; }
else { size++; }
}
- in.close();
-
+ in.close();*/
+
+ if (debug) { mothurOut("[DEBUG]: size = " + toString(size) + ".\n"); }
+
positions.push_back(size);
positions[0] = 0;
exit(1);
}
}
+//**********************************************************************************************************************
+vector<consTax> MothurOut::readConsTax(string inputfile){
+ try {
+
+ vector<consTax> taxes;
+
+ ifstream in;
+ openInputFile(inputfile, in);
+
+ //read headers
+ getline(in);
+
+ while (!in.eof()) {
+
+ if (control_pressed) { break; }
+
+ string otu = ""; string tax = "unknown";
+ int size = 0;
+
+ in >> otu >> size >> tax; gobble(in);
+ consTax temp(otu, tax, size);
+ taxes.push_back(temp);
+ }
+ in.close();
+
+ return taxes;
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "readConsTax");
+ exit(1);
+ }
+}
+//**********************************************************************************************************************
+int MothurOut::readConsTax(string inputfile, map<string, consTax2>& taxes){
+ try {
+ ifstream in;
+ openInputFile(inputfile, in);
+
+ //read headers
+ getline(in);
+
+ while (!in.eof()) {
+
+ if (control_pressed) { break; }
+
+ string otu = ""; string tax = "unknown";
+ int size = 0;
+
+ in >> otu >> size >> tax; gobble(in);
+ consTax2 temp(tax, size);
+ taxes[otu] = temp;
+ }
+ in.close();
+
+ return 0;
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "readConsTax");
+ exit(1);
+ }
+}
/**************************************************************************************************/
vector<unsigned long long> MothurOut::setFilePosEachLine(string filename, int& num) {
try {
}
}
/**************************************************************************************************/
+
+vector<unsigned long long> MothurOut::divideFilePerLine(string filename, int& proc) {
+ try{
+ vector<unsigned long long> filePos;
+ filePos.push_back(0);
+
+ FILE * pFile;
+ unsigned long long size;
+
+ filename = getFullPathName(filename);
+
+ //get num bytes in file
+ pFile = fopen (filename.c_str(),"rb");
+ if (pFile==NULL) perror ("Error opening file");
+ else{
+ fseek (pFile, 0, SEEK_END);
+ size=ftell (pFile);
+ fclose (pFile);
+ }
+
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
+
+ //estimate file breaks
+ unsigned long long chunkSize = 0;
+ chunkSize = size / proc;
+
+ //file to small to divide by processors
+ if (chunkSize == 0) { proc = 1; filePos.push_back(size); return filePos; }
+
+ //for each process seekg to closest file break and search for next '>' char. make that the filebreak
+ for (int i = 0; i < proc; i++) {
+ unsigned long long spot = (i+1) * chunkSize;
+
+ ifstream in;
+ openInputFile(filename, in);
+ in.seekg(spot);
+
+ //look for next line break
+ unsigned long long newSpot = spot;
+ while (!in.eof()) {
+ char c = in.get();
+
+ if ((c == '\n') || (c == '\r') || (c == '\f')) { gobble(in); newSpot = in.tellg(); break; }
+ else if (int(c) == -1) { break; }
+ }
+
+ //there was not another line before the end of the file
+ unsigned long long sanityPos = in.tellg();
+
+ if (sanityPos == -1) { break; }
+ else { filePos.push_back(newSpot); }
+
+ in.close();
+ }
+
+ //save end pos
+ filePos.push_back(size);
+
+ //sanity check filePos
+ for (int i = 0; i < (filePos.size()-1); i++) {
+ if (filePos[(i+1)] <= filePos[i]) { filePos.erase(filePos.begin()+(i+1)); i--; }
+ }
+
+ proc = (filePos.size() - 1);
+#else
+ mothurOut("[ERROR]: Windows version should not be calling the divideFile function."); mothurOutEndLine();
+ proc=1;
+ filePos.push_back(size);
+#endif
+ return filePos;
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "divideFile");
+ exit(1);
+ }
+}
+/**************************************************************************************************/
int MothurOut::divideFile(string filename, int& proc, vector<string>& files) {
try{
bool pairDone = false;
bool columnOne = true;
string firstCol, secondCol;
+ bool error = false;
while (!in.eof()) {
if (control_pressed) { break; }
if (!ignore) { taxMap[firstCol] = secondCol; }
if (debug) { mothurOut("[DEBUG]: name = '" + firstCol + "' tax = '" + secondCol + "'\n"); }
}else {
- mothurOut("[ERROR]: " + firstCol + " is already in your taxonomy file, names must be unique./n"); control_pressed = true;
+ mothurOut("[ERROR]: " + firstCol + " is already in your taxonomy file, names must be unique.\n"); error = true;
}
pairDone = false;
}
if (!ignore) { taxMap[firstCol] = secondCol; }
if (debug) { mothurOut("[DEBUG]: name = '" + firstCol + "' tax = '" + secondCol + "'\n"); }
}else {
- mothurOut("[ERROR]: " + firstCol + " is already in your taxonomy file, names must be unique./n"); control_pressed = true;
+ mothurOut("[ERROR]: " + firstCol + " is already in your taxonomy file, names must be unique./n"); error = true;
}
pairDone = false;
}
}
+ if (error) { control_pressed = true; }
+ if (debug) { mothurOut("[DEBUG]: numSeqs saved = '" + toString(taxMap.size()) + "'\n"); }
return taxMap.size();
}
/************************************************************/
int MothurOut::checkName(string& name) {
try {
- for (int i = 0; i < name.length(); i++) {
- if (name[i] == ':') { name[i] = '_'; changedSeqNames = true; }
- }
+ if (modifyNames) {
+ for (int i = 0; i < name.length(); i++) {
+ if (name[i] == ':') { name[i] = '_'; changedSeqNames = true; }
+ }
+ }
return 0;
}
catch(exception& e) {
in.read(buffer, 4096);
vector<string> pieces = splitWhiteSpace(rest, buffer, in.gcount());
- for (int i = 0; i < pieces.size(); i++) { checkName(pieces[i]); names.insert(pieces[i]); }
+ for (int i = 0; i < pieces.size(); i++) { checkName(pieces[i]);
+ names.insert(pieces[i]);
+ }
}
in.close();
exit(1);
}
}
+/***********************************************************************/
+string MothurOut::getSimpleLabel(string label){
+ try {
+ string simple = "";
+
+ //remove OTU or phylo tag
+ string newLabel1 = "";
+ for (int i = 0; i < label.length(); i++) {
+ if(label[i]>47 && label[i]<58) { //is a digit
+ newLabel1 += label[i];
+ }
+ }
+
+ int num1;
+ mothurConvert(newLabel1, num1);
+
+ simple = toString(num1);
+
+ return simple;
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "isLabelEquivalent");
+ exit(1);
+ }
+}
+/***********************************************************************/
+string MothurOut::mothurGetpid(int threadID){
+ try {
+
+ string pid = "";
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
+
+ pid += toString(getpid()); if(debug) { mothurOut("[DEBUG]: " + pid + "\n"); }
+ //remove any weird chars
+ string pid1 = "";
+ for (int i = 0; i < pid.length(); i++) {
+ if(pid[i]>47 && pid[i]<58) { //is a digit
+ pid1 += pid[i];
+ }
+ }
+ pid = pid1;
+#else
+ pid += toString(threadID);
+#endif
+ return pid;
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "mothurGetpid");
+ exit(1);
+ }
+}
+
+/***********************************************************************/
+
+bool MothurOut::isLabelEquivalent(string label1, string label2){
+ try {
+ bool same = false;
+
+ //remove OTU or phylo tag
+ string newLabel1 = "";
+ for (int i = 0; i < label1.length(); i++) {
+ if(label1[i]>47 && label1[i]<58) { //is a digit
+ newLabel1 += label1[i];
+ }
+ }
+
+ string newLabel2 = "";
+ for (int i = 0; i < label2.length(); i++) {
+ if(label2[i]>47 && label2[i]<58) { //is a digit
+ newLabel2 += label2[i];
+ }
+ }
+
+ int num1, num2;
+ mothurConvert(newLabel1, num1);
+ mothurConvert(newLabel2, num2);
+
+ if (num1 == num2) { same = true; }
+
+ return same;
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "isLabelEquivalent");
+ exit(1);
+ }
+}
//**********************************************************************************************************************
bool MothurOut::isSubset(vector<string> bigset, vector<string> subset) {
try {
if (subset.size() > bigset.size()) { return false; }
- //check if each guy in suset is also in bigset
+ //check if each guy in subset is also in bigset
for (int i = 0; i < subset.size(); i++) {
bool match = false;
for (int j = 0; j < bigset.size(); j++) {
}
}
/***********************************************************************/
-
+string MothurOut::findEdianness() {
+ try {
+ // find real endian type
+ unsigned char EndianTest[2] = {1,0};
+ short x = *(short *)EndianTest;
+
+ string endianType = "unknown";
+ if(x == 1) { endianType = "BIG_ENDIAN"; }
+ else { endianType = "LITTLE_ENDIAN"; }
+
+ return endianType;
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "findEdianness");
+ exit(1);
+ }
+}
+/***********************************************************************/
+double MothurOut::median(vector<double> x) {
+ try {
+ double value = 0.0;
+
+ if (x.size() == 0) { } //error
+ else {
+ //For example, if a < b < c, then the median of the list {a, b, c} is b, and, if a < b < c < d, then the median of the list {a, b, c, d} is the mean of b and c; i.e., it is (b + c)/2.
+ sort(x.begin(), x.end());
+ //is x.size even?
+ if ((x.size()%2) == 0) { //size() is even. median = average of 2 midpoints
+ int midIndex1 = (x.size()/2)-1;
+ int midIndex2 = (x.size()/2);
+ value = (x[midIndex1]+ x[midIndex2]) / 2.0;
+ }else {
+ int midIndex = (x.size()/2);
+ value = x[midIndex];
+ }
+ }
+ return value;
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "median");
+ exit(1);
+ }
+}
+/***********************************************************************/
int MothurOut::factorial(int num){
try {
int total = 1;
}
}
/***********************************************************************/
+bool MothurOut::checkLocations(string& filename, string inputDir){
+ try {
+ filename = getFullPathName(filename);
+
+ int ableToOpen;
+ ifstream in;
+ ableToOpen = openInputFile(filename, in, "noerror");
+ in.close();
+
+ //if you can't open it, try input location
+ if (ableToOpen == 1) {
+ if (inputDir != "") { //default path is set
+ string tryPath = inputDir + getSimpleName(filename);
+ mothurOut("Unable to open " + filename + ". Trying input directory " + tryPath); mothurOutEndLine();
+ ifstream in2;
+ ableToOpen = openInputFile(tryPath, in2, "noerror");
+ in2.close();
+ filename = tryPath;
+ }
+ }
+
+ //if you can't open it, try default location
+ if (ableToOpen == 1) {
+ if (getDefaultPath() != "") { //default path is set
+ string tryPath = getDefaultPath() + getSimpleName(filename);
+ mothurOut("Unable to open " + filename + ". Trying default " + tryPath); mothurOutEndLine();
+ ifstream in2;
+ ableToOpen = openInputFile(tryPath, in2, "noerror");
+ in2.close();
+ filename = tryPath;
+ }
+ }
+
+ //if you can't open it its not in current working directory or inputDir, try mothur excutable location
+ if (ableToOpen == 1) {
+ string exepath = argv;
+ string tempPath = exepath;
+ for (int i = 0; i < exepath.length(); i++) { tempPath[i] = tolower(exepath[i]); }
+ exepath = exepath.substr(0, (tempPath.find_last_of('m')));
+
+ string tryPath = getFullPathName(exepath) + getSimpleName(filename);
+ mothurOut("Unable to open " + filename + ". Trying mothur's executable location " + tryPath); mothurOutEndLine();
+ ifstream in2;
+ ableToOpen = openInputFile(tryPath, in2, "noerror");
+ in2.close();
+ filename = tryPath;
+ }
+
+ if (ableToOpen == 1) { mothurOut("Unable to open " + filename + "."); mothurOutEndLine(); return false; }
+
+ return true;
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "checkLocations");
+ exit(1);
+ }
+}
+/***********************************************************************/
//This function parses the estimator options and puts them in a vector
void MothurOut::splitAtChar(string& estim, vector<string>& container, char symbol) {
string individual = "";
int estimLength = estim.size();
bool prevEscape = false;
- for(int i=0;i<estimLength;i++){
+ /*for(int i=0;i<estimLength;i++){
if(prevEscape){
individual += estim[i];
prevEscape = false;
prevEscape = false;
}
}
- }
+ }*/
+
+
+ for(int i=0;i<estimLength;i++){
+ if(estim[i] == '-'){
+ if (prevEscape) { individual += estim[i]; prevEscape = false; } //add in dash because it was escaped.
+ else {
+ container.push_back(individual);
+ individual = "";
+ }
+ }else if(estim[i] == '\\'){
+ if (i < estimLength-1) {
+ if (estim[i+1] == '-') { prevEscape=true; } //are you a backslash before a dash, if yes ignore
+ else { individual += estim[i]; prevEscape = false; } //if no, add in
+ }else { individual += estim[i]; }
+ }else {
+ individual += estim[i];
+ }
+ }
+
+
+
container.push_back(individual);
}
catch(exception& e) {
string individual = "";
int estimLength = estim.size();
bool prevEscape = false;
+ /*
for(int i=0;i<estimLength;i++){
if(prevEscape){
individual += estim[i];
}
}
}
- container.insert(individual);
+ */
+
+ for(int i=0;i<estimLength;i++){
+ if(estim[i] == '-'){
+ if (prevEscape) { individual += estim[i]; prevEscape = false; } //add in dash because it was escaped.
+ else {
+ container.insert(individual);
+ individual = "";
+ }
+ }else if(estim[i] == '\\'){
+ if (i < estimLength-1) {
+ if (estim[i+1] == '-') { prevEscape=true; } //are you a backslash before a dash, if yes ignore
+ else { individual += estim[i]; prevEscape = false; } //if no, add in
+ }else { individual += estim[i]; }
+ }else {
+ individual += estim[i];
+ }
+ }
+ container.insert(individual);
}
catch(exception& e) {
int lineNum;
int estimLength = estim.size();
bool prevEscape = false;
+ /*
for(int i=0;i<estimLength;i++){
if(prevEscape){
individual += estim[i];
prevEscape = false;
}
}
- }
+ }*/
+
+ for(int i=0;i<estimLength;i++){
+ if(estim[i] == '-'){
+ if (prevEscape) { individual += estim[i]; prevEscape = false; } //add in dash because it was escaped.
+ else {
+ convert(individual, lineNum); //convert the string to int
+ container.insert(lineNum);
+ individual = "";
+ }
+ }else if(estim[i] == '\\'){
+ if (i < estimLength-1) {
+ if (estim[i+1] == '-') { prevEscape=true; } //are you a backslash before a dash, if yes ignore
+ else { individual += estim[i]; prevEscape = false; } //if no, add in
+ }else { individual += estim[i]; }
+ }else {
+ individual += estim[i];
+ }
+ }
+
convert(individual, lineNum); //convert the string to int
container.insert(lineNum);
}
exit(1);
}
}
+
/***********************************************************************/
string MothurOut::makeList(vector<string>& names) {
try {
string space = " ";
while(suffix.at(0) == ' ')
suffix = suffix.substr(1, suffix.length());
- }
+ }else { suffix = ""; }
- }
+ }
catch(exception& e) {
- errorOut(e, "MothurOut", "splitAtComma");
+ errorOut(e, "MothurOut", "splitAtChar");
exit(1);
}
}
string space = " ";
while(suffix.at(0) == ' ')
suffix = suffix.substr(1, suffix.length());
- }
+ }else { suffix = ""; }
}
catch(exception& e) {
exit(1);
}
}
+/**************************************************************************************************/
+//removes entries that are only white space
+int MothurOut::removeBlanks(vector<string>& tempVector) {
+ try {
+ vector<string> newVector;
+ for (int i = 0; i < tempVector.size(); i++) {
+ bool isBlank = true;
+ for (int j = 0; j < tempVector[i].length(); j++) {
+ if (!isspace(tempVector[i][j])) { isBlank = false; j+= tempVector[i].length(); } //contains non space chars, break out and save
+ }
+ if (!isBlank) { newVector.push_back(tempVector[i]); }
+ }
+ tempVector = newVector;
+ return 0;
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "removeBlanks");
+ exit(1);
+ }
+}
/***********************************************************************/
//this function determines if the user has given us labels that are smaller than the given label.
//if so then it returns true so that the calling function can run the previous valid distance.
exit(1);
}
}
+/**************************************************************************************************/
+double MothurOut::getAverage(vector<double> dists) {
+ try{
+ double average = 0;
+
+ for (int i = 0; i < dists.size(); i++) {
+ average += dists[i];
+ }
+
+ //finds average.
+ average /= (double) dists.size();
+
+ return average;
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "getAverage");
+ exit(1);
+ }
+}
+
/**************************************************************************************************/
vector<double> MothurOut::getStandardDeviation(vector< vector<double> >& dists) {
try{
return stdDev;
}
catch(exception& e) {
- errorOut(e, "MothurOut", "getAverages");
+ errorOut(e, "MothurOut", "getStandardDeviation");
exit(1);
}
}
}
}
/**************************************************************************************************/
+// returns largest value in vector
+double MothurOut::max(vector<double>& featureVector){
+ try {
+ if (featureVector.size() == 0) { mothurOut("[ERROR]: vector size = 0!\n"); control_pressed=true; return 0.0; }
+
+ //finds largest
+ double largest = featureVector[0];
+ for (int i = 1; i < featureVector.size(); i++) {
+ if (featureVector[i] > largest) { largest = featureVector[i]; }
+ }
+
+ return largest;
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "max");
+ exit(1);
+ }
+}
+/**************************************************************************************************/
+// returns smallest value in vector
+double MothurOut::min(vector<double>& featureVector){
+ try {
+ if (featureVector.size() == 0) { mothurOut("[ERROR]: vector size = 0!\n"); control_pressed=true; return 0.0; }
+
+ //finds smallest
+ double smallest = featureVector[0];
+ for (int i = 1; i < featureVector.size(); i++) {
+ if (featureVector[i] < smallest) { smallest = featureVector[i]; }
+ }
+
+ return smallest;
+ }
+ catch(exception& e) {
+ errorOut(e, "MothurOut", "min");
+ exit(1);
+ }
+}
+
+/**************************************************************************************************/
projects / mothur.git / blobdiff