X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=mothurout.cpp;h=66ee704dd59d0221d1a0a7a40de65ecf42d762b2;hb=2ff2d03fbe46ce8cf2738bff4403a52be4f31e2f;hp=bfd1cc1da84a5140869c6766fc1f3de8dc02bf0b;hpb=4283eb0248ca6e7e3e3344647f16166da0e14147;p=mothur.git

diff --git a/mothurout.cpp b/mothurout.cpp
index bfd1cc1..66ee704 100644
--- a/mothurout.cpp
+++ b/mothurout.cpp
@@ -2599,6 +2599,65 @@ int MothurOut::getNumChar(string line, char c){
 		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 {
@@ -2864,7 +2923,50 @@ unsigned int MothurOut::fromBase36(string base36){
 	}
 }
 /***********************************************************************/
-
+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;
@@ -2911,6 +3013,64 @@ void MothurOut::getNumSeqs(ifstream& file, int& numSeqs){
 	}	
 }
 /***********************************************************************/
+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) {
@@ -3499,7 +3659,7 @@ vector<double> MothurOut::getStandardDeviation(vector< vector<double> >& dists,
         return stdDev;
     }
 	catch(exception& e) {
-		errorOut(e, "MothurOut", "getAverages");		
+		errorOut(e, "MothurOut", "getStandardDeviation");		
 		exit(1);
 	}
 }
@@ -3782,6 +3942,44 @@ double MothurOut::getStandardDeviation(vector<int>& featureVector){
 	}
 }
 /**************************************************************************************************/
+// 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);
+	}
+}
+/**************************************************************************************************/