libshuff and updated help to include libshuff and modifications to read.dist.

[mothur.git] / coverage.cpp

diff --git a/coverage.cpp b/coverage.cpp
index e7baf001fefe4d5de552c1cd6362eaa2b1333d2c..cd8138d7dd6216e31f0617a45cb7b0bd63d5dbb5 100644 (file)
--- a/coverage.cpp
+++ b/coverage.cpp
@@ -10,21 +10,83 @@
 #include "coverage.h"
 
 //**********************************************************************************************************************
-vector< vector<float> > Coverage::getValues(FullMatrix*, float) {
-       try {
+Coverage::Coverage() {
                globaldata = GlobalData::getInstance();
-               numGroups = globaldata->Groups.size();
+               numUserGroups = globaldata->Groups.size();
+               numGroups = globaldata->gGroupmap->getNumGroups();
+}
+
+//**********************************************************************************************************************
+void Coverage::getValues(FullMatrix* matrix, vector< vector< vector<float> > >& data, vector<float> dist, string mode) {
+       try {
+               vector<float> min;
+               vector<string> groups;
                
                //initialize data
-               data.resize(numGroups);
+               data.resize(dist.size());
                for (int l = 0; l < data.size(); l++) {
-                       data[l].push_back(0.0);
+                       data[l].resize(numGroups);
+                       for (int k = 0; k < data[l].size(); k++) {
+                               data[l][k].push_back(0.0);
+                       }
                }
 
                /**************************************/
-               //get the minumums for each comparision
+               //get the minimums for each comparision
                /**************************************/
-               return data;
+               int count = 0;
+               int a = 0;
+               int b = 0;
+               for (int i = 0; i < numGroups; i++) {
+                       for (int j = 0; j < numGroups; j++) {
+                       
+                               //is this "box" one hte user wants analyzed?
+                               if ((inUsersGroups(globaldata->gGroupmap->namesOfGroups[i], globaldata->Groups) == true) && (inUsersGroups(globaldata->gGroupmap->namesOfGroups[j], globaldata->Groups) == true)) {
+                                       
+                                       if (mode == "random") {
+                                               //create random matrix for this comparison
+                                               matrix->shuffle(globaldata->gGroupmap->namesOfGroups[i], globaldata->gGroupmap->namesOfGroups[j]);
+                                       }
+                       
+                                       min = matrix->getMins(count);  //returns vector of mins for "box" requested ie. groups A, B, 0 = AA, 1 = AB, 2 = BA, 3 = BB;
+
+                                       //find the coverage at this distance
+                                       sort(min.begin(), min.end());
+                                       
+                                       //loop through each distance and fill data
+                                       for (int k = 0; k < data.size(); k++) {
+                                       
+                                               int index = -1;
+                                               //find index in min where value is higher than d
+                                               for (int m = 0; m < min.size(); m++) {
+                                                       if (min[m] > dist[k])   { index = m; break;     }
+                                               }
+                                       
+                                               // if you don't find one than all the mins are less than d
+                                               if (index == -1) { index = min.size();  }
+                                       
+                                               //save value in data
+                                               data[k][a][b] = 1.0 - ((min.size()-index)/(float)min.size());
+       
+                                       }
+                                       
+                                       //move to next box
+                                       if (b < numUserGroups-1) {  b++;  }
+                                       else{ //you are moving to a new row of "boxes"
+                                               b = 0;
+                                               a++;
+                                       }
+
+                                       count++;
+                                       
+                                       if (mode == "random") {
+                                               //restore matrix to original form for next shuffle
+                                               matrix->restore();
+                                       }
+                               }
+                       }
+               }
+               
        }
        catch(exception& e) {
                cout << "Standard Error: " << e.what() << " has occurred in the Coverage class Function getValues. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";