void printFlow(std::multimap<T, flow> data, const char* filename) {
FILE* pFile = fopen(filename, "w");
for (typename std::multimap<T, flow>::reverse_iterator ii = data.rbegin(); ii != data.rend(); ++ii) {
printFlow(&ii->second, pFile);
}
fclose(pFile);
}
void printLongestLines(int numberOfLines, const std::multimap<int, std::string> &lines) {
std::multimap<int, std::string>::const_reverse_iterator it;
it = lines.rbegin();
for (int i = 0; i < numberOfLines; i++) {
std::cout << (*it).second << std::endl;
++it;
}
}
void printMaximumBeautySum(const std::multimap<int, char> &counts) {
int maximumBeauty = 26;
int sum = 0;
std::map<int, char>::const_reverse_iterator rit;
for (rit = counts.rbegin(); rit != counts.rend(); ++rit) {
sum += (rit->first * maximumBeauty);
maximumBeauty--;
}
std::cout << sum << std::endl;
}
void print_top_words(int num, std::multimap<int, std::string> count_word_map)
// since std::map sorts by std::less on keys and the key is of type integer
// by getting the end of the map and iterating backward we can find the
// largest word counts for each word
{
auto iter = count_word_map.rbegin();
for (int i = 1; i <= num && iter != count_word_map.rend(); ++i, ++iter)
{
std::cout << i << ") " << iter->second << ": " << iter->first << std::endl;
}
}
void f_multimap() {
std::multimap<int, int> C;
std::multimap<int, int>::iterator MMapI1 = C.begin();
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when declaring iterators
// CHECK-FIXES: auto MMapI1 = C.begin();
std::multimap<int, int>::reverse_iterator MMapI2 = C.rbegin();
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when declaring iterators
// CHECK-FIXES: auto MMapI2 = C.rbegin();
const std::multimap<int, int> D;
std::multimap<int, int>::const_iterator MMapI3 = D.begin();
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when declaring iterators
// CHECK-FIXES: auto MMapI3 = D.begin();
std::multimap<int, int>::const_reverse_iterator MMapI4 = D.rbegin();
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when declaring iterators
// CHECK-FIXES: auto MMapI4 = D.rbegin();
}
void AScore::determineHighestScoringPermutations_(const std::vector<std::vector<double> >& peptide_site_scores, std::vector<ProbablePhosphoSites>& sites, const vector<vector<Size> >& permutations, std::multimap<double, Size>& ranking) const
{
// For every phospho site of the highest (weighted) scoring phospho site assignment:
// 1. determine the next best (weighted) score assignment with this site in unphosporylated state.
// 2. determine the filtering level (peak depths) that maximizes the (unweighted) score difference between these two assignments
sites.clear();
// take first set of phospho site assignments
sites.resize(permutations[0].size());
const vector<Size> & best_peptide_sites = permutations[ranking.rbegin()->second]; // sites of the assignment that achieved the highest weighted score
for (Size i = 0; i < best_peptide_sites.size(); ++i) // for each phosphorylated site
{
multimap<double, Size>::reverse_iterator rev = ranking.rbegin();
sites[i].first = best_peptide_sites[i]; // store the site
sites[i].seq_1 = rev->second; // and permutation
bool peptide_not_found = true;
// iterate from best scoring peptide to the first peptide that doesn't contain the current phospho site
do
{
++rev;
for (Size j = 0; j < best_peptide_sites.size(); ++j)
{
if (j == i)
{
if (find(permutations[rev->second].begin(), permutations[rev->second].end(), best_peptide_sites[j]) != permutations[rev->second].end())
{
peptide_not_found = true;
break;
}
else
{
peptide_not_found = false;
}
}
else
{
if (find(permutations[rev->second].begin(), permutations[rev->second].end(), best_peptide_sites[j]) == permutations[rev->second].end())
{
peptide_not_found = true;
break;
}
else
{
peptide_not_found = false;
}
}
}
}
while (peptide_not_found);
// store permutation of peptide without the phospho site i (seq_2)
sites[i].seq_2 = rev->second;
// store phospho site location that is not contained in the best scoring (seq_1) but in seq_2.
for (Size j = 0; j < permutations[sites[i].seq_2].size(); ++j)
{
if (find(permutations[sites[i].seq_1].begin(), permutations[sites[i].seq_1].end(), permutations[sites[i].seq_2][j]) == permutations[sites[i].seq_1].end())
{
sites[i].second = permutations[sites[i].seq_2][j];
break;
}
}
}
// store peak depth that achieves maximum score difference between best and runner up for every phospho site.
for (Size i = 0; i < sites.size(); ++i)
{
double maximum_score_difference = 0.0;
sites[i].peak_depth = 1;
vector<double>::const_iterator first_it = peptide_site_scores[sites[i].seq_1].begin();
vector<double>::const_iterator second_it = peptide_site_scores[sites[i].seq_2].begin();
for (Size depth = 1; second_it != peptide_site_scores[sites[i].seq_2].end(); ++second_it, ++first_it, ++depth)
{
double phospho_at_site_score = *first_it;
double no_phospho_at_site_score = *second_it;
double score_difference = phospho_at_site_score - no_phospho_at_site_score;
if (score_difference > maximum_score_difference)
{
maximum_score_difference = score_difference;
sites[i].peak_depth = depth;
}
}
}
}
int main(int, char**)
{
{
typedef std::pair<const int, double> V;
V ar[] =
{
V(1, 1),
V(1, 1.5),
V(1, 2),
V(2, 1),
V(2, 1.5),
V(2, 2),
V(3, 1),
V(3, 1.5),
V(3, 2),
V(4, 1),
V(4, 1.5),
V(4, 2),
V(5, 1),
V(5, 1.5),
V(5, 2),
V(6, 1),
V(6, 1.5),
V(6, 2),
V(7, 1),
V(7, 1.5),
V(7, 2),
V(8, 1),
V(8, 1.5),
V(8, 2)
};
std::multimap<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
std::multimap<int, double>::iterator i;
i = m.begin();
std::multimap<int, double>::const_iterator k = i;
assert(i == k);
for (int j = 1; j <= 8; ++j)
for (double d = 1; d <= 2; d += .5, ++i)
{
assert(i->first == j);
assert(i->second == d);
i->second = 2.5;
assert(i->second == 2.5);
}
}
{
typedef std::pair<const int, double> V;
V ar[] =
{
V(1, 1),
V(1, 1.5),
V(1, 2),
V(2, 1),
V(2, 1.5),
V(2, 2),
V(3, 1),
V(3, 1.5),
V(3, 2),
V(4, 1),
V(4, 1.5),
V(4, 2),
V(5, 1),
V(5, 1.5),
V(5, 2),
V(6, 1),
V(6, 1.5),
V(6, 2),
V(7, 1),
V(7, 1.5),
V(7, 2),
V(8, 1),
V(8, 1.5),
V(8, 2)
};
const std::multimap<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
std::multimap<int, double>::const_iterator i;
i = m.begin();
for (int j = 1; j <= 8; ++j)
for (double d = 1; d <= 2; d += .5, ++i)
{
assert(i->first == j);
assert(i->second == d);
}
}
#if TEST_STD_VER >= 11
{
typedef std::pair<const int, double> V;
V ar[] =
{
V(1, 1),
V(1, 1.5),
V(1, 2),
V(2, 1),
V(2, 1.5),
V(2, 2),
V(3, 1),
V(3, 1.5),
V(3, 2),
V(4, 1),
V(4, 1.5),
V(4, 2),
V(5, 1),
V(5, 1.5),
V(5, 2),
V(6, 1),
V(6, 1.5),
V(6, 2),
V(7, 1),
V(7, 1.5),
V(7, 2),
V(8, 1),
V(8, 1.5),
V(8, 2)
};
std::multimap<int, double, std::less<int>, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
std::multimap<int, double, std::less<int>, min_allocator<V>>::iterator i;
i = m.begin();
std::multimap<int, double, std::less<int>, min_allocator<V>>::const_iterator k = i;
assert(i == k);
for (int j = 1; j <= 8; ++j)
for (double d = 1; d <= 2; d += .5, ++i)
{
assert(i->first == j);
assert(i->second == d);
i->second = 2.5;
assert(i->second == 2.5);
}
}
{
typedef std::pair<const int, double> V;
V ar[] =
{
V(1, 1),
V(1, 1.5),
V(1, 2),
V(2, 1),
V(2, 1.5),
V(2, 2),
V(3, 1),
V(3, 1.5),
V(3, 2),
V(4, 1),
V(4, 1.5),
V(4, 2),
V(5, 1),
V(5, 1.5),
V(5, 2),
V(6, 1),
V(6, 1.5),
V(6, 2),
V(7, 1),
V(7, 1.5),
V(7, 2),
V(8, 1),
V(8, 1.5),
V(8, 2)
};
const std::multimap<int, double, std::less<int>, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
std::multimap<int, double, std::less<int>, min_allocator<V>>::const_iterator i;
i = m.begin();
for (int j = 1; j <= 8; ++j)
for (double d = 1; d <= 2; d += .5, ++i)
{
assert(i->first == j);
assert(i->second == d);
}
}
#endif
#if TEST_STD_VER > 11
{ // N3644 testing
typedef std::multimap<int, double> C;
C::iterator ii1{}, ii2{};
C::iterator ii4 = ii1;
C::const_iterator cii{};
assert ( ii1 == ii2 );
assert ( ii1 == ii4 );
assert (!(ii1 != ii2 ));
assert ( (ii1 == cii ));
assert ( (cii == ii1 ));
assert (!(ii1 != cii ));
assert (!(cii != ii1 ));
}
#endif
return 0;
}
