changes for 1.11

diff --git a/decalc.cpp b/decalc.cpp
index 4e80c65d29aa7c8d6a2354db95027c3365c7962d..2e214bffe969181c9f83061edc69a491610fe8a8 100644 (file)
--- a/decalc.cpp
+++ b/decalc.cpp
@@ -381,9 +381,9 @@ vector<float>  DeCalculator::findQav(vector<int> window, int size, vector<float>
 }
 //***************************************************************************************************************
 //seqs have already been masked
-vector< vector<quanMember> > DeCalculator::getQuantiles(vector<Sequence*> seqs, vector<int> windowSizesTemplate, int window, vector<float> probProfile, int increment, int start, int end) {
+vector< vector<float> > DeCalculator::getQuantiles(vector<Sequence*> seqs, vector<int> windowSizesTemplate, int window, vector<float> probProfile, int increment, int start, int end) {
        try {
-               vector< vector<quanMember> > quan; 
+               vector< vector<float> > quan; 
                
                //percentage of mismatched pairs 1 to 100
                quan.resize(100);
@@ -428,9 +428,9 @@ vector< vector<quanMember> > DeCalculator::getQuantiles(vector<Sequence*> seqs,
        //cout << i << '\t' <<  j << '\t' << dist << '\t' << de << endl;                        
                                dist = ceil(dist);
                                
-                               quanMember newScore(de, i, j);
+                               //quanMember newScore(de, i, j);
                                
-                               quan[dist].push_back(newScore);
+                               quan[dist].push_back(de);
 
                                delete subject;
                        }
@@ -454,23 +454,23 @@ inline bool compareQuanMembers(quanMember left, quanMember right){
 } 
 //***************************************************************************************************************
 //this was going to be used by pintail to increase the sensitivity of the chimera detection, but it wasn't quite right.  may want to revisit in the future...
-void DeCalculator::removeObviousOutliers(vector< vector<quanMember> >& quantiles, int num) {
+void DeCalculator::removeObviousOutliers(vector< vector<float> >& quantiles, int num) {
        try {
                                                
                for (int i = 0; i < quantiles.size(); i++) {
                        
                        //find mean of this quantile score
-                       sort(quantiles[i].begin(), quantiles[i].end(), compareQuanMembers);
+                       sort(quantiles[i].begin(), quantiles[i].end());
                        
-                       vector<quanMember> temp;
+                       vector<float> temp;
                        if (quantiles[i].size() != 0) {
-                               float high = quantiles[i][int(quantiles[i].size() * 0.99)].score;
-                               float low =  quantiles[i][int(quantiles[i].size() * 0.01)].score;
+                               float high = quantiles[i][int(quantiles[i].size() * 0.99)];
+                               float low =  quantiles[i][int(quantiles[i].size() * 0.01)];
                        
                                //look at each value in quantiles to see if it is an outlier
                                for (int j = 0; j < quantiles[i].size(); j++) {
                                        //is this score between 1 and 99%
-                                       if ((quantiles[i][j].score > low) && (quantiles[i][j].score < high)) {
+                                       if ((quantiles[i][j] > low) && (quantiles[i][j] < high)) {
                                                temp.push_back(quantiles[i][j]);
                                        }
                                }

diff --git a/decalc.h b/decalc.h
index da663e80f786d1a98b646fe856bbe32522dd2c42..2d0d529dfb7136e22894ecc46a0f36be01eef353 100644 (file)
--- a/decalc.h
+++ b/decalc.h
@@ -47,7 +47,7 @@ class DeCalculator {
                void runMask(Sequence*);
                void trimSeqs(Sequence*, Sequence*, map<int, int>&);
                map<int, int> trimSeqs(Sequence*, vector<Sequence*>);
-               void removeObviousOutliers(vector< vector<quanMember> >&, int);
+               void removeObviousOutliers(vector< vector<float> >&, int);
                vector<float> calcFreq(vector<Sequence*>, string);
                vector<int> findWindows(Sequence*, int, int, int&, int);
                vector<float> calcObserved(Sequence*, Sequence*, vector<int>, int);
@@ -56,7 +56,7 @@ class DeCalculator {
                float calcDE(vector<float>, vector<float>);
                float calcDist(Sequence*, Sequence*, int, int);
                float getCoef(vector<float>, vector<float>);
-               vector< vector<quanMember> > getQuantiles(vector<Sequence*>, vector<int>, int, vector<float>, int, int, int);
+               vector< vector<float> > getQuantiles(vector<Sequence*>, vector<int>, int, vector<float>, int, int, int);
                
                vector<int> returnObviousOutliers(vector< vector<quanMember> >, int);
                

diff --git a/mothur.cpp b/mothur.cpp
index 0249f6518cc08b7c902f598365739fc2bdeb032f..d5f838745a3f65b13e1d9dcb40c0829f3bb1fc7c 100644 (file)
--- a/mothur.cpp
+++ b/mothur.cpp
@@ -73,9 +73,9 @@ int main(int argc, char *argv[]){
                #endif\r
                \r
                //header\r
-               m->mothurOut("mothur v.1.10.2");\r
+               m->mothurOut("mothur v.1.11.0");\r
                m->mothurOutEndLine();          \r
-               m->mothurOut("Last updated: 5/26/2010");\r
+               m->mothurOut("Last updated: 6/18/2010");\r
                m->mothurOutEndLine();  \r
                m->mothurOutEndLine();          \r
                m->mothurOut("by");\r

diff --git a/pintail.cpp b/pintail.cpp
index 0050a43f0d926094b0d9f969a21e6c2c306ab1f6..5bfdc44128dd300cc22a33e8fa696d032dcab774 100644 (file)
--- a/pintail.cpp
+++ b/pintail.cpp
@@ -196,20 +196,20 @@ int Pintail::doPrep() {
                                        }
                                }else{
                                        
-                                       sort(quantilesMembers[i].begin(), quantilesMembers[i].end(), compareQuanMembers);
+                                       sort(quantilesMembers[i].begin(), quantilesMembers[i].end());
                                        
                                        //save 10%
-                                       temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.10)].score);
+                                       temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.10)]);
                                        //save 25%
-                                       temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.25)].score);
+                                       temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.25)]);
                                        //save 50%
