BOOST_AUTO_TEST_CASE_TEMPLATE ( test_mapping_range, Tp, every_quad ) { Tp fix(20, randomize(-100, 100)); { // non-const mapping_iterator_pair<typename Tp::container_type> pair(mapping_range(fix.container, 2u)); BOOST_CHECK(pair.first == mapping_begin(fix.container, 2u)); BOOST_CHECK(pair.second == mapping_end(fix.container, 2u)); mapping_iterator_pair<typename Tp::container_type> pair2; pair2 = mapping_range(fix.container, 3u); BOOST_CHECK(pair2.first == mapping_begin(fix.container, 3u)); BOOST_CHECK(pair2.second == mapping_end(fix.container, 3u)); } { // const mapping_iterator_pair<const typename Tp::container_type> pair0(mapping_range(fix.container, 1u)); // cast constructor BOOST_CHECK(pair0.first == mapping_begin(fix.container, 1u)); BOOST_CHECK(pair0.second == mapping_end(fix.container, 1u)); mapping_iterator_pair<const typename Tp::container_type> pair1(mapping_crange(fix.container, 2u)); // copy constructor BOOST_CHECK(pair1.first == mapping_begin(fix.container, 2u)); BOOST_CHECK(pair1.second == mapping_end(fix.container, 2u)); mapping_iterator_pair<const typename Tp::container_type> pair2; pair2 = mapping_crange(fix.container, 3u); // assignment operator BOOST_CHECK(pair2.first == mapping_cbegin(fix.container, 3u)); BOOST_CHECK(pair2.second == mapping_cend(fix.container, 3u)); } }
void compare_libraries(std::size_t data_size, const Distribution& distribution) { std::cout << "\t" << N << " dimensions, " << data_size << " objects:" << std::endl; std::vector<Point> data; data.reserve(data_size); for (std::size_t i = 0; i < data_size; ++i) data.push_back(Point(distribution)); { // Mapping begin into an idle_point_multiset spatial::idle_point_multiset<N, Point> cobaye; cobaye.insert_rebalance(data.begin(), data.end()); std::cout << "\t\tidle_point_multiset (maximum):\t" << std::flush; utils::time_point start = utils::process_timer_now(); for (int j = 0; j != N; ++j) { spatial::mapping_iterator<spatial::idle_point_multiset<N, Point> > i = mapping_end(cobaye, 0); --i; } utils::time_point stop = utils::process_timer_now(); std::cout << (stop - start) << "sec" << std::endl; std::cout << "\t\tidle_point_multiset:\t" << std::flush; start = utils::process_timer_now(); for (int j = 0; j != N; ++j) { spatial::mapping_iterator<spatial::idle_point_multiset<N, Point> > i = mapping_begin(cobaye, 0); ++i; } stop = utils::process_timer_now(); std::cout << (stop - start) << "sec" << std::endl; } { // Mapping begin into a point_multiset spatial::point_multiset<N, Point> cobaye; cobaye.insert(data.begin(), data.end()); std::cout << "\t\tpoint_multiset:\t" << std::flush; utils::time_point start = utils::process_timer_now(); for (int j = 0; j != N; ++j) { spatial::mapping_iterator<spatial::point_multiset<N, Point> > i = mapping_begin(cobaye, 0); ++i; } utils::time_point stop = utils::process_timer_now(); std::cout << (stop - start) << "sec" << std::endl; std::cout << "\t\tpoint_multiset (reverse):\t" << std::flush; start = utils::process_timer_now(); for (int j = 0; j != N; ++j) { spatial::mapping_iterator<spatial::point_multiset<N, Point> > i = mapping_end(cobaye, 0); --i; } stop = utils::process_timer_now(); std::cout << (stop - start) << "sec" << std::endl; } }
BOOST_AUTO_TEST_CASE_TEMPLATE ( test_mapping_upper_bound, Tp, quad_maps ) { { // find the smallest element that is greater than key Tp fix(100, randomize(-2, 2)); quad lower (-3, -3, -3, -3); quad in (-1, -1, -1, -1); quad upper (1, 1, 1, 1); for (dimension_type mapping_dim = 0; mapping_dim < 4; ++mapping_dim) { mapping_iterator<typename Tp::container_type> iter (mapping_upper_bound(fix.container, mapping_dim, in)); BOOST_CHECK(iter == mapping_end(fix.container, mapping_dim) || quad_less()(mapping_dim, in, iter->first)); BOOST_CHECK(iter == mapping_begin(fix.container, mapping_dim) || !quad_less()(mapping_dim, (--iter)->first, in)); iter = mapping_upper_bound(fix.container, mapping_dim, lower); BOOST_CHECK(iter == mapping_begin(fix.container, mapping_dim)); iter = mapping_upper_bound(fix.container, mapping_dim, upper); BOOST_CHECK(iter == mapping_end(fix.container, mapping_dim)); } } { // same test with a tree filled with similar values Tp fix(100, same()); quad lower (99, 99, 99, 99); quad in (100, 100, 100, 100); quad upper (101, 101, 101, 101); for (dimension_type mapping_dim = 0; mapping_dim < 4; ++mapping_dim) { mapping_iterator<typename Tp::container_type> iter (mapping_upper_bound(fix.container, mapping_dim, lower)); BOOST_CHECK(iter == mapping_begin(fix.container, mapping_dim)); iter = mapping_upper_bound(fix.container, mapping_dim, in); BOOST_CHECK(iter == mapping_end(fix.container, mapping_dim)); iter = mapping_upper_bound(fix.container, mapping_dim, upper); BOOST_CHECK(iter == mapping_end(fix.container, mapping_dim)); } } { // test at the limit: tree with 1 value Tp fix(1, same()); quad lower (0, 0, 0, 0); quad in (1, 1, 1, 1); quad upper (2, 2, 2, 2); for (dimension_type mapping_dim = 0; mapping_dim < 4; ++mapping_dim) { mapping_iterator<const typename Tp::container_type> iter (mapping_cupper_bound(fix.container, mapping_dim, lower)); BOOST_CHECK(iter == mapping_cbegin(fix.container, mapping_dim)); iter = mapping_cupper_bound(fix.container, mapping_dim, in); BOOST_CHECK(iter == mapping_cend(fix.container, mapping_dim)); iter = mapping_cupper_bound(fix.container, mapping_dim, upper); BOOST_CHECK(iter == mapping_cend(fix.container, mapping_dim)); } } { // test at the limit: tree filled with decreasing values Tp fix(100, decrease()); // first (100, 100, 100, 100), last (1, 1, 1, 1) quad lower(0, 0, 0, 0); quad in (99, 99, 99, 99); quad upper(100, 100, 100, 100); for (dimension_type mapping_dim = 0; mapping_dim < 4; ++mapping_dim) { mapping_iterator<typename Tp::container_type> iter (mapping_upper_bound(fix.container, mapping_dim, lower)); BOOST_CHECK(iter == mapping_begin(fix.container, mapping_dim)); iter = mapping_upper_bound(fix.container, mapping_dim, in); BOOST_CHECK(iter != mapping_end(fix.container, mapping_dim) && ++iter == mapping_end(fix.container, mapping_dim)); iter = mapping_upper_bound(fix.container, mapping_dim, upper); BOOST_CHECK(iter == mapping_end(fix.container, mapping_dim)); } } { // test at the limit: tree filled with increasing values Tp fix(100, increase()); // first (0, 0, 0, 0), last (99, 99, 99, 99) quad lower(-1, -1, -1, -1); quad in(98, 98, 98, 98); quad upper (99, 99, 99, 99); for (dimension_type mapping_dim = 0; mapping_dim < 4; ++mapping_dim) { mapping_iterator<typename Tp::container_type> iter (mapping_upper_bound(fix.container, mapping_dim, lower)); BOOST_CHECK(iter == mapping_begin(fix.container, mapping_dim)); iter = mapping_upper_bound(fix.container, mapping_dim, in); BOOST_CHECK(iter != mapping_end(fix.container, mapping_dim) && ++iter == mapping_end(fix.container, mapping_dim)); iter = mapping_upper_bound(fix.container, mapping_dim, upper); BOOST_CHECK(iter == mapping_end(fix.container, mapping_dim)); } } }
BOOST_AUTO_TEST_CASE_TEMPLATE ( test_mapping_decrement, Tp, int2_maps ) { { // test the invarient of the increment Tp fix(100, randomize(-3, 3)); for (dimension_type mapping_dim = 0; mapping_dim < 2; ++mapping_dim) { std::reverse_iterator <mapping_iterator<typename Tp::container_type> > iter(mapping_end(fix.container, mapping_dim)), end(mapping_begin(fix.container, mapping_dim)); int count = 0; double tmp = iter->first[mapping_dim]; for (; iter != end; ++iter) { BOOST_CHECK_GE(tmp, iter->first[mapping_dim]); tmp = iter->first[mapping_dim]; if (++count > 100) break; } BOOST_CHECK_EQUAL(count, 100); } } { // test at the limit: a tree where all elements are the same Tp fix(100, same()); for (dimension_type mapping_dim = 0; mapping_dim < 2; ++mapping_dim) { std::reverse_iterator <mapping_iterator<typename Tp::container_type> > iter(mapping_end(fix.container, mapping_dim)), end(mapping_begin(fix.container, mapping_dim)); int count = 0; for (; iter != end; ++iter) { BOOST_CHECK_EQUAL(100, iter->first[mapping_dim]); if (++count > 100) break; } BOOST_CHECK_EQUAL(count, 100); } } { // test at the limit: a tree with 2 elements Tp fix(2, same()); for (dimension_type mapping_dim = 0; mapping_dim < 2; ++mapping_dim) { mapping_iterator<const typename Tp::container_type> pre = mapping_cend(fix.container, mapping_dim), post = mapping_cend(fix.container, mapping_dim), begin = mapping_cbegin(fix.container, mapping_dim); BOOST_CHECK(pre != begin); BOOST_CHECK(--pre != post--); BOOST_CHECK(pre == post); BOOST_CHECK(post-- != begin); BOOST_CHECK(--pre == begin); BOOST_CHECK(post == begin); } } { // test at the limit: a right-unbalanced tree (pre-increment) Tp fix(100, increase()); for (dimension_type mapping_dim = 0; mapping_dim < 2; ++mapping_dim) { std::reverse_iterator <mapping_iterator<typename Tp::container_type> > iter(mapping_end(fix.container, mapping_dim)), end(mapping_begin(fix.container, mapping_dim)); int count = 0; double tmp = iter->first[mapping_dim]; for (; iter != end; ++iter) { BOOST_CHECK_GE(tmp, iter->first[mapping_dim]); tmp = iter->first[mapping_dim]; if (++count > 100) break; } BOOST_CHECK_EQUAL(count, 100); } } { // test at the limit: a left-unbalanced tree (post-increment) Tp fix(100, decrease()); for (dimension_type mapping_dim = 0; mapping_dim < 2; ++mapping_dim) { std::reverse_iterator <mapping_iterator<typename Tp::container_type> > iter(mapping_end(fix.container, mapping_dim)), end(mapping_begin(fix.container, mapping_dim)); int count = 0; double tmp = iter->first[mapping_dim]; for (; iter != end; iter++) { BOOST_CHECK_GE(tmp, iter->first[mapping_dim]); tmp = iter->first[mapping_dim]; if (++count > 100) break; } BOOST_CHECK_EQUAL(count, 100); } } }
BOOST_AUTO_TEST_CASE_TEMPLATE ( test_mapping_maximum, Tp, int2_sets ) { { Tp fix(100, randomize(-20, 20)); // Prove that you can find the max value with N nodes, down to 1 nodes while (!fix.container.empty()) { unsigned int count = 0; int max_value_0 = (*fix.container.begin())[0]; int max_value_1 = (*fix.container.begin())[1]; for(typename Tp::container_type::iterator i = fix.container.begin(); i != fix.container.end(); ++i) { int tmp = (*i)[0]; if (tmp > max_value_0) { max_value_0 = tmp; } tmp = (*i)[1]; if (tmp > max_value_1) { max_value_1 = tmp; } ++count; } BOOST_CHECK_EQUAL(count, fix.container.size()); mapping_iterator<typename Tp::container_type> iter; iter = mapping_end(fix.container, 0); --iter; // When at the end, this call the 'maximum' function BOOST_REQUIRE_EQUAL((*iter)[0], max_value_0); iter = mapping_end(fix.container, 1); --iter; BOOST_REQUIRE_EQUAL((*iter)[1], max_value_1); fix.container.erase(iter); } } { // A tree where all elements are the same! Tp fix(100, same()); // Prove that you can find the max value with N nodes, down to 1 nodes while (!fix.container.empty()) { unsigned int count = 0; for(typename Tp::container_type::iterator i = fix.container.begin(); i != fix.container.end(); ++i) { ++count; } BOOST_CHECK_EQUAL(count, fix.container.size()); mapping_iterator<typename Tp::container_type> iter; iter = mapping_end(fix.container, 0); --iter; BOOST_CHECK_EQUAL((*iter)[0], 100); iter = mapping_end(fix.container, 1); --iter; BOOST_CHECK_EQUAL((*iter)[1], 100); fix.container.erase(iter); } } { // test at the limit: a tree with 1 element Tp fix(1, same()); mapping_iterator<const typename Tp::container_type> iter; iter = mapping_cend(fix.container, 0); --iter; BOOST_CHECK_EQUAL((*iter)[0], 1); // should be (1, 1); BOOST_CHECK_EQUAL((*iter)[1], 1); iter = mapping_cend(fix.container, 1); --iter; BOOST_CHECK_EQUAL((*iter)[0], 1); // should be (1, 1); BOOST_CHECK_EQUAL((*iter)[1], 1); } { // test at the limit: an unbalanced tree! Tp fix(100, decrease()); mapping_iterator<typename Tp::container_type> iter; iter = mapping_end(fix.container, 0); --iter; BOOST_CHECK_EQUAL((*iter)[0], 100); // should be (100, 100); BOOST_CHECK_EQUAL((*iter)[1], 100); } { // test at the limit: an unbalanced tree! Tp fix(100, increase()); mapping_iterator<typename Tp::container_type> iter; iter = mapping_end(fix.container, 1); --iter; BOOST_CHECK_EQUAL((*iter)[0], 99); // should be (99, 99); BOOST_CHECK_EQUAL((*iter)[1], 99); } }