void ensaio(int w) { t=w; A.setValues(t,t);B.setValues(t,t);C.setValues(t,t); A.criar();B.criar();C.criar(); A.encher_random(); B.encher_random(); C.encher_ceros(); }
forceinline void Map<I,M,false>::next(void) { if (i()) { mi = m.min(i.min()); ma = m.max(i.max()); ++i; while (i() && (ma+1 >= m.min(i.min()))) { ma = m.max(i.max()); ++i; } } else { finish(); } }
int main() { typedef std::pair<const int, double> V; typedef std::multimap<int, double> M; { typedef M::size_type R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.count(4); assert(r == 0); r = m.count(5); assert(r == 3); r = m.count(6); assert(r == 0); r = m.count(7); assert(r == 3); r = m.count(8); assert(r == 0); r = m.count(9); assert(r == 3); r = m.count(10); assert(r == 0); } }
void operator()(int k, int l, const double (&Q)[N]) { const size_t ni = meta::shell<A>::size; const size_t nj = meta::shell<B>::size; size_t size1,size2; for (int b = 0; b < size1; ++b) { double *C1 = &C1_.block(0,0); double T1[nj]; for (int j = 0; j < nj; ++j) { for (int i = 0; i < ni; ++i) { T1[j] = C1[i]*Q[i+j*ni]; } } double *C2 = &C2_.data()[0]; double *T2 = &T2_.iterator2()[a]; for (int a = 0; a < size2; ++a) { for (int j = 0; j < nj; ++j) { T2[a] = C2[j+a*nj]*T1[j]; } } } }
int main() { typedef std::pair<const int, double> V; typedef std::map<int, double> M; { typedef M::size_type R; V ar[] = { V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.count(5); assert(r == 1); r = m.count(6); assert(r == 1); r = m.count(7); assert(r == 1); r = m.count(8); assert(r == 1); r = m.count(9); assert(r == 1); r = m.count(10); assert(r == 1); r = m.count(11); assert(r == 1); r = m.count(12); assert(r == 1); r = m.count(4); assert(r == 0); } }
int main() { typedef int V; typedef std::set<int> M; { typedef M::size_type R; V ar[] = { 5, 6, 7, 8, 9, 10, 11, 12 }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.count(5); assert(r == 1); r = m.count(6); assert(r == 1); r = m.count(7); assert(r == 1); r = m.count(8); assert(r == 1); r = m.count(9); assert(r == 1); r = m.count(10); assert(r == 1); r = m.count(11); assert(r == 1); r = m.count(12); assert(r == 1); r = m.count(4); assert(r == 0); } }
void init(const Corpus<D>& corpus, const V& vocab) { for(int di = 0; di < num_docs; di++){ const int num_w = num_words[di]; D doc = corpus[di]; for(int wi = 0; wi < num_w; wi++){ // randomly assign to a topic int topic = wi % model->num_topics(); assignments[di][wi] = topic; ++c_doc_topic[di][topic]; ++c_topic[topic][ vocab.index(doc[wi]) ]; ++c_topic_sums[topic]; } } }
CollapsedGibbsDMC<M, D, V>(M* model, Corpus<D>* corpus, V* vocab) : num_docs(corpus->num_docs()), model(model), corpus_(corpus), num_topics_(model->num_topics()) { int num_docs = corpus->num_docs(); for(int d = 0; d < num_docs; d++) { const int nw = ((*corpus)[d]).num_words(); num_words.push_back(nw); c_doc_topic.push_back(std::vector<int>(num_topics_)); assignments.push_back(std::vector<int>(nw)); } const int vocab_size = vocab->num_words(); for(int t = 0; t < model->num_topics(); t++) { c_topic_sums.push_back(0); c_topic.push_back(std::vector<int>(vocab_size)); } word_dmc = dmc::gdmc(vocab_size, model->hyper_word(), model->num_topics()); topic_dmc = dmc::gdmc(model->num_topics(), model->hyper_theta(), num_docs); }
int main() { typedef std::pair<const int, double> V; { typedef std::multimap<int, double> M; { typedef std::pair<M::iterator, M::iterator> R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.equal_range(4); assert(r.first == m.begin()); assert(r.second == m.begin()); r = m.equal_range(5); assert(r.first == m.begin()); assert(r.second == next(m.begin(), 3)); r = m.equal_range(6); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(7); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(8); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(9); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 9)); r = m.equal_range(10); assert(r.first == m.end()); assert(r.second == m.end()); } { typedef std::pair<M::const_iterator, M::const_iterator> R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.equal_range(4); assert(r.first == m.begin()); assert(r.second == m.begin()); r = m.equal_range(5); assert(r.first == m.begin()); assert(r.second == next(m.begin(), 3)); r = m.equal_range(6); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(7); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(8); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(9); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 9)); r = m.equal_range(10); assert(r.first == m.end()); assert(r.second == m.end()); } } #if __cplusplus >= 201103L { typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M; { typedef std::pair<M::iterator, M::iterator> R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.equal_range(4); assert(r.first == m.begin()); assert(r.second == m.begin()); r = m.equal_range(5); assert(r.first == m.begin()); assert(r.second == next(m.begin(), 3)); r = m.equal_range(6); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(7); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(8); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(9); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 9)); r = m.equal_range(10); assert(r.first == m.end()); assert(r.second == m.end()); } { typedef std::pair<M::const_iterator, M::const_iterator> R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.equal_range(4); assert(r.first == m.begin()); assert(r.second == m.begin()); r = m.equal_range(5); assert(r.first == m.begin()); assert(r.second == next(m.begin(), 3)); r = m.equal_range(6); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(7); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(8); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(9); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 9)); r = m.equal_range(10); assert(r.first == m.end()); assert(r.second == m.end()); } } #endif #if _LIBCPP_STD_VER > 11 { typedef std::pair<const int, double> V; typedef std::multimap<int, double, std::less<>> M; typedef std::pair<M::iterator, M::iterator> R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.equal_range(4); assert(r.first == m.begin()); assert(r.second == m.begin()); r = m.equal_range(5); assert(r.first == m.begin()); assert(r.second == next(m.begin(), 3)); r = m.equal_range(6); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(7); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(8); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(9); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 9)); r = m.equal_range(10); assert(r.first == m.end()); assert(r.second == m.end()); r = m.equal_range(C2Int(4)); assert(r.first == m.begin()); assert(r.second == m.begin()); r = m.equal_range(C2Int(5)); assert(r.first == m.begin()); assert(r.second == next(m.begin(), 3)); r = m.equal_range(C2Int(6)); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(C2Int(7)); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(C2Int(8)); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(C2Int(9)); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 9)); r = m.equal_range(C2Int(10)); assert(r.first == m.end()); assert(r.second == m.end()); } { typedef PrivateConstructor PC; typedef std::multimap<PC, double, std::less<>> M; typedef std::pair<M::iterator, M::iterator> R; M m; m.insert ( std::make_pair<PC, double> ( PC::make(5), 1 )); m.insert ( std::make_pair<PC, double> ( PC::make(5), 2 )); m.insert ( std::make_pair<PC, double> ( PC::make(5), 3 )); m.insert ( std::make_pair<PC, double> ( PC::make(7), 1 )); m.insert ( std::make_pair<PC, double> ( PC::make(7), 2 )); m.insert ( std::make_pair<PC, double> ( PC::make(7), 3 )); m.insert ( std::make_pair<PC, double> ( PC::make(9), 1 )); m.insert ( std::make_pair<PC, double> ( PC::make(9), 2 )); m.insert ( std::make_pair<PC, double> ( PC::make(9), 3 )); // assert(m.size() == 9); R r = m.equal_range(4); assert(r.first == m.begin()); assert(r.second == m.begin()); r = m.equal_range(5); assert(r.first == m.begin()); assert(r.second == next(m.begin(), 3)); r = m.equal_range(6); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(7); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(8); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(9); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 9)); r = m.equal_range(10); assert(r.first == m.end()); assert(r.second == m.end()); } #endif }
int main() { { typedef int V; typedef std::multiset<int> M; { typedef M::size_type R; V ar[] = { 5, 5, 5, 5, 7, 7, 7, 9, 9 }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.count(4); assert(r == 0); r = m.count(5); assert(r == 4); r = m.count(6); assert(r == 0); r = m.count(7); assert(r == 3); r = m.count(8); assert(r == 0); r = m.count(9); assert(r == 2); r = m.count(10); assert(r == 0); } } #if TEST_STD_VER >= 11 { typedef int V; typedef std::multiset<int, std::less<int>, min_allocator<int>> M; { typedef M::size_type R; V ar[] = { 5, 5, 5, 5, 7, 7, 7, 9, 9 }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.count(4); assert(r == 0); r = m.count(5); assert(r == 4); r = m.count(6); assert(r == 0); r = m.count(7); assert(r == 3); r = m.count(8); assert(r == 0); r = m.count(9); assert(r == 2); r = m.count(10); assert(r == 0); } } #endif #if _LIBCPP_STD_VER > 11 { typedef int V; typedef std::multiset<int, std::less<>> M; typedef M::size_type R; V ar[] = { 5, 5, 5, 5, 7, 7, 7, 9, 9 }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.count(4); assert(r == 0); r = m.count(5); assert(r == 4); r = m.count(6); assert(r == 0); r = m.count(7); assert(r == 3); r = m.count(8); assert(r == 0); r = m.count(9); assert(r == 2); r = m.count(10); assert(r == 0); } { typedef PrivateConstructor V; typedef std::multiset<V, std::less<>> M; typedef M::size_type R; M m; m.insert ( V::make ( 5 )); m.insert ( V::make ( 5 )); m.insert ( V::make ( 5 )); m.insert ( V::make ( 5 )); m.insert ( V::make ( 7 )); m.insert ( V::make ( 7 )); m.insert ( V::make ( 7 )); m.insert ( V::make ( 9 )); m.insert ( V::make ( 9 )); R r = m.count(4); assert(r == 0); r = m.count(5); assert(r == 4); r = m.count(6); assert(r == 0); r = m.count(7); assert(r == 3); r = m.count(8); assert(r == 0); r = m.count(9); assert(r == 2); r = m.count(10); assert(r == 0); } #endif }
int main() { { typedef std::pair<const int, double> V; typedef std::map<int, double> M; { typedef M::iterator R; V ar[] = { V(5, 5), V(7, 6), V(9, 7), V(11, 8), V(13, 9), V(15, 10), V(17, 11), V(19, 12) }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.upper_bound(5); assert(r == next(m.begin(), 1)); r = m.upper_bound(7); assert(r == next(m.begin(), 2)); r = m.upper_bound(9); assert(r == next(m.begin(), 3)); r = m.upper_bound(11); assert(r == next(m.begin(), 4)); r = m.upper_bound(13); assert(r == next(m.begin(), 5)); r = m.upper_bound(15); assert(r == next(m.begin(), 6)); r = m.upper_bound(17); assert(r == next(m.begin(), 7)); r = m.upper_bound(19); assert(r == next(m.begin(), 8)); r = m.upper_bound(4); assert(r == next(m.begin(), 0)); r = m.upper_bound(6); assert(r == next(m.begin(), 1)); r = m.upper_bound(8); assert(r == next(m.begin(), 2)); r = m.upper_bound(10); assert(r == next(m.begin(), 3)); r = m.upper_bound(12); assert(r == next(m.begin(), 4)); r = m.upper_bound(14); assert(r == next(m.begin(), 5)); r = m.upper_bound(16); assert(r == next(m.begin(), 6)); r = m.upper_bound(18); assert(r == next(m.begin(), 7)); r = m.upper_bound(20); assert(r == next(m.begin(), 8)); } { typedef M::const_iterator R; V ar[] = { V(5, 5), V(7, 6), V(9, 7), V(11, 8), V(13, 9), V(15, 10), V(17, 11), V(19, 12) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.upper_bound(5); assert(r == next(m.begin(), 1)); r = m.upper_bound(7); assert(r == next(m.begin(), 2)); r = m.upper_bound(9); assert(r == next(m.begin(), 3)); r = m.upper_bound(11); assert(r == next(m.begin(), 4)); r = m.upper_bound(13); assert(r == next(m.begin(), 5)); r = m.upper_bound(15); assert(r == next(m.begin(), 6)); r = m.upper_bound(17); assert(r == next(m.begin(), 7)); r = m.upper_bound(19); assert(r == next(m.begin(), 8)); r = m.upper_bound(4); assert(r == next(m.begin(), 0)); r = m.upper_bound(6); assert(r == next(m.begin(), 1)); r = m.upper_bound(8); assert(r == next(m.begin(), 2)); r = m.upper_bound(10); assert(r == next(m.begin(), 3)); r = m.upper_bound(12); assert(r == next(m.begin(), 4)); r = m.upper_bound(14); assert(r == next(m.begin(), 5)); r = m.upper_bound(16); assert(r == next(m.begin(), 6)); r = m.upper_bound(18); assert(r == next(m.begin(), 7)); r = m.upper_bound(20); assert(r == next(m.begin(), 8)); } } #if TEST_STD_VER >= 11 { typedef std::pair<const int, double> V; typedef std::map<int, double, std::less<int>, min_allocator<V>> M; { typedef M::iterator R; V ar[] = { V(5, 5), V(7, 6), V(9, 7), V(11, 8), V(13, 9), V(15, 10), V(17, 11), V(19, 12) }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.upper_bound(5); assert(r == next(m.begin(), 1)); r = m.upper_bound(7); assert(r == next(m.begin(), 2)); r = m.upper_bound(9); assert(r == next(m.begin(), 3)); r = m.upper_bound(11); assert(r == next(m.begin(), 4)); r = m.upper_bound(13); assert(r == next(m.begin(), 5)); r = m.upper_bound(15); assert(r == next(m.begin(), 6)); r = m.upper_bound(17); assert(r == next(m.begin(), 7)); r = m.upper_bound(19); assert(r == next(m.begin(), 8)); r = m.upper_bound(4); assert(r == next(m.begin(), 0)); r = m.upper_bound(6); assert(r == next(m.begin(), 1)); r = m.upper_bound(8); assert(r == next(m.begin(), 2)); r = m.upper_bound(10); assert(r == next(m.begin(), 3)); r = m.upper_bound(12); assert(r == next(m.begin(), 4)); r = m.upper_bound(14); assert(r == next(m.begin(), 5)); r = m.upper_bound(16); assert(r == next(m.begin(), 6)); r = m.upper_bound(18); assert(r == next(m.begin(), 7)); r = m.upper_bound(20); assert(r == next(m.begin(), 8)); } { typedef M::const_iterator R; V ar[] = { V(5, 5), V(7, 6), V(9, 7), V(11, 8), V(13, 9), V(15, 10), V(17, 11), V(19, 12) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.upper_bound(5); assert(r == next(m.begin(), 1)); r = m.upper_bound(7); assert(r == next(m.begin(), 2)); r = m.upper_bound(9); assert(r == next(m.begin(), 3)); r = m.upper_bound(11); assert(r == next(m.begin(), 4)); r = m.upper_bound(13); assert(r == next(m.begin(), 5)); r = m.upper_bound(15); assert(r == next(m.begin(), 6)); r = m.upper_bound(17); assert(r == next(m.begin(), 7)); r = m.upper_bound(19); assert(r == next(m.begin(), 8)); r = m.upper_bound(4); assert(r == next(m.begin(), 0)); r = m.upper_bound(6); assert(r == next(m.begin(), 1)); r = m.upper_bound(8); assert(r == next(m.begin(), 2)); r = m.upper_bound(10); assert(r == next(m.begin(), 3)); r = m.upper_bound(12); assert(r == next(m.begin(), 4)); r = m.upper_bound(14); assert(r == next(m.begin(), 5)); r = m.upper_bound(16); assert(r == next(m.begin(), 6)); r = m.upper_bound(18); assert(r == next(m.begin(), 7)); r = m.upper_bound(20); assert(r == next(m.begin(), 8)); } } #endif #if TEST_STD_VER > 11 { typedef std::pair<const int, double> V; typedef std::map<int, double, std::less<>> M; typedef M::iterator R; V ar[] = { V(5, 5), V(7, 6), V(9, 7), V(11, 8), V(13, 9), V(15, 10), V(17, 11), V(19, 12) }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.upper_bound(5); assert(r == next(m.begin(), 1)); r = m.upper_bound(7); assert(r == next(m.begin(), 2)); r = m.upper_bound(9); assert(r == next(m.begin(), 3)); r = m.upper_bound(11); assert(r == next(m.begin(), 4)); r = m.upper_bound(13); assert(r == next(m.begin(), 5)); r = m.upper_bound(15); assert(r == next(m.begin(), 6)); r = m.upper_bound(17); assert(r == next(m.begin(), 7)); r = m.upper_bound(19); assert(r == next(m.begin(), 8)); r = m.upper_bound(4); assert(r == next(m.begin(), 0)); r = m.upper_bound(6); assert(r == next(m.begin(), 1)); r = m.upper_bound(8); assert(r == next(m.begin(), 2)); r = m.upper_bound(10); assert(r == next(m.begin(), 3)); r = m.upper_bound(12); assert(r == next(m.begin(), 4)); r = m.upper_bound(14); assert(r == next(m.begin(), 5)); r = m.upper_bound(16); assert(r == next(m.begin(), 6)); r = m.upper_bound(18); assert(r == next(m.begin(), 7)); r = m.upper_bound(20); assert(r == next(m.begin(), 8)); } { typedef PrivateConstructor PC; typedef std::map<PC, double, std::less<>> M; typedef M::iterator R; M m; m [ PC::make(5) ] = 5; m [ PC::make(7) ] = 6; m [ PC::make(9) ] = 7; m [ PC::make(11) ] = 8; m [ PC::make(13) ] = 9; m [ PC::make(15) ] = 10; m [ PC::make(17) ] = 11; m [ PC::make(19) ] = 12; R r = m.upper_bound(5); assert(r == next(m.begin(), 1)); r = m.upper_bound(7); assert(r == next(m.begin(), 2)); r = m.upper_bound(9); assert(r == next(m.begin(), 3)); r = m.upper_bound(11); assert(r == next(m.begin(), 4)); r = m.upper_bound(13); assert(r == next(m.begin(), 5)); r = m.upper_bound(15); assert(r == next(m.begin(), 6)); r = m.upper_bound(17); assert(r == next(m.begin(), 7)); r = m.upper_bound(19); assert(r == next(m.begin(), 8)); r = m.upper_bound(4); assert(r == next(m.begin(), 0)); r = m.upper_bound(6); assert(r == next(m.begin(), 1)); r = m.upper_bound(8); assert(r == next(m.begin(), 2)); r = m.upper_bound(10); assert(r == next(m.begin(), 3)); r = m.upper_bound(12); assert(r == next(m.begin(), 4)); r = m.upper_bound(14); assert(r == next(m.begin(), 5)); r = m.upper_bound(16); assert(r == next(m.begin(), 6)); r = m.upper_bound(18); assert(r == next(m.begin(), 7)); r = m.upper_bound(20); assert(r == next(m.begin(), 8)); } #endif }
int main() { typedef std::pair<const int, double> V; { typedef std::multimap<int, double> M; { typedef M::size_type R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.count(4); assert(r == 0); r = m.count(5); assert(r == 3); r = m.count(6); assert(r == 0); r = m.count(7); assert(r == 3); r = m.count(8); assert(r == 0); r = m.count(9); assert(r == 3); r = m.count(10); assert(r == 0); } } #if __cplusplus >= 201103L { typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M; { typedef M::size_type R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.count(4); assert(r == 0); r = m.count(5); assert(r == 3); r = m.count(6); assert(r == 0); r = m.count(7); assert(r == 3); r = m.count(8); assert(r == 0); r = m.count(9); assert(r == 3); r = m.count(10); assert(r == 0); } } #endif #if _LIBCPP_STD_VER > 11 { typedef std::multimap<int, double, std::less<>> M; typedef M::size_type R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.count(4); assert(r == 0); r = m.count(5); assert(r == 3); r = m.count(6); assert(r == 0); r = m.count(7); assert(r == 3); r = m.count(8); assert(r == 0); r = m.count(9); assert(r == 3); r = m.count(10); assert(r == 0); r = m.count(C2Int(4)); assert(r == 0); r = m.count(C2Int(5)); assert(r == 3); r = m.count(C2Int(6)); assert(r == 0); r = m.count(C2Int(7)); assert(r == 3); r = m.count(C2Int(8)); assert(r == 0); r = m.count(C2Int(9)); assert(r == 3); r = m.count(C2Int(10)); assert(r == 0); } { typedef PrivateConstructor PC; typedef std::multimap<PC, double, std::less<>> M; typedef M::size_type R; M m; m.insert ( std::make_pair<PC, double> ( PC::make(5), 1 )); m.insert ( std::make_pair<PC, double> ( PC::make(5), 2 )); m.insert ( std::make_pair<PC, double> ( PC::make(5), 3 )); m.insert ( std::make_pair<PC, double> ( PC::make(7), 1 )); m.insert ( std::make_pair<PC, double> ( PC::make(7), 2 )); m.insert ( std::make_pair<PC, double> ( PC::make(7), 3 )); m.insert ( std::make_pair<PC, double> ( PC::make(9), 1 )); m.insert ( std::make_pair<PC, double> ( PC::make(9), 2 )); m.insert ( std::make_pair<PC, double> ( PC::make(9), 3 )); R r = m.count(4); assert(r == 0); r = m.count(5); assert(r == 3); r = m.count(6); assert(r == 0); r = m.count(7); assert(r == 3); r = m.count(8); assert(r == 0); r = m.count(9); assert(r == 3); r = m.count(10); assert(r == 0); } #endif }
int main() { typedef std::pair<const int, double> V; { typedef std::multimap<int, double> M; { typedef std::pair<M::iterator, M::iterator> R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.equal_range(4); assert(r.first == m.begin()); assert(r.second == m.begin()); r = m.equal_range(5); assert(r.first == m.begin()); assert(r.second == next(m.begin(), 3)); r = m.equal_range(6); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(7); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(8); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(9); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 9)); r = m.equal_range(10); assert(r.first == m.end()); assert(r.second == m.end()); } { typedef std::pair<M::const_iterator, M::const_iterator> R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.equal_range(4); assert(r.first == m.begin()); assert(r.second == m.begin()); r = m.equal_range(5); assert(r.first == m.begin()); assert(r.second == next(m.begin(), 3)); r = m.equal_range(6); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(7); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(8); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(9); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 9)); r = m.equal_range(10); assert(r.first == m.end()); assert(r.second == m.end()); } } #if __cplusplus >= 201103L { typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M; { typedef std::pair<M::iterator, M::iterator> R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.equal_range(4); assert(r.first == m.begin()); assert(r.second == m.begin()); r = m.equal_range(5); assert(r.first == m.begin()); assert(r.second == next(m.begin(), 3)); r = m.equal_range(6); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(7); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(8); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(9); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 9)); r = m.equal_range(10); assert(r.first == m.end()); assert(r.second == m.end()); } { typedef std::pair<M::const_iterator, M::const_iterator> R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.equal_range(4); assert(r.first == m.begin()); assert(r.second == m.begin()); r = m.equal_range(5); assert(r.first == m.begin()); assert(r.second == next(m.begin(), 3)); r = m.equal_range(6); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(7); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(8); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(9); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 9)); r = m.equal_range(10); assert(r.first == m.end()); assert(r.second == m.end()); } } #endif }
{ { typedef contiguous::multiset<int> M; typedef int V; V ar[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; M m(ar, ar + sizeof(ar)/sizeof(ar[0])); REQUIRE(m.size() == 8); m.clear(); REQUIRE(m.size() == 0); } #if TEST_STD_VER >= 11 { typedef contiguous::multiset<int, std::less<int>, min_allocator<int>> M; typedef int V; V ar[] = { 1, 2, 3, 4, 5,
int main() { typedef std::pair<const int, double> V; { typedef std::multimap<int, double> M; { typedef M::iterator R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.find(5); assert(r == m.begin()); r = m.find(6); assert(r == m.end()); r = m.find(7); assert(r == next(m.begin(), 3)); r = m.find(8); assert(r == m.end()); r = m.find(9); assert(r == next(m.begin(), 6)); r = m.find(10); assert(r == m.end()); } { typedef M::const_iterator R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.find(5); assert(r == m.begin()); r = m.find(6); assert(r == m.end()); r = m.find(7); assert(r == next(m.begin(), 3)); r = m.find(8); assert(r == m.end()); r = m.find(9); assert(r == next(m.begin(), 6)); r = m.find(10); assert(r == m.end()); } } #if __cplusplus >= 201103L { typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M; { typedef M::iterator R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.find(5); assert(r == m.begin()); r = m.find(6); assert(r == m.end()); r = m.find(7); assert(r == next(m.begin(), 3)); r = m.find(8); assert(r == m.end()); r = m.find(9); assert(r == next(m.begin(), 6)); r = m.find(10); assert(r == m.end()); } { typedef M::const_iterator R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.find(5); assert(r == m.begin()); r = m.find(6); assert(r == m.end()); r = m.find(7); assert(r == next(m.begin(), 3)); r = m.find(8); assert(r == m.end()); r = m.find(9); assert(r == next(m.begin(), 6)); r = m.find(10); assert(r == m.end()); } } #endif #if _LIBCPP_STD_VER > 11 { typedef std::pair<const int, double> V; typedef std::multimap<int, double, std::less<>> M; typedef M::iterator R; V ar[] = { V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3) }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.find(5); assert(r == m.begin()); r = m.find(6); assert(r == m.end()); r = m.find(7); assert(r == next(m.begin(), 3)); r = m.find(8); assert(r == m.end()); r = m.find(9); assert(r == next(m.begin(), 6)); r = m.find(10); assert(r == m.end()); } { typedef PrivateConstructor PC; typedef std::multimap<PC, double, std::less<>> M; typedef M::iterator R; M m; m.insert ( std::make_pair<PC, double> ( PC::make(5), 1 )); m.insert ( std::make_pair<PC, double> ( PC::make(5), 2 )); m.insert ( std::make_pair<PC, double> ( PC::make(5), 3 )); m.insert ( std::make_pair<PC, double> ( PC::make(7), 1 )); m.insert ( std::make_pair<PC, double> ( PC::make(7), 2 )); m.insert ( std::make_pair<PC, double> ( PC::make(7), 3 )); m.insert ( std::make_pair<PC, double> ( PC::make(9), 1 )); m.insert ( std::make_pair<PC, double> ( PC::make(9), 2 )); m.insert ( std::make_pair<PC, double> ( PC::make(9), 3 )); R r = m.find(5); assert(r == m.begin()); r = m.find(6); assert(r == m.end()); r = m.find(7); assert(r == next(m.begin(), 3)); r = m.find(8); assert(r == m.end()); r = m.find(9); assert(r == next(m.begin(), 6)); r = m.find(10); assert(r == m.end()); } #endif }
void main() { { typedef std::pair<const int, double> V; typedef map<int, double> M; { typedef M::size_type R; V ar[] = { V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.count(5); assert(r == 1); r = m.count(6); assert(r == 1); r = m.count(7); assert(r == 1); r = m.count(8); assert(r == 1); r = m.count(9); assert(r == 1); r = m.count(10); assert(r == 1); r = m.count(11); assert(r == 1); r = m.count(12); assert(r == 1); r = m.count(4); assert(r == 0); } } //#if __cplusplus >= 201103L #ifdef LIBCPP_TEST_MIN_ALLOCATOR { typedef std::pair<const int, double> V; typedef map<int, double, std::less<int>, min_allocator<V>> M; { typedef M::size_type R; V ar[] = { V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.count(5); assert(r == 1); r = m.count(6); assert(r == 1); r = m.count(7); assert(r == 1); r = m.count(8); assert(r == 1); r = m.count(9); assert(r == 1); r = m.count(10); assert(r == 1); r = m.count(11); assert(r == 1); r = m.count(12); assert(r == 1); r = m.count(4); assert(r == 0); } } #endif #if _LIBCPP_STD_VER > 11 { typedef std::pair<const int, double> V; typedef map<int, double, std::less <>> M; typedef M::size_type R; V ar[] = { V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.count(5); assert(r == 1); r = m.count(6); assert(r == 1); r = m.count(7); assert(r == 1); r = m.count(8); assert(r == 1); r = m.count(9); assert(r == 1); r = m.count(10); assert(r == 1); r = m.count(11); assert(r == 1); r = m.count(12); assert(r == 1); r = m.count(4); assert(r == 0); r = m.count(C2Int(5)); assert(r == 1); r = m.count(C2Int(6)); assert(r == 1); r = m.count(C2Int(7)); assert(r == 1); r = m.count(C2Int(8)); assert(r == 1); r = m.count(C2Int(9)); assert(r == 1); r = m.count(C2Int(10)); assert(r == 1); r = m.count(C2Int(11)); assert(r == 1); r = m.count(C2Int(12)); assert(r == 1); r = m.count(C2Int(4)); assert(r == 0); } { typedef PrivateConstructor PC; typedef map<PC, double, std::less<>> M; typedef M::size_type R; M m; m [ PC::make(5) ] = 5; m [ PC::make(6) ] = 6; m [ PC::make(7) ] = 7; m [ PC::make(8) ] = 8; m [ PC::make(9) ] = 9; m [ PC::make(10) ] = 10; m [ PC::make(11) ] = 11; m [ PC::make(12) ] = 12; R r = m.count(5); assert(r == 1); r = m.count(6); assert(r == 1); r = m.count(7); assert(r == 1); r = m.count(8); assert(r == 1); r = m.count(9); assert(r == 1); r = m.count(10); assert(r == 1); r = m.count(11); assert(r == 1); r = m.count(12); assert(r == 1); r = m.count(4); assert(r == 0); } #endif }
bool compareData(boost::numpy::matrix const & mp) const { return _matrix.data() == reinterpret_cast<double const*>(mp.get_data()); }
{ typedef contiguous::multiset<int> M; typedef int V; typedef M::iterator I; V ar[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; M m(ar, ar + sizeof(ar)/sizeof(ar[0])); REQUIRE(m.size() == 8); I i = m.erase(next(m.cbegin(), 5), next(m.cbegin(), 5)); REQUIRE(m.size() == 8); REQUIRE(i == next(m.begin(), 5)); REQUIRE(*next(m.begin(), 0) == 1); REQUIRE(*next(m.begin(), 1) == 2); REQUIRE(*next(m.begin(), 2) == 3); REQUIRE(*next(m.begin(), 3) == 4); REQUIRE(*next(m.begin(), 4) == 5); REQUIRE(*next(m.begin(), 5) == 6); REQUIRE(*next(m.begin(), 6) == 7); REQUIRE(*next(m.begin(), 7) == 8); i = m.erase(next(m.cbegin(), 3), next(m.cbegin(), 4)); REQUIRE(m.size() == 7);
void main() { { typedef int V; typedef set<int> M; { typedef std::pair<M::iterator, M::iterator> R; V ar[] = { 5, 7, 9, 11, 13, 15, 17, 19 }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.equal_range(5); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(7); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(9); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(11); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(13); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(15); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(17); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(19); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 8)); r = m.equal_range(4); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 0)); r = m.equal_range(6); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(8); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(10); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(12); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(14); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(16); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(18); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(20); assert(r.first == next(m.begin(), 8)); assert(r.second == next(m.begin(), 8)); } { typedef std::pair<M::const_iterator, M::const_iterator> R; V ar[] = { 5, 7, 9, 11, 13, 15, 17, 19 }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.equal_range(5); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(7); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(9); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(11); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(13); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(15); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(17); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(19); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 8)); r = m.equal_range(4); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 0)); r = m.equal_range(6); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(8); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(10); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(12); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(14); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(16); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(18); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(20); assert(r.first == next(m.begin(), 8)); assert(r.second == next(m.begin(), 8)); } } //#if __cplusplus >= 201103L #ifdef LIBCPP_TEST_MIN_ALLOCATOR { typedef int V; typedef set<int, std::less<int>, min_allocator<int>> M; typedef std::pair<M::iterator, M::iterator> R; V ar[] = { 5, 7, 9, 11, 13, 15, 17, 19 }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.equal_range(5); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(7); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(9); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(11); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(13); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(15); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(17); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(19); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 8)); r = m.equal_range(4); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 0)); r = m.equal_range(6); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(8); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(10); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(12); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(14); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(16); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(18); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(20); assert(r.first == next(m.begin(), 8)); assert(r.second == next(m.begin(), 8)); } #endif #if _LIBCPP_STD_VER > 11 { typedef int V; typedef set<V, std::less<>> M; { typedef std::pair<M::iterator, M::iterator> R; V ar[] = { 5, 7, 9, 11, 13, 15, 17, 19 }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.equal_range(5); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(7); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(9); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(11); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(13); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(15); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(17); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(19); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 8)); r = m.equal_range(4); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 0)); r = m.equal_range(6); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(8); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(10); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(12); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(14); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(16); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(18); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(20); assert(r.first == next(m.begin(), 8)); assert(r.second == next(m.begin(), 8)); } } { typedef PrivateConstructor V; typedef set<V, std::less<>> M; typedef std::pair<M::iterator, M::iterator> R; M m; m.insert ( V::make ( 5 )); m.insert ( V::make ( 7 )); m.insert ( V::make ( 9 )); m.insert ( V::make ( 11 )); m.insert ( V::make ( 13 )); m.insert ( V::make ( 15 )); m.insert ( V::make ( 17 )); m.insert ( V::make ( 19 )); R r = m.equal_range(5); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(7); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(9); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(11); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(13); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(15); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(17); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(19); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 8)); r = m.equal_range(4); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 0)); r = m.equal_range(6); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(8); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(10); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(12); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(14); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(16); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(18); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(20); assert(r.first == next(m.begin(), 8)); assert(r.second == next(m.begin(), 8)); } #endif }
int main() { typedef int V; typedef std::set<int> M; { typedef std::pair<M::iterator, M::iterator> R; V ar[] = { 5, 7, 9, 11, 13, 15, 17, 19 }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.equal_range(5); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(7); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(9); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(11); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(13); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(15); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(17); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(19); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 8)); r = m.equal_range(4); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 0)); r = m.equal_range(6); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(8); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(10); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(12); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(14); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(16); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(18); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(20); assert(r.first == next(m.begin(), 8)); assert(r.second == next(m.begin(), 8)); } { typedef std::pair<M::const_iterator, M::const_iterator> R; V ar[] = { 5, 7, 9, 11, 13, 15, 17, 19 }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.equal_range(5); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(7); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(9); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(11); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(13); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(15); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(17); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(19); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 8)); r = m.equal_range(4); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 0)); r = m.equal_range(6); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(8); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(10); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(12); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(14); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(16); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(18); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(20); assert(r.first == next(m.begin(), 8)); assert(r.second == next(m.begin(), 8)); } }
// class map // bool empty() const; #include "defs.h" #include "contiguous/map.h" #include "catch.hpp" #include "min_allocator.h" TEST_CASE("map access empty pass") { { typedef contiguous::map<int, double> M; M m; REQUIRE(m.empty()); m.insert(M::value_type(1, 1.5)); REQUIRE(!m.empty()); m.clear(); REQUIRE(m.empty()); } #if TEST_STD_VER >= 11 { typedef contiguous::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M; M m; REQUIRE(m.empty()); m.insert(M::value_type(1, 1.5)); REQUIRE(!m.empty()); m.clear(); REQUIRE(m.empty());
int main() { { typedef std::pair<const int, double> V; typedef std::map<int, double> M; { typedef M::size_type R; V ar[] = { V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.count(5); assert(r == 1); r = m.count(6); assert(r == 1); r = m.count(7); assert(r == 1); r = m.count(8); assert(r == 1); r = m.count(9); assert(r == 1); r = m.count(10); assert(r == 1); r = m.count(11); assert(r == 1); r = m.count(12); assert(r == 1); r = m.count(4); assert(r == 0); } } #if __cplusplus >= 201103L { typedef std::pair<const int, double> V; typedef std::map<int, double, std::less<int>, min_allocator<V>> M; { typedef M::size_type R; V ar[] = { V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.count(5); assert(r == 1); r = m.count(6); assert(r == 1); r = m.count(7); assert(r == 1); r = m.count(8); assert(r == 1); r = m.count(9); assert(r == 1); r = m.count(10); assert(r == 1); r = m.count(11); assert(r == 1); r = m.count(12); assert(r == 1); r = m.count(4); assert(r == 0); } } #endif }
int main(int, char**) { { typedef int V; typedef std::multiset<int> M; { typedef M::iterator R; V ar[] = { 5, 5, 5, 7, 7, 7, 9, 9, 9 }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.lower_bound(4); assert(r == next(m.begin(), 0)); r = m.lower_bound(5); assert(r == next(m.begin(), 0)); r = m.lower_bound(6); assert(r == next(m.begin(), 3)); r = m.lower_bound(7); assert(r == next(m.begin(), 3)); r = m.lower_bound(8); assert(r == next(m.begin(), 6)); r = m.lower_bound(9); assert(r == next(m.begin(), 6)); r = m.lower_bound(11); assert(r == next(m.begin(), 9)); } { typedef M::const_iterator R; V ar[] = { 5, 5, 5, 7, 7, 7, 9, 9, 9 }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.lower_bound(4); assert(r == next(m.begin(), 0)); r = m.lower_bound(5); assert(r == next(m.begin(), 0)); r = m.lower_bound(6); assert(r == next(m.begin(), 3)); r = m.lower_bound(7); assert(r == next(m.begin(), 3)); r = m.lower_bound(8); assert(r == next(m.begin(), 6)); r = m.lower_bound(9); assert(r == next(m.begin(), 6)); r = m.lower_bound(11); assert(r == next(m.begin(), 9)); } } #if TEST_STD_VER >= 11 { typedef int V; typedef std::multiset<int, std::less<int>, min_allocator<int>> M; { typedef M::iterator R; V ar[] = { 5, 5, 5, 7, 7, 7, 9, 9, 9 }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.lower_bound(4); assert(r == next(m.begin(), 0)); r = m.lower_bound(5); assert(r == next(m.begin(), 0)); r = m.lower_bound(6); assert(r == next(m.begin(), 3)); r = m.lower_bound(7); assert(r == next(m.begin(), 3)); r = m.lower_bound(8); assert(r == next(m.begin(), 6)); r = m.lower_bound(9); assert(r == next(m.begin(), 6)); r = m.lower_bound(11); assert(r == next(m.begin(), 9)); } { typedef M::const_iterator R; V ar[] = { 5, 5, 5, 7, 7, 7, 9, 9, 9 }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.lower_bound(4); assert(r == next(m.begin(), 0)); r = m.lower_bound(5); assert(r == next(m.begin(), 0)); r = m.lower_bound(6); assert(r == next(m.begin(), 3)); r = m.lower_bound(7); assert(r == next(m.begin(), 3)); r = m.lower_bound(8); assert(r == next(m.begin(), 6)); r = m.lower_bound(9); assert(r == next(m.begin(), 6)); r = m.lower_bound(11); assert(r == next(m.begin(), 9)); } } #endif #if TEST_STD_VER > 11 { typedef int V; typedef std::multiset<V, std::less<>> M; typedef M::iterator R; V ar[] = { 5, 5, 5, 7, 7, 7, 9, 9, 9 }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.lower_bound(4); assert(r == next(m.begin(), 0)); r = m.lower_bound(5); assert(r == next(m.begin(), 0)); r = m.lower_bound(6); assert(r == next(m.begin(), 3)); r = m.lower_bound(7); assert(r == next(m.begin(), 3)); r = m.lower_bound(8); assert(r == next(m.begin(), 6)); r = m.lower_bound(9); assert(r == next(m.begin(), 6)); r = m.lower_bound(11); assert(r == next(m.begin(), 9)); } { typedef PrivateConstructor V; typedef std::multiset<V, std::less<>> M; typedef M::iterator R; M m; m.insert ( V::make ( 5 )); m.insert ( V::make ( 5 )); m.insert ( V::make ( 5 )); m.insert ( V::make ( 7 )); m.insert ( V::make ( 7 )); m.insert ( V::make ( 7 )); m.insert ( V::make ( 9 )); m.insert ( V::make ( 9 )); m.insert ( V::make ( 9 )); R r = m.lower_bound(4); assert(r == next(m.begin(), 0)); r = m.lower_bound(5); assert(r == next(m.begin(), 0)); r = m.lower_bound(6); assert(r == next(m.begin(), 3)); r = m.lower_bound(7); assert(r == next(m.begin(), 3)); r = m.lower_bound(8); assert(r == next(m.begin(), 6)); r = m.lower_bound(9); assert(r == next(m.begin(), 6)); r = m.lower_bound(11); assert(r == next(m.begin(), 9)); } #endif return 0; }
//===----------------------------------------------------------------------===// // <set> // class set // size_type max_size() const; #include "defs.h" #include "contiguous/set.h" #include "catch.hpp" #include "min_allocator.h" TEST_CASE("set max size pass") { { typedef contiguous::set<int> M; M m; REQUIRE(m.max_size() != 0); } #if TEST_STD_VER >= 11 { typedef contiguous::set<int, std::less<int>, min_allocator<int>> M; M m; REQUIRE(m.max_size() != 0); } #endif }
int main() { typedef std::pair<const int, double> V; typedef std::map<int, double> M; { typedef std::pair<M::iterator, M::iterator> R; V ar[] = { V(5, 5), V(7, 6), V(9, 7), V(11, 8), V(13, 9), V(15, 10), V(17, 11), V(19, 12) }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.equal_range(5); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(7); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(9); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(11); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(13); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(15); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(17); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(19); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 8)); r = m.equal_range(4); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 0)); r = m.equal_range(6); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(8); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(10); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(12); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(14); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(16); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(18); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(20); assert(r.first == next(m.begin(), 8)); assert(r.second == next(m.begin(), 8)); } { typedef std::pair<M::const_iterator, M::const_iterator> R; V ar[] = { V(5, 5), V(7, 6), V(9, 7), V(11, 8), V(13, 9), V(15, 10), V(17, 11), V(19, 12) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.equal_range(5); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(7); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(9); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(11); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(13); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(15); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(17); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(19); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 8)); r = m.equal_range(4); assert(r.first == next(m.begin(), 0)); assert(r.second == next(m.begin(), 0)); r = m.equal_range(6); assert(r.first == next(m.begin(), 1)); assert(r.second == next(m.begin(), 1)); r = m.equal_range(8); assert(r.first == next(m.begin(), 2)); assert(r.second == next(m.begin(), 2)); r = m.equal_range(10); assert(r.first == next(m.begin(), 3)); assert(r.second == next(m.begin(), 3)); r = m.equal_range(12); assert(r.first == next(m.begin(), 4)); assert(r.second == next(m.begin(), 4)); r = m.equal_range(14); assert(r.first == next(m.begin(), 5)); assert(r.second == next(m.begin(), 5)); r = m.equal_range(16); assert(r.first == next(m.begin(), 6)); assert(r.second == next(m.begin(), 6)); r = m.equal_range(18); assert(r.first == next(m.begin(), 7)); assert(r.second == next(m.begin(), 7)); r = m.equal_range(20); assert(r.first == next(m.begin(), 8)); assert(r.second == next(m.begin(), 8)); } }
int main() { { typedef int V; typedef std::set<int> M; { typedef M::iterator R; V ar[] = { 5, 7, 9, 11, 13, 15, 17, 19 }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.lower_bound(5); assert(r == m.begin()); r = m.lower_bound(7); assert(r == next(m.begin())); r = m.lower_bound(9); assert(r == next(m.begin(), 2)); r = m.lower_bound(11); assert(r == next(m.begin(), 3)); r = m.lower_bound(13); assert(r == next(m.begin(), 4)); r = m.lower_bound(15); assert(r == next(m.begin(), 5)); r = m.lower_bound(17); assert(r == next(m.begin(), 6)); r = m.lower_bound(19); assert(r == next(m.begin(), 7)); r = m.lower_bound(4); assert(r == next(m.begin(), 0)); r = m.lower_bound(6); assert(r == next(m.begin(), 1)); r = m.lower_bound(8); assert(r == next(m.begin(), 2)); r = m.lower_bound(10); assert(r == next(m.begin(), 3)); r = m.lower_bound(12); assert(r == next(m.begin(), 4)); r = m.lower_bound(14); assert(r == next(m.begin(), 5)); r = m.lower_bound(16); assert(r == next(m.begin(), 6)); r = m.lower_bound(18); assert(r == next(m.begin(), 7)); r = m.lower_bound(20); assert(r == next(m.begin(), 8)); } { typedef M::const_iterator R; V ar[] = { 5, 7, 9, 11, 13, 15, 17, 19 }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.lower_bound(5); assert(r == m.begin()); r = m.lower_bound(7); assert(r == next(m.begin())); r = m.lower_bound(9); assert(r == next(m.begin(), 2)); r = m.lower_bound(11); assert(r == next(m.begin(), 3)); r = m.lower_bound(13); assert(r == next(m.begin(), 4)); r = m.lower_bound(15); assert(r == next(m.begin(), 5)); r = m.lower_bound(17); assert(r == next(m.begin(), 6)); r = m.lower_bound(19); assert(r == next(m.begin(), 7)); r = m.lower_bound(4); assert(r == next(m.begin(), 0)); r = m.lower_bound(6); assert(r == next(m.begin(), 1)); r = m.lower_bound(8); assert(r == next(m.begin(), 2)); r = m.lower_bound(10); assert(r == next(m.begin(), 3)); r = m.lower_bound(12); assert(r == next(m.begin(), 4)); r = m.lower_bound(14); assert(r == next(m.begin(), 5)); r = m.lower_bound(16); assert(r == next(m.begin(), 6)); r = m.lower_bound(18); assert(r == next(m.begin(), 7)); r = m.lower_bound(20); assert(r == next(m.begin(), 8)); } } #if __cplusplus >= 201103L || defined(_LIBCPP_MSVC) { typedef int V; typedef std::set<int, std::less<int>, min_allocator<int>> M; { typedef M::iterator R; V ar[] = { 5, 7, 9, 11, 13, 15, 17, 19 }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.lower_bound(5); assert(r == m.begin()); r = m.lower_bound(7); assert(r == next(m.begin())); r = m.lower_bound(9); assert(r == next(m.begin(), 2)); r = m.lower_bound(11); assert(r == next(m.begin(), 3)); r = m.lower_bound(13); assert(r == next(m.begin(), 4)); r = m.lower_bound(15); assert(r == next(m.begin(), 5)); r = m.lower_bound(17); assert(r == next(m.begin(), 6)); r = m.lower_bound(19); assert(r == next(m.begin(), 7)); r = m.lower_bound(4); assert(r == next(m.begin(), 0)); r = m.lower_bound(6); assert(r == next(m.begin(), 1)); r = m.lower_bound(8); assert(r == next(m.begin(), 2)); r = m.lower_bound(10); assert(r == next(m.begin(), 3)); r = m.lower_bound(12); assert(r == next(m.begin(), 4)); r = m.lower_bound(14); assert(r == next(m.begin(), 5)); r = m.lower_bound(16); assert(r == next(m.begin(), 6)); r = m.lower_bound(18); assert(r == next(m.begin(), 7)); r = m.lower_bound(20); assert(r == next(m.begin(), 8)); } { typedef M::const_iterator R; V ar[] = { 5, 7, 9, 11, 13, 15, 17, 19 }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.lower_bound(5); assert(r == m.begin()); r = m.lower_bound(7); assert(r == next(m.begin())); r = m.lower_bound(9); assert(r == next(m.begin(), 2)); r = m.lower_bound(11); assert(r == next(m.begin(), 3)); r = m.lower_bound(13); assert(r == next(m.begin(), 4)); r = m.lower_bound(15); assert(r == next(m.begin(), 5)); r = m.lower_bound(17); assert(r == next(m.begin(), 6)); r = m.lower_bound(19); assert(r == next(m.begin(), 7)); r = m.lower_bound(4); assert(r == next(m.begin(), 0)); r = m.lower_bound(6); assert(r == next(m.begin(), 1)); r = m.lower_bound(8); assert(r == next(m.begin(), 2)); r = m.lower_bound(10); assert(r == next(m.begin(), 3)); r = m.lower_bound(12); assert(r == next(m.begin(), 4)); r = m.lower_bound(14); assert(r == next(m.begin(), 5)); r = m.lower_bound(16); assert(r == next(m.begin(), 6)); r = m.lower_bound(18); assert(r == next(m.begin(), 7)); r = m.lower_bound(20); assert(r == next(m.begin(), 8)); } } #endif #if _LIBCPP_STD_VER > 11 { typedef int V; typedef std::set<V, std::less<>> M; typedef M::iterator R; V ar[] = { 5, 7, 9, 11, 13, 15, 17, 19 }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.lower_bound(5); assert(r == m.begin()); r = m.lower_bound(7); assert(r == next(m.begin())); r = m.lower_bound(9); assert(r == next(m.begin(), 2)); r = m.lower_bound(11); assert(r == next(m.begin(), 3)); r = m.lower_bound(13); assert(r == next(m.begin(), 4)); r = m.lower_bound(15); assert(r == next(m.begin(), 5)); r = m.lower_bound(17); assert(r == next(m.begin(), 6)); r = m.lower_bound(19); assert(r == next(m.begin(), 7)); r = m.lower_bound(4); assert(r == next(m.begin(), 0)); r = m.lower_bound(6); assert(r == next(m.begin(), 1)); r = m.lower_bound(8); assert(r == next(m.begin(), 2)); r = m.lower_bound(10); assert(r == next(m.begin(), 3)); r = m.lower_bound(12); assert(r == next(m.begin(), 4)); r = m.lower_bound(14); assert(r == next(m.begin(), 5)); r = m.lower_bound(16); assert(r == next(m.begin(), 6)); r = m.lower_bound(18); assert(r == next(m.begin(), 7)); r = m.lower_bound(20); assert(r == next(m.begin(), 8)); } { typedef PrivateConstructor V; typedef std::set<V, std::less<>> M; typedef M::iterator R; M m; m.insert ( V::make ( 5 )); m.insert ( V::make ( 7 )); m.insert ( V::make ( 9 )); m.insert ( V::make ( 11 )); m.insert ( V::make ( 13 )); m.insert ( V::make ( 15 )); m.insert ( V::make ( 17 )); m.insert ( V::make ( 19 )); R r = m.lower_bound(5); assert(r == m.begin()); r = m.lower_bound(7); assert(r == next(m.begin())); r = m.lower_bound(9); assert(r == next(m.begin(), 2)); r = m.lower_bound(11); assert(r == next(m.begin(), 3)); r = m.lower_bound(13); assert(r == next(m.begin(), 4)); r = m.lower_bound(15); assert(r == next(m.begin(), 5)); r = m.lower_bound(17); assert(r == next(m.begin(), 6)); r = m.lower_bound(19); assert(r == next(m.begin(), 7)); r = m.lower_bound(4); assert(r == next(m.begin(), 0)); r = m.lower_bound(6); assert(r == next(m.begin(), 1)); r = m.lower_bound(8); assert(r == next(m.begin(), 2)); r = m.lower_bound(10); assert(r == next(m.begin(), 3)); r = m.lower_bound(12); assert(r == next(m.begin(), 4)); r = m.lower_bound(14); assert(r == next(m.begin(), 5)); r = m.lower_bound(16); assert(r == next(m.begin(), 6)); r = m.lower_bound(18); assert(r == next(m.begin(), 7)); r = m.lower_bound(20); assert(r == next(m.begin(), 8)); } #endif }
typedef test_allocator<VC> A; typedef contiguous::map<MoveOnly, MoveOnly, C, A> M; typedef std::move_iterator<V*> I; V a1[] = { V(1, 1), V(1, 2), V(1, 3), V(2, 1), V(2, 2), V(2, 3), V(3, 1), V(3, 2), V(3, 3) }; M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7)); V a2[] = { V(1, 1), V(1, 2), V(1, 3), V(2, 1), V(2, 2), V(2, 3), V(3, 1), V(3, 2), V(3, 3) }; M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7)); M m3(std::move(m1), A(7)); REQUIRE(m3 == m2);
int main() { { typedef std::pair<const int, double> V; typedef std::map<int, double> M; { typedef M::iterator R; V ar[] = { V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12) }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.find(5); assert(r == m.begin()); r = m.find(6); assert(r == next(m.begin())); r = m.find(7); assert(r == next(m.begin(), 2)); r = m.find(8); assert(r == next(m.begin(), 3)); r = m.find(9); assert(r == next(m.begin(), 4)); r = m.find(10); assert(r == next(m.begin(), 5)); r = m.find(11); assert(r == next(m.begin(), 6)); r = m.find(12); assert(r == next(m.begin(), 7)); r = m.find(4); assert(r == next(m.begin(), 8)); } { typedef M::const_iterator R; V ar[] = { V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.find(5); assert(r == m.begin()); r = m.find(6); assert(r == next(m.begin())); r = m.find(7); assert(r == next(m.begin(), 2)); r = m.find(8); assert(r == next(m.begin(), 3)); r = m.find(9); assert(r == next(m.begin(), 4)); r = m.find(10); assert(r == next(m.begin(), 5)); r = m.find(11); assert(r == next(m.begin(), 6)); r = m.find(12); assert(r == next(m.begin(), 7)); r = m.find(4); assert(r == next(m.begin(), 8)); } } #if __cplusplus >= 201103L { typedef std::pair<const int, double> V; typedef std::map<int, double, std::less<int>, min_allocator<V>> M; { typedef M::iterator R; V ar[] = { V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12) }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.find(5); assert(r == m.begin()); r = m.find(6); assert(r == next(m.begin())); r = m.find(7); assert(r == next(m.begin(), 2)); r = m.find(8); assert(r == next(m.begin(), 3)); r = m.find(9); assert(r == next(m.begin(), 4)); r = m.find(10); assert(r == next(m.begin(), 5)); r = m.find(11); assert(r == next(m.begin(), 6)); r = m.find(12); assert(r == next(m.begin(), 7)); r = m.find(4); assert(r == next(m.begin(), 8)); } { typedef M::const_iterator R; V ar[] = { V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12) }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.find(5); assert(r == m.begin()); r = m.find(6); assert(r == next(m.begin())); r = m.find(7); assert(r == next(m.begin(), 2)); r = m.find(8); assert(r == next(m.begin(), 3)); r = m.find(9); assert(r == next(m.begin(), 4)); r = m.find(10); assert(r == next(m.begin(), 5)); r = m.find(11); assert(r == next(m.begin(), 6)); r = m.find(12); assert(r == next(m.begin(), 7)); r = m.find(4); assert(r == next(m.begin(), 8)); } } #endif #if _LIBCPP_STD_VER > 11 { typedef std::pair<const int, double> V; typedef std::map<int, double, std::less<>> M; typedef M::iterator R; V ar[] = { V(5, 5), V(6, 6), V(7, 7), V(8, 8), V(9, 9), V(10, 10), V(11, 11), V(12, 12) }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.find(5); assert(r == m.begin()); r = m.find(6); assert(r == next(m.begin())); r = m.find(7); assert(r == next(m.begin(), 2)); r = m.find(8); assert(r == next(m.begin(), 3)); r = m.find(9); assert(r == next(m.begin(), 4)); r = m.find(10); assert(r == next(m.begin(), 5)); r = m.find(11); assert(r == next(m.begin(), 6)); r = m.find(12); assert(r == next(m.begin(), 7)); r = m.find(4); assert(r == next(m.begin(), 8)); } { typedef PrivateConstructor PC; typedef std::map<PC, double, std::less<>> M; typedef M::iterator R; M m; m [ PC::make(5) ] = 5; m [ PC::make(6) ] = 6; m [ PC::make(7) ] = 7; m [ PC::make(8) ] = 8; m [ PC::make(9) ] = 9; m [ PC::make(10) ] = 10; m [ PC::make(11) ] = 11; m [ PC::make(12) ] = 12; R r = m.find(5); assert(r == m.begin()); r = m.find(6); assert(r == next(m.begin())); r = m.find(7); assert(r == next(m.begin(), 2)); r = m.find(8); assert(r == next(m.begin(), 3)); r = m.find(9); assert(r == next(m.begin(), 4)); r = m.find(10); assert(r == next(m.begin(), 5)); r = m.find(11); assert(r == next(m.begin(), 6)); r = m.find(12); assert(r == next(m.begin(), 7)); r = m.find(4); assert(r == next(m.begin(), 8)); } #endif }
int main() { { typedef int V; typedef std::multiset<int> M; { typedef M::iterator R; V ar[] = { 5, 5, 5, 7, 7, 7, 9, 9, 9 }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.lower_bound(4); assert(r == next(m.begin(), 0)); r = m.lower_bound(5); assert(r == next(m.begin(), 0)); r = m.lower_bound(6); assert(r == next(m.begin(), 3)); r = m.lower_bound(7); assert(r == next(m.begin(), 3)); r = m.lower_bound(8); assert(r == next(m.begin(), 6)); r = m.lower_bound(9); assert(r == next(m.begin(), 6)); r = m.lower_bound(11); assert(r == next(m.begin(), 9)); } { typedef M::const_iterator R; V ar[] = { 5, 5, 5, 7, 7, 7, 9, 9, 9 }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.lower_bound(4); assert(r == next(m.begin(), 0)); r = m.lower_bound(5); assert(r == next(m.begin(), 0)); r = m.lower_bound(6); assert(r == next(m.begin(), 3)); r = m.lower_bound(7); assert(r == next(m.begin(), 3)); r = m.lower_bound(8); assert(r == next(m.begin(), 6)); r = m.lower_bound(9); assert(r == next(m.begin(), 6)); r = m.lower_bound(11); assert(r == next(m.begin(), 9)); } } #if __cplusplus >= 201103L { typedef int V; typedef std::multiset<int, std::less<int>, min_allocator<int>> M; { typedef M::iterator R; V ar[] = { 5, 5, 5, 7, 7, 7, 9, 9, 9 }; M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.lower_bound(4); assert(r == next(m.begin(), 0)); r = m.lower_bound(5); assert(r == next(m.begin(), 0)); r = m.lower_bound(6); assert(r == next(m.begin(), 3)); r = m.lower_bound(7); assert(r == next(m.begin(), 3)); r = m.lower_bound(8); assert(r == next(m.begin(), 6)); r = m.lower_bound(9); assert(r == next(m.begin(), 6)); r = m.lower_bound(11); assert(r == next(m.begin(), 9)); } { typedef M::const_iterator R; V ar[] = { 5, 5, 5, 7, 7, 7, 9, 9, 9 }; const M m(ar, ar+sizeof(ar)/sizeof(ar[0])); R r = m.lower_bound(4); assert(r == next(m.begin(), 0)); r = m.lower_bound(5); assert(r == next(m.begin(), 0)); r = m.lower_bound(6); assert(r == next(m.begin(), 3)); r = m.lower_bound(7); assert(r == next(m.begin(), 3)); r = m.lower_bound(8); assert(r == next(m.begin(), 6)); r = m.lower_bound(9); assert(r == next(m.begin(), 6)); r = m.lower_bound(11); assert(r == next(m.begin(), 9)); } } #endif }
#include "defs.h" #include "contiguous/multiset.h" #include "catch.hpp" #include "MoveOnly.h" #include "min_allocator.h" TEST_CASE("multiset insert rv pass") { #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES { typedef contiguous::multiset<MoveOnly> M; typedef M::iterator R; M m; R r = m.insert(M::value_type(2)); REQUIRE(r == m.begin()); REQUIRE(m.size() == 1); REQUIRE(*r == 2); r = m.insert(M::value_type(1)); REQUIRE(r == m.begin()); REQUIRE(m.size() == 2); REQUIRE(*r == 1); r = m.insert(M::value_type(3)); REQUIRE(r == prev(m.end())); REQUIRE(m.size() == 3); REQUIRE(*r == 3);