}
//**********************************************************************************************************************
-void Coverage::getValues(FullMatrix* matrix, vector< vector< vector<float> > >& data, vector<float> dist, string mode) {
+void Coverage::getValues(FullMatrix* matrix, vector< vector< vector<float> > >& data, vector<float> dist) {
try {
vector<float> min;
vector<string> groups;
//get the minimums for each comparision
/**************************************/
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?
+ //is this "box" one the 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
if (index == -1) { index = min.size(); }
//save value in data
- data[k][a][b] = 1.0 - ((min.size()-index)/(float)min.size());
+ data[k][i][j] = 1.0 - ((min.size()-index)/(float)min.size());
}
+ }
+ count++;
+ }
+ }
+
+ }
+ 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";
+ exit(1);
+ }
+ catch(...) {
+ cout << "An unknown error has occurred in the Coverage class function getValues. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+ exit(1);
+ }
+}
+
+//**********************************************************************************************************************
+void Coverage::getValues(FullMatrix* matrix, vector< vector< vector<float> > >& data, vector<float> dist, string mode) {
+ try {
+ vector<float> min1;
+ vector<float> min2;
+ vector<string> groups;
+
+ //initialize data
+ data.resize(dist.size());
+ for (int l = 0; l < data.size(); l++) {
+ data[l].resize(numGroups);
+ for (int k = 0; k < data[l].size(); k++) {
+ data[l][k].push_back(0.0);
+ }
+ }
+
+ /**************************************/
+ //get the minimums for each comparision
+ /**************************************/
+ int count = 0;
+ int count2 = 0;
+
+ //for each box
+ for (int i = 0; i < numGroups; i++) {
+ for (int j = 0; j < numGroups; j++) {
+
+ if (i != j) {
+ //is this "box" one the user wants analyzed?
+ if ((inUsersGroups(globaldata->gGroupmap->namesOfGroups[i], globaldata->Groups) == true) && (inUsersGroups(globaldata->gGroupmap->namesOfGroups[j], globaldata->Groups) == true)) {
- //move to next box
- if (b < numUserGroups-1) { b++; }
- else{ //you are moving to a new row of "boxes"
- b = 0;
- a++;
- }
+ matrix->shuffle(globaldata->gGroupmap->namesOfGroups[i], globaldata->gGroupmap->namesOfGroups[j]);
+
+ min1 = matrix->getMins(count); //returns vector of mins for "box" requested ie. groups A, B, 0 = AA, 1 = AB, 2 = BA, 3 = BB;
+ min2 = matrix->getMins(count2); //returns vector of mins for "box" requested ie. groups A, B, 0 = AA, 1 = AB, 2 = BA, 3 = BB;
- count++;
+ //find the coverage at this distance
+ sort(min1.begin(), min1.end());
+
+ //find the coverage at this distance
+ sort(min2.begin(), min2.end());
+
+ float distDiff = 0;
+
+ //loop through each distance and fill data
+ for (int k = 0; k < data.size(); k++) {
+ //****** coverage of AA **********//
+ int index = -1;
+ //find index in min where value is higher than d
+ for (int m = 0; m < min1.size(); m++) {
+ if (min1[m] > dist[k]) { index = m; break; }
+ }
- if (mode == "random") {
- //restore matrix to original form for next shuffle
+ // if you don't find one than all the mins are less than d
+ if (index == -1) { index = min1.size(); }
+
+ //****** coverage of AB **********//
+ int index2 = -1;
+ //find index in min where value is higher than d
+ for (int m = 0; m < min2.size(); m++) {
+ if (min2[m] > dist[k]) { index2 = m; break; }
+ }
+
+ // if you don't find one than all the mins are less than d
+ if (index2 == -1) { index2 = min2.size(); }
+
+ //coverage of ii
+ float covII = 1.0 - ((min1.size()-index)/(float)min1.size());
+
+ //coverage of ij
+ float covIJ = 1.0 - ((min2.size()-index2)/(float)min2.size());
+
+ //save value in data (Caa - Cab)^2 * distDiff
+ data[k][i][j] = ((covII-covIJ) * (covII-covIJ)) * distDiff;
+
+ //update distDiff
+ if (k < data.size() - 1) {
+ distDiff = dist[k+1] - dist[k];
+ }
+ }
+
+ //put matrix back to original
matrix->restore();
}
}
+
+ count2++;
}
+ count += numGroups+1; //go from AA to BB to CC
}
}
cout << "An unknown error has occurred in the Coverage class function getValues. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
exit(1);
}
+
}
-//**********************************************************************************************************************
-
\ No newline at end of file
deltaValues.clear();
deltaValues.resize(dist.size());
- coverage->getValues(matrix, cValues, dist, "user");
+ coverage->getValues(matrix, cValues, dist);
- float distDiff = dist[0];
+ float distDiff = 0;
- //loop through each distance and load rsumdelta
+ //loop through each distance and load sumdelta
for (int p = 0; p < cValues.size(); p++) {
//find delta values
int count = 0;
for (int j = 0; j < numGroups; j++) {
//don't save AA to AA
if (i != j) {
- //(Caa - Cab)^2
- deltaValues[p].push_back(((cValues[p][i][i]-cValues[p][i][j]) * (cValues[p][i][i]-cValues[p][i][j])) * distDiff);
+ //(Caa - Cab)^2 * distDiff
+ deltaValues[p].push_back(((cValues[p][i][i]-cValues[p][i][j]) * (cValues[p][i][i]-cValues[p][i][j])) * distDiff); //* distDiff
sumDelta[count] += deltaValues[p][count];
count++;
}
}
}
if (p < cValues.size() - 1) {
- distDiff = dist[p+1] - dist[p];
-//cout << distDiff << endl;
+ distDiff = dist[p+1] - dist[p];
}
}
coverage->getValues(matrix, cValues, dist, "random");
- distDiff = 1;
-
//loop through each distance and load rsumdelta
for (int p = 0; p < cValues.size(); p++) {
//find delta values
for (int j = 0; j < numGroups; j++) {
//don't save AA to AA
if (i != j) {
- //(Caa - Cab)^2
- rsumDelta[count][m] += (((cValues[p][i][i]-cValues[p][i][j]) * (cValues[p][i][i]-cValues[p][i][j])) * distDiff);
+ //rsumDelta[3][500] = the sum of the delta scores for BB-BC for random matrix # 500.
+ rsumDelta[count][m] += cValues[p][i][j]; // where cValues[p][0][1] = delta value at distance p of AA-AB, cValues[p][1][2] = delta value at distance p of BB-BC.
count++;
}
}
}
-
- if (p < cValues.size() - 1) {
- distDiff = dist[p+1] - dist[p];
- }
}
//clear out old Values
//sort so labels match
sort(globaldata->Groups.begin(), globaldata->Groups.end());
+ //sort
+ sort(globaldata->gGroupmap->namesOfGroups.begin(), globaldata->gGroupmap->namesOfGroups.end());
+
+
// number of comparisons i.e. with groups A,B,C = AA, AB, AC, BA, BB, BC...;
for (int i=0; i<numGroups; i++) {
for (int l = 0; l < numGroups; l++) {
projects / mothur.git / commitdiff