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_minimum, Tp, int2_sets ) { { Tp fix(100, randomize(-20, 20)); // Prove that you can find the min value with N nodes, down to 1 nodes while (!fix.container.empty()) { unsigned int count = 0; int min_value_0 = (*fix.container.begin())[0]; int min_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 < min_value_0) { min_value_0 = tmp; } tmp = (*i)[1]; if (tmp < min_value_1) { min_value_1 = tmp; } ++count; } BOOST_CHECK_EQUAL(count, fix.container.size()); mapping_iterator<typename Tp::container_type> iter; dimension_type mapping_dim = 0; iter = mapping_begin(fix.container, mapping_dim); BOOST_CHECK_EQUAL((*iter)[mapping_dim], min_value_0); mapping_dim = 1; iter = mapping_begin(fix.container, mapping_dim); BOOST_CHECK_EQUAL((*iter)[mapping_dim], min_value_1); fix.container.erase(iter); } } { // A tree where all elements are the same! Tp fix(100, same()); // Prove that you can find the min 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_begin(fix.container, 0); BOOST_CHECK_EQUAL((*iter)[0], 100); iter = mapping_begin(fix.container, 1); 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_cbegin(fix.container, 0); BOOST_CHECK_EQUAL((*iter)[0], 1); // should be (1, 1); BOOST_CHECK_EQUAL((*iter)[1], 1); iter = mapping_cbegin(fix.container, 1); BOOST_CHECK_EQUAL((*iter)[0], 1); // should be (1, 1); BOOST_CHECK_EQUAL((*iter)[1], 1); } { // test at the limit: an unbalanced tree (i.e. insertions in order)! Tp fix(100, decrease()); mapping_iterator<typename Tp::container_type> iter; dimension_type mapping_dim = 0; iter = mapping_begin(fix.container, mapping_dim); BOOST_CHECK_EQUAL((*iter)[0], 1); // should be (1, 1); BOOST_CHECK_EQUAL((*iter)[1], 1); } { // test at the limit: an unbalanced tree (i.e insertions in order)! Tp fix(100, increase()); mapping_iterator<typename Tp::container_type> iter; dimension_type mapping_dim = 1; iter = mapping_begin(fix.container, mapping_dim); BOOST_CHECK_EQUAL((*iter)[0], 0); // should be (0, 0); BOOST_CHECK_EQUAL((*iter)[1], 0); } }
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); } } }