}
//***************************************************************************************************************
//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);
//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;
}
}
//***************************************************************************************************************
//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]);
}
}
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);
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);
#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
}
}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)]);
}
printQuanFile(noOutliers, outputString);
+ //free memory
+ quantilesMembers.clear();
+
m->mothurOut("Done."); m->mothurOutEndLine();
}
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;
}
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);
}
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;