boost_mirror/geometry
1
0
Fork 0
mirror of https://github.com/boostorg/geometry.git synced 2025-05-09 23:24:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

geometry.index: test - fixed varray warnings, example - code using packing added to glut_vis and benchmark_experimental.

Browse Source 
[SVN r84721]
This commit is contained in:
Adam Wulkiewicz 2013-06-10 03:45:43 +00:00
parent c44de29d5e
commit d34f36fd95
5 changed files with 120 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
index/example/benchmark_experimental.cpp
View File

@ -35,11 +35,14 @@ void mycopy(I1 first, I2 last, O o)
*o = *first;
}
//#define BOOST_GEOMETRY_INDEX_BENCHMARK_DEBUG
int main()
{
typedef boost::chrono::thread_clock clock_t;
typedef boost::chrono::duration<float> dur_t;
#ifndef BOOST_GEOMETRY_INDEX_BENCHMARK_DEBUG
size_t values_count = 1000000;
size_t queries_count = 100000;
size_t nearest_queries_count = 10000;
@ -47,9 +50,19 @@ int main()
size_t path_queries_count = 2000;
size_t path_queries_count2 = 10000;
unsigned path_values_count = 10;
#else
size_t values_count = 1000;
size_t queries_count = 1;
size_t nearest_queries_count = 1;
unsigned neighbours_count = 10;
size_t path_queries_count = 1;
size_t path_queries_count2 = 1;
unsigned path_values_count = 10;
#endif
float max_val = static_cast<float>(values_count / 2);
std::vector< std::pair<float, float> > coords;
std::vector<B> values;
//randomize values
{
@ -63,39 +76,62 @@ int main()
std::cout << "randomizing data\n";
for ( size_t i = 0 ; i < values_count ; ++i )
{
coords.push_back(std::make_pair(rnd(), rnd()));
float x = rnd();
float y = rnd();
coords.push_back(std::make_pair(x, y));
values.push_back(B(P(x - 0.5f, y - 0.5f), P(x + 0.5f, y + 0.5f)));
}
std::cout << "randomized\n";
}
typedef bgi::rtree<B, bgi::linear<16, 4> > RT;
//typedef bgi::rtree<B, bgi::linear<100, 50> > RT;
//typedef bgi::rtree<B, bgi::quadratic<8, 3> > RT;
//typedef bgi::rtree<B, bgi::rstar<8, 3> > RT;
typedef bgi::rtree<B, bgi::rstar<8, 3> > RT;
std::cout << "sizeof rtree: " << sizeof(RT) << std::endl;
for (;;)
{
std::vector<B> result;
result.reserve(100);
B result_one;
// packing test
{
clock_t::time_point start = clock_t::now();
RT t(values.begin(), values.end());
dur_t time = clock_t::now() - start;
std::cout << time << " - pack " << values_count << '\n';
{
clock_t::time_point start = clock_t::now();
size_t temp = 0;
for (size_t i = 0 ; i < queries_count ; ++i )
{
float x = coords[i].first;
float y = coords[i].second;
result.clear();
t.query(bgi::intersects(B(P(x - 10, y - 10), P(x + 10, y + 10))), std::back_inserter(result));
temp += result.size();
}
dur_t time = clock_t::now() - start;
std::cout << time << " - query(B) " << queries_count << " found " << temp << '\n';
}
}
RT t;
// inserting test
{
clock_t::time_point start = clock_t::now();
for (size_t i = 0 ; i < values_count ; ++i )
{
float x = coords[i].first;
float y = coords[i].second;
B b(P(x - 0.5f, y - 0.5f), P(x + 0.5f, y + 0.5f));
t.insert(b);
}
t.insert(values);
dur_t time = clock_t::now() - start;
std::cout << time << " - insert " << values_count << '\n';
}
std::vector<B> result;
result.reserve(100);
B result_one;
{
clock_t::time_point start = clock_t::now();

30
index/example/glut_vis.cpp
View File

@ -622,6 +622,36 @@ void keyboard(unsigned char key, int /*x*/, int /*y*/)
glutPostRedisplay();
}
else if ( current_line == "bulk" )
{
vect.clear();
for ( size_t i = 0 ; i < 35 ; ++i )
{
float x = ( rand() % 100 );
float y = ( rand() % 100 );
float w = ( rand() % 2 ) + 1;
float h = ( rand() % 2 ) + 1;
B b(P(x - w, y - h),P(x + w, y + h));
vect.push_back(b);
std::cout << "inserted: ";
bgi::detail::utilities::print_indexable(std::cout, b);
std::cout << '\n';
}
RTree t2(vect);
t = boost::move(t2);
std::cout << ( bgi::detail::rtree::utilities::are_boxes_ok(t) ? "boxes OK\n" : "WRONG BOXES!\n" );
std::cout << ( bgi::detail::rtree::utilities::are_levels_ok(t) ? "levels OK\n" : "WRONG LEVELS!\n" );
std::cout << "\n";
search_valid = false;
glutPostRedisplay();
}
else
{
if ( current_line == "knn" )

28
index/test/movable.hpp
View File

@ -1,15 +1,15 @@
//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2009.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// Boost.Geometry.Index varray
// Unit Test
// Copyright (c) 2009 Ion Gaztanaga
// Copyright (c) 2012-2013 Adam Wulkiewicz, Lodz, Poland.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/move for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_MOVE_TEST_MOVABLE_HPP
#define BOOST_MOVE_TEST_MOVABLE_HPP
#ifndef BOOST_GEOMETRY_INDEX_TEST_MOVABLE_HPP
#define BOOST_GEOMETRY_INDEX_TEST_MOVABLE_HPP
//[movable_definition
//header file "movable.hpp"
@ -39,10 +39,10 @@ public:
class copy_movable
{
BOOST_COPYABLE_AND_MOVABLE(copy_movable)
int value_;
size_t value_;
public:
copy_movable(int value = 1) : value_(value){}
copy_movable(size_t value = 1) : value_(value){}
//Move constructor and assignment
copy_movable(BOOST_RV_REF(copy_movable) m)
@ -89,4 +89,4 @@ struct has_nothrow_move<copy_movable>
} //namespace boost{
//]
#endif //BOOST_MOVE_TEST_MOVABLE_HPP
#endif //BOOST_GEOMETRY_INDEX_TEST_MOVABLE_HPP

30
index/test/varray.cpp
View File

@ -659,98 +659,98 @@ int test_main(int, char* [])
{
BOOST_CHECK(counting_value::count() == 0);
test_ctor_ndc<int, 10>();
test_ctor_ndc<size_t, 10>();
test_ctor_ndc<value_ndc, 10>();
test_ctor_ndc<counting_value, 10>();
BOOST_CHECK(counting_value::count() == 0);
test_ctor_ndc<shptr_value, 10>();
test_ctor_ndc<copy_movable, 10>();
test_ctor_nc<int, 10>(5);
test_ctor_nc<size_t, 10>(5);
test_ctor_nc<value_nc, 10>(5);
test_ctor_nc<counting_value, 10>(5);
BOOST_CHECK(counting_value::count() == 0);
test_ctor_nc<shptr_value, 10>(5);
test_ctor_nc<copy_movable, 10>(5);
test_ctor_nd<int, 10>(5, 1);
test_ctor_nd<size_t, 10>(5, 1);
test_ctor_nd<value_nd, 10>(5, value_nd(1));
test_ctor_nd<counting_value, 10>(5, counting_value(1));
BOOST_CHECK(counting_value::count() == 0);
test_ctor_nd<shptr_value, 10>(5, shptr_value(1));
test_ctor_nd<copy_movable, 10>(5, produce());
test_resize_nc<int, 10>(5);
test_resize_nc<size_t, 10>(5);
test_resize_nc<value_nc, 10>(5);
test_resize_nc<counting_value, 10>(5);
BOOST_CHECK(counting_value::count() == 0);
test_resize_nc<shptr_value, 10>(5);
test_resize_nc<copy_movable, 10>(5);
test_resize_nd<int, 10>(5, 1);
test_resize_nd<size_t, 10>(5, 1);
test_resize_nd<value_nd, 10>(5, value_nd(1));
test_resize_nd<counting_value, 10>(5, counting_value(1));
BOOST_CHECK(counting_value::count() == 0);
test_resize_nd<shptr_value, 10>(5, shptr_value(1));
test_resize_nd<copy_movable, 10>(5, produce());
test_push_back_nd<int, 10>();
test_push_back_nd<size_t, 10>();
test_push_back_nd<value_nd, 10>();
test_push_back_nd<counting_value, 10>();
BOOST_CHECK(counting_value::count() == 0);
test_push_back_nd<shptr_value, 10>();
test_push_back_nd<copy_movable, 10>();
test_pop_back_nd<int, 10>();
test_pop_back_nd<size_t, 10>();
test_pop_back_nd<value_nd, 10>();
test_pop_back_nd<counting_value, 10>();
BOOST_CHECK(counting_value::count() == 0);
test_pop_back_nd<shptr_value, 10>();
test_pop_back_nd<copy_movable, 10>();
test_copy_and_assign_nd<int, 10>(1);
test_copy_and_assign_nd<size_t, 10>(1);
test_copy_and_assign_nd<value_nd, 10>(value_nd(1));
test_copy_and_assign_nd<counting_value, 10>(counting_value(1));
BOOST_CHECK(counting_value::count() == 0);
test_copy_and_assign_nd<shptr_value, 10>(shptr_value(1));
test_copy_and_assign_nd<copy_movable, 10>(produce());
test_iterators_nd<int, 10>();
test_iterators_nd<size_t, 10>();
test_iterators_nd<value_nd, 10>();
test_iterators_nd<counting_value, 10>();
BOOST_CHECK(counting_value::count() == 0);
test_iterators_nd<shptr_value, 10>();
test_iterators_nd<copy_movable, 10>();
test_erase_nd<int, 10>();
test_erase_nd<size_t, 10>();
test_erase_nd<value_nd, 10>();
test_erase_nd<counting_value, 10>();
BOOST_CHECK(counting_value::count() == 0);
test_erase_nd<shptr_value, 10>();
test_erase_nd<copy_movable, 10>();
test_insert_nd<int, 10>(50);
test_insert_nd<size_t, 10>(50);
test_insert_nd<value_nd, 10>(value_nd(50));
test_insert_nd<counting_value, 10>(counting_value(50));
BOOST_CHECK(counting_value::count() == 0);
test_insert_nd<shptr_value, 10>(shptr_value(50));
test_insert_nd<copy_movable, 10>(produce());
test_capacity_0_nd<int>();
test_capacity_0_nd<size_t>();
test_capacity_0_nd<value_nd>();
test_capacity_0_nd<counting_value>();
BOOST_CHECK(counting_value::count() == 0);
test_capacity_0_nd<shptr_value>();
test_capacity_0_nd<copy_movable>();
test_exceptions_nd<int, 10>();
test_exceptions_nd<size_t, 10>();
test_exceptions_nd<value_nd, 10>();
test_exceptions_nd<counting_value, 10>();
BOOST_CHECK(counting_value::count() == 0);
test_exceptions_nd<shptr_value, 10>();
test_exceptions_nd<copy_movable, 10>();
test_swap_and_move_nd<int, 10>();
test_swap_and_move_nd<size_t, 10>();
test_swap_and_move_nd<value_nd, 10>();
test_swap_and_move_nd<counting_value, 10>();
BOOST_CHECK(counting_value::count() == 0);
@ -763,7 +763,7 @@ int test_main(int, char* [])
test_emplace_2p<counting_value, 10>();
BOOST_CHECK(counting_value::count() == 0);
test_sv_elem<int, 10>(50);
test_sv_elem<size_t, 10>(50);
test_sv_elem<value_nd, 10>(value_nd(50));
test_sv_elem<counting_value, 10>(counting_value(50));
BOOST_CHECK(counting_value::count() == 0);

22
index/test/varray_test.hpp
View File

@ -19,38 +19,38 @@
class value_ndc
{
public:
explicit value_ndc(int a) : aa(a) {}
explicit value_ndc(size_t a) : aa(a) {}
~value_ndc() {}
bool operator==(value_ndc const& v) const { return aa == v.aa; }
bool operator<(value_ndc const& v) const { return aa < v.aa; }
private:
value_ndc(value_ndc const&) {}
value_ndc & operator=(value_ndc const&) { return *this; }
int aa;
size_t aa;
};
class value_nd
{
public:
explicit value_nd(int a) : aa(a) {}
explicit value_nd(size_t a) : aa(a) {}
~value_nd() {}
bool operator==(value_nd const& v) const { return aa == v.aa; }
bool operator<(value_nd const& v) const { return aa < v.aa; }
private:
int aa;
size_t aa;
};
class value_nc
{
public:
explicit value_nc(int a = 0) : aa(a) {}
explicit value_nc(size_t a = 0) : aa(a) {}
~value_nc() {}
bool operator==(value_nc const& v) const { return aa == v.aa; }
bool operator<(value_nc const& v) const { return aa < v.aa; }
private:
value_nc(value_nc const&) {}
value_nc & operator=(value_ndc const&) { return *this; }
int aa;
size_t aa;
};
class counting_value
@ -58,7 +58,7 @@ class counting_value
BOOST_COPYABLE_AND_MOVABLE(counting_value)
public:
explicit counting_value(int a = 0, int b = 0) : aa(a), bb(b) { ++c(); }
explicit counting_value(size_t a = 0, size_t b = 0) : aa(a), bb(b) { ++c(); }
counting_value(counting_value const& v) : aa(v.aa), bb(v.bb) { ++c(); }
counting_value(BOOST_RV_REF(counting_value) p) : aa(p.aa), bb(p.bb) { p.aa = 0; p.bb = 0; ++c(); } // Move constructor
counting_value& operator=(BOOST_RV_REF(counting_value) p) { aa = p.aa; p.aa = 0; bb = p.bb; p.bb = 0; return *this; } // Move assignment
@ -70,7 +70,7 @@ public:
private:
static size_t & c() { static size_t co = 0; return co; }
int aa, bb;
size_t aa, bb;
};
namespace boost {
@ -85,13 +85,13 @@ struct has_nothrow_move<counting_value>
class shptr_value
{
typedef boost::shared_ptr<int> Ptr;
typedef boost::shared_ptr<size_t> Ptr;
public:
explicit shptr_value(int a = 0) : m_ptr(new int(a)) {}
explicit shptr_value(size_t a = 0) : m_ptr(new size_t(a)) {}
bool operator==(shptr_value const& v) const { return *m_ptr == *(v.m_ptr); }
bool operator<(shptr_value const& v) const { return *m_ptr < *(v.m_ptr); }
private:
boost::shared_ptr<int> m_ptr;
boost::shared_ptr<size_t> m_ptr;
};
#endif // BOOST_GEOMETRY_INDEX_TEST_VARRAY_TEST_HPP