*/
//this follows wigeon, but we may want to consider that it chops off the end values if the sequence cannot be evenly divided into steps
- for (int m = front; m < (back - size) ; m+=increment) { win.push_back(m); }
+ for (int i = front; i < (back - size) ; i+=increment) { win.push_back(i); }
vector<float> temp;
//int gaps = 0;
- for (int m = 0; m < window.size(); m++) {
+ for (int i = 0; i < window.size(); i++) {
- string seqFrag = query->getAligned().substr(window[m], size);
- string seqFragsub = subject->getAligned().substr(window[m], size);
+ string seqFrag = query->getAligned().substr(window[i], size);
+ string seqFragsub = subject->getAligned().substr(window[i], size);
int diff = 0;
for (int b = 0; b < seqFrag.length(); b++) {
//for each window
vector<float> queryExpected;
- for (int m = 0; m < qav.size(); m++) {
+ for (int j = 0; j < qav.size(); j++) {
- float expected = qav[m] * coef;
+ float expected = qav[j] * coef;
queryExpected.push_back(expected);
}
try {
//for each window
- float sum = 0.0; //sum = sum from 1 to m of (oi-ei)^2
+ float sum = 0.0; //sum = sum from 1 to i of (oi-ei)^2
int numZeros = 0;
- for (int m = 0; m < obs.size(); m++) {
+ for (int j = 0; j < obs.size(); j++) {
- //if (obs[m] != 0.0) {
- sum += ((obs[m] - exp[m]) * (obs[m] - exp[m]));
+ //if (obs[j] != 0.0) {
+ sum += ((obs[j] - exp[j]) * (obs[j] - exp[j]));
//}else { numZeros++; }
}
//find base with highest frequency
int highest = 0;
- for (int m = 0; m < freq.size(); m++) { if (freq[m] > highest) { highest = freq[m]; } }
+ for (int j = 0; j < freq.size(); j++) { if (freq[j] > highest) { highest = freq[j]; } }
float highFreq = highest / (float) (seqs.size());
vector<float> averages;
//for each window find average
- for (int m = 0; m < window.size(); m++) {
+ for (int i = 0; i < window.size(); i++) {
float average = 0.0;
//while you are in the window for this sequence
int count = 0;
- for (int j = window[m]; j < (window[m]+size); j++) {
+ for (int j = window[i]; j < (window[i]+size); j++) {
average += probabilityProfile[j];
count++;
}
}
//***************************************************************************************************************
//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);
-//ofstream o;
-//string out = "getQuantiles.out";
-//openOutputFile(out, o);
-
+
//for each sequence
for(int i = start; i < end; i++){
float de = calcDE(obsi, exp);
float dist = calcDist(query, subject, front, back);
- //o << i << '\t' << j << '\t' << dist << '\t' << de << endl;
+ //cout << i << '\t' << j << '\t' << dist << '\t' << de << endl;
dist = ceil(dist);
- quanMember newScore(de, i, j);
-
- quan[dist].push_back(newScore);
+ //quanMember newScore(de, i, j);
+ quan[dist].push_back(de);
+
delete subject;
}
delete query;
}
+
return quan;
}
//***************************************************************************************************************
//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);
-
- float high = quantiles[i][int(quantiles[i].size() * 0.99)].score;
- float low = quantiles[i][int(quantiles[i].size() * 0.01)].score;
- vector<quanMember> temp;
+ //find mean of this quantile score
+ sort(quantiles[i].begin(), quantiles[i].end());
- //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)) {
- temp.push_back(quantiles[i][j]);
+ vector<float> temp;
+ if (quantiles[i].size() != 0) {
+ 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] > low) && (quantiles[i][j] < high)) {
+ temp.push_back(quantiles[i][j]);
+ }
}
}
-
quantiles[i] = temp;
}