]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | //---------------------------------------------------------------------------// |
2 | // Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> | |
3 | // | |
4 | // Distributed under the Boost Software License, Version 1.0 | |
5 | // See accompanying file LICENSE_1_0.txt or copy at | |
6 | // http://www.boost.org/LICENSE_1_0.txt | |
7 | // | |
8 | // See http://boostorg.github.com/compute for more information. | |
9 | //---------------------------------------------------------------------------// | |
10 | ||
11 | #define BOOST_TEST_MODULE TestStridedIterator | |
12 | #include <boost/test/unit_test.hpp> | |
13 | ||
14 | #include <iterator> | |
15 | ||
16 | #include <boost/type_traits.hpp> | |
17 | #include <boost/static_assert.hpp> | |
18 | ||
19 | #include <boost/compute/algorithm/copy.hpp> | |
20 | #include <boost/compute/container/vector.hpp> | |
b32b8144 | 21 | #include <boost/compute/iterator/buffer_iterator.hpp> |
7c673cae FG |
22 | #include <boost/compute/iterator/strided_iterator.hpp> |
23 | ||
24 | #include "check_macros.hpp" | |
25 | #include "context_setup.hpp" | |
26 | ||
b32b8144 FG |
27 | namespace bc = boost::compute; |
28 | ||
7c673cae FG |
29 | BOOST_AUTO_TEST_CASE(value_type) |
30 | { | |
31 | BOOST_STATIC_ASSERT(( | |
32 | boost::is_same< | |
33 | boost::compute::strided_iterator< | |
34 | boost::compute::buffer_iterator<int> | |
35 | >::value_type, | |
36 | int | |
37 | >::value | |
38 | )); | |
39 | BOOST_STATIC_ASSERT(( | |
40 | boost::is_same< | |
41 | boost::compute::strided_iterator< | |
42 | boost::compute::buffer_iterator<float> | |
43 | >::value_type, | |
44 | float | |
45 | >::value | |
46 | )); | |
47 | } | |
48 | ||
49 | BOOST_AUTO_TEST_CASE(base_type) | |
50 | { | |
51 | BOOST_STATIC_ASSERT(( | |
52 | boost::is_same< | |
53 | boost::compute::strided_iterator< | |
54 | boost::compute::buffer_iterator<int> | |
55 | >::base_type, | |
56 | boost::compute::buffer_iterator<int> | |
57 | >::value | |
58 | )); | |
59 | } | |
60 | ||
61 | BOOST_AUTO_TEST_CASE(distance) | |
62 | { | |
63 | int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; | |
64 | boost::compute::vector<int> vec(data, data + 8, queue); | |
65 | ||
66 | BOOST_CHECK_EQUAL( | |
67 | std::distance( | |
68 | boost::compute::make_strided_iterator(vec.begin(), 1), | |
69 | boost::compute::make_strided_iterator(vec.end(), 1) | |
70 | ), | |
71 | std::ptrdiff_t(8) | |
72 | ); | |
73 | BOOST_CHECK_EQUAL( | |
74 | std::distance( | |
75 | boost::compute::make_strided_iterator(vec.begin(), 2), | |
76 | boost::compute::make_strided_iterator(vec.end(), 2) | |
77 | ), | |
78 | std::ptrdiff_t(4) | |
79 | ); | |
80 | ||
81 | BOOST_CHECK_EQUAL( | |
82 | std::distance( | |
83 | boost::compute::make_strided_iterator(vec.begin(), 3), | |
84 | boost::compute::make_strided_iterator(vec.begin()+6, 3) | |
85 | ), | |
86 | std::ptrdiff_t(2) | |
87 | ); | |
88 | } | |
89 | ||
90 | BOOST_AUTO_TEST_CASE(copy) | |
91 | { | |
92 | boost::compute::int_ data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; | |
93 | boost::compute::vector<boost::compute::int_> vec(data, data + 8, queue); | |
94 | ||
95 | boost::compute::vector<boost::compute::int_> result(4, context); | |
96 | ||
97 | // copy every other element to result | |
98 | boost::compute::copy( | |
99 | boost::compute::make_strided_iterator(vec.begin(), 2), | |
100 | boost::compute::make_strided_iterator(vec.end(), 2), | |
101 | result.begin(), | |
102 | queue | |
103 | ); | |
104 | CHECK_RANGE_EQUAL(boost::compute::int_, 4, result, (1, 3, 5, 7)); | |
105 | ||
106 | // copy every 3rd element to result | |
107 | boost::compute::copy( | |
108 | boost::compute::make_strided_iterator(vec.begin(), 3), | |
109 | boost::compute::make_strided_iterator(vec.begin()+9, 3), | |
110 | result.begin(), | |
111 | queue | |
112 | ); | |
113 | CHECK_RANGE_EQUAL(boost::compute::int_, 3, result, (1, 4, 7)); | |
114 | } | |
115 | ||
116 | BOOST_AUTO_TEST_CASE(make_strided_iterator_end) | |
117 | { | |
118 | boost::compute::int_ data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; | |
119 | boost::compute::vector<boost::compute::int_> vec(data, data + 8, queue); | |
120 | ||
121 | // stride equals 3 | |
122 | typedef boost::compute::vector<boost::compute::int_>::iterator IterType; | |
123 | boost::compute::strided_iterator<IterType> end = | |
124 | boost::compute::make_strided_iterator_end(vec.begin(), | |
125 | vec.end(), | |
126 | 3); | |
127 | ||
128 | // end should be vec.begin() + 9 which is one step after last element | |
129 | // accessible through strided_iterator, i.e. vec.begin()+6 | |
130 | BOOST_CHECK(boost::compute::make_strided_iterator(vec.begin()+9, 3) == | |
131 | end); | |
132 | ||
133 | // stride equals 2 | |
134 | end = boost::compute::make_strided_iterator_end(vec.begin(), | |
135 | vec.end(), | |
136 | 2); | |
137 | // end should be vec.end(), because vector size is divisible by 2 | |
138 | BOOST_CHECK(boost::compute::make_strided_iterator(vec.end(), 2) == end); | |
139 | ||
140 | // stride equals 1000 | |
141 | end = boost::compute::make_strided_iterator_end(vec.begin(), | |
142 | vec.end(), | |
143 | 1000); | |
144 | // end should be vec.begin() + 1000, because stride > vector size | |
145 | BOOST_CHECK(boost::compute::make_strided_iterator(vec.begin()+1000, 1000) == | |
146 | end); | |
147 | ||
148 | ||
149 | // test boost::compute::make_strided_iterator_end with copy(..) | |
150 | ||
151 | boost::compute::vector<boost::compute::int_> result(4, context); | |
152 | ||
153 | // copy every other element to result | |
154 | boost::compute::copy( | |
155 | boost::compute::make_strided_iterator(vec.begin()+1, 2), | |
156 | boost::compute::make_strided_iterator_end(vec.begin()+1, vec.end(), 2), | |
157 | result.begin(), | |
158 | queue | |
159 | ); | |
160 | CHECK_RANGE_EQUAL(boost::compute::int_, 4, result, (2, 4, 6, 8)); | |
161 | } | |
162 | ||
b32b8144 FG |
163 | BOOST_AUTO_TEST_CASE(iterator_tag) |
164 | { | |
165 | typedef bc::buffer_iterator<bc::float_> i_type; | |
166 | ||
167 | BOOST_STATIC_ASSERT(( | |
168 | boost::is_same< | |
169 | std::iterator_traits< | |
170 | i_type | |
171 | >::iterator_category, | |
172 | std::iterator_traits< | |
173 | bc::strided_iterator<i_type> | |
174 | >::iterator_category | |
175 | >::value | |
176 | )); | |
177 | } | |
178 | ||
179 | BOOST_AUTO_TEST_CASE(std_distance) | |
180 | { | |
181 | bc::vector<bc::float_> vec( | |
182 | size_t(300), | |
183 | bc::float_(1.1f), | |
184 | queue | |
185 | ); | |
186 | ||
187 | bc::strided_iterator<bc::buffer_iterator<bc::float_> > begin(vec.begin(), 1); | |
188 | bc::strided_iterator<bc::buffer_iterator<bc::float_> > end(vec.end(), 1); | |
189 | ||
190 | BOOST_CHECK_EQUAL(std::distance(begin, end), 300); | |
191 | BOOST_CHECK_EQUAL(std::distance(end, begin), -300); | |
192 | } | |
193 | ||
7c673cae | 194 | BOOST_AUTO_TEST_SUITE_END() |