-                                       temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.5)].score);
+                                       temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.5)]);
                                        //save 75%
-                                       temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.75)].score);
+                                       temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.75)]);
                                        //save 95%
-                                       temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.95)].score);
+                                       temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.95)]);
                                        //save 99%
-                                       temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.99)].score);
+                                       temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.99)]);
                                        
                                }
                                
@@ -224,6 +224,9 @@ int Pintail::doPrep() {
                        
                        printQuanFile(noOutliers, outputString);
                        
+                       //free memory
+                       quantilesMembers.clear();
+                       
                        m->mothurOut("Done."); m->mothurOutEndLine();
                }
                
@@ -544,7 +547,7 @@ void Pintail::createProcessesQuan() {
                                for (int i = 0; i < quantilesMembers.size(); i++) {
                                        out << quantilesMembers[i].size() << '\t';
                                        for (int j = 0; j < quantilesMembers[i].size(); j++) {
-                                               out << quantilesMembers[i][j].score << '\t' << quantilesMembers[i][j].member1 << '\t' << quantilesMembers[i][j].member2 << '\t';
+                                               out << quantilesMembers[i][j] << '\t';
                                        }
                                        out << endl;
                                }
@@ -567,25 +570,23 @@ void Pintail::createProcessesQuan() {
                        string s = toString(processIDS[i]) + ".temp";
                        openInputFile(s, in);
                        
-                       vector< vector<quanMember> > quan; 
+                       vector< vector<float> > quan; 
                        quan.resize(100);
                        
                        //get quantiles
-                       for (int m = 0; m < quan.size(); m++) {
+                       for (int h = 0; h < quan.size(); h++) {
                                int num;
                                in >> num; 
                                
                                gobble(in);
 
-                               vector<quanMember> q;  float w; int b, n;
+                               vector<float> q;  float w; 
                                for (int j = 0; j < num; j++) {
-                                       in >> w >> b >> n;
-       
-                                       quanMember newMember(w, b, n);
-                                       q.push_back(newMember);
+                                       in >> w;
+                                       q.push_back(w);
                                }
 
-                               quan[m] = q;
+                               quan[h] = q;
                                gobble(in);
                        }
                        

diff --git a/pintail.h b/pintail.h
index 7164842106d7b61d36883b351167163aeb4e878a..3da52459e58959457b0a491ce29bfa4f856f1df3 100644 (file)
--- a/pintail.h
+++ b/pintail.h
@@ -66,7 +66,7 @@ class Pintail : public Chimera {
                float DE;                       //DE is the deviaation for query
                vector<float> probabilityProfile;
                vector< vector<float> > quantiles;  //quantiles[0] is the vector of deviations with ceiling score of 1, quantiles[1] is the vector of deviations with ceiling score of 2...
-               vector< vector<quanMember> > quantilesMembers;  //quantiles[0] is the vector of deviations with ceiling score of 1, quantiles[1] is the vector of deviations with ceiling score of 2...
+               vector< vector<float> > quantilesMembers;  //quantiles[0] is the vector of deviations with ceiling score of 1, quantiles[1] is the vector of deviations with ceiling score of 2...
                set<int>  h;
                string mergedFilterString;