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) {
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){
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{
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);
+ }
+}
+/***********************************************************************/
+
+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 {
}
}
/***********************************************************************/
-
+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) {
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