]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /*-----------------------------------------------------------------------------+ |
2 | Copyright (c) 2008-2009: Joachim Faulhaber | |
3 | +------------------------------------------------------------------------------+ | |
4 | Distributed under the Boost Software License, Version 1.0. | |
5 | (See accompanying file LICENCE.txt or copy at | |
6 | http://www.boost.org/LICENSE_1_0.txt) | |
7 | +-----------------------------------------------------------------------------*/ | |
8 | #ifndef LIBS_ICL_TEST_TEST_INTERVAL_SET_MIXED_HPP_JOFA_090702 | |
9 | #define LIBS_ICL_TEST_TEST_INTERVAL_SET_MIXED_HPP_JOFA_090702 | |
10 | ||
11 | template <class T> | |
12 | void interval_set_mixed_ctor_4_ordered_types() | |
13 | { | |
14 | typedef interval_set<T> IntervalSetT; | |
15 | typedef typename IntervalSetT::interval_type IntervalT; | |
16 | ||
17 | T v0 = boost::icl::identity_element<T>::value(); | |
18 | ||
19 | split_interval_set<T> split_set(v0); | |
20 | separate_interval_set<T> sep_set(split_set); | |
21 | interval_set<T> join_set(sep_set); | |
22 | ||
23 | BOOST_CHECK_EQUAL( hull(split_set).lower(), hull(sep_set).lower() ); | |
24 | BOOST_CHECK_EQUAL( hull(split_set).lower(), hull(join_set).lower() ); | |
25 | } | |
26 | ||
27 | template <class T> | |
28 | void interval_set_mixed_equal_4_ordered_types() | |
29 | { | |
30 | typedef interval_set<T> IntervalSetT; | |
31 | typedef typename IntervalSetT::interval_type IntervalT; | |
32 | ||
33 | T v0 = boost::icl::identity_element<T>::value(); | |
34 | ||
35 | split_interval_set<T> split_empty, split_single(v0); | |
36 | separate_interval_set<T> sep_empty, sep_single(v0); | |
37 | interval_set<T> join_empty, join_single(v0); | |
38 | ||
39 | // mixed ==-equality is a strange thing. Most times is does not | |
40 | // make sense. It is better to allow only for same type == equality. | |
41 | BOOST_CHECK_EQUAL( split_empty == split_empty, true ); | |
42 | BOOST_CHECK_EQUAL( sep_empty == sep_empty, true ); | |
43 | BOOST_CHECK_EQUAL( join_empty == join_empty, true ); | |
44 | ||
45 | // There were Problems with operator== and emtpy sets. | |
46 | BOOST_CHECK_EQUAL( split_empty == split_single, false ); | |
47 | BOOST_CHECK_EQUAL( sep_empty == sep_single, false ); | |
48 | BOOST_CHECK_EQUAL( join_empty == join_single, false ); | |
49 | ||
50 | BOOST_CHECK_EQUAL( split_single == split_empty, false ); | |
51 | BOOST_CHECK_EQUAL( sep_single == sep_empty, false ); | |
52 | BOOST_CHECK_EQUAL( join_single == join_empty, false ); | |
53 | ||
54 | BOOST_CHECK_EQUAL( is_element_equal(split_empty, split_empty), true ); | |
55 | BOOST_CHECK_EQUAL( is_element_equal(split_empty, sep_empty), true ); | |
56 | BOOST_CHECK_EQUAL( is_element_equal(split_empty, join_empty), true ); | |
57 | ||
58 | BOOST_CHECK_EQUAL( is_element_equal(sep_empty, split_empty), true ); | |
59 | BOOST_CHECK_EQUAL( is_element_equal(sep_empty, sep_empty), true ); | |
60 | BOOST_CHECK_EQUAL( is_element_equal(sep_empty, join_empty), true ); | |
61 | ||
62 | BOOST_CHECK_EQUAL( is_element_equal(join_empty, split_empty), true ); | |
63 | BOOST_CHECK_EQUAL( is_element_equal(join_empty, sep_empty), true ); | |
64 | BOOST_CHECK_EQUAL( is_element_equal(join_empty, join_empty), true ); | |
65 | ||
66 | //-------------------------------------------------------------------------- | |
67 | BOOST_CHECK_EQUAL( is_element_equal(split_empty, split_single), false ); | |
68 | BOOST_CHECK_EQUAL( is_element_equal(split_empty, sep_single), false ); | |
69 | BOOST_CHECK_EQUAL( is_element_equal(split_empty, join_single), false ); | |
70 | ||
71 | BOOST_CHECK_EQUAL( is_element_equal(sep_empty, split_single), false ); | |
72 | BOOST_CHECK_EQUAL( is_element_equal(sep_empty, sep_single), false ); | |
73 | BOOST_CHECK_EQUAL( is_element_equal(sep_empty, join_single), false ); | |
74 | ||
75 | BOOST_CHECK_EQUAL( is_element_equal(join_empty, split_single), false ); | |
76 | BOOST_CHECK_EQUAL( is_element_equal(join_empty, sep_single), false ); | |
77 | BOOST_CHECK_EQUAL( is_element_equal(join_empty, join_single), false ); | |
78 | ||
79 | //-------------------------------------------------------------------------- | |
80 | BOOST_CHECK_EQUAL( is_element_equal(split_single, split_empty), false ); | |
81 | BOOST_CHECK_EQUAL( is_element_equal(split_single, sep_empty), false ); | |
82 | BOOST_CHECK_EQUAL( is_element_equal(split_single, join_empty), false ); | |
83 | ||
84 | BOOST_CHECK_EQUAL( is_element_equal(sep_single, split_empty), false ); | |
85 | BOOST_CHECK_EQUAL( is_element_equal(sep_single, sep_empty), false ); | |
86 | BOOST_CHECK_EQUAL( is_element_equal(sep_single, join_empty), false ); | |
87 | ||
88 | BOOST_CHECK_EQUAL( is_element_equal(join_single, split_empty), false ); | |
89 | BOOST_CHECK_EQUAL( is_element_equal(join_single, sep_empty), false ); | |
90 | BOOST_CHECK_EQUAL( is_element_equal(join_single, join_empty), false ); | |
91 | ||
92 | } | |
93 | ||
94 | template <class T> | |
95 | void interval_set_mixed_assign_4_ordered_types() | |
96 | { | |
97 | typedef interval_set<T> IntervalSetT; | |
98 | typedef typename IntervalSetT::interval_type IntervalT; | |
99 | ||
100 | T v0 = boost::icl::identity_element<T>::value(); | |
101 | T v1 = unit_element<T>::value(); | |
102 | ||
103 | split_interval_set<T> split_set; | |
104 | separate_interval_set<T> sep_set; | |
105 | interval_set<T> join_set; | |
106 | split_set.add(v0); | |
107 | sep_set = split_set; | |
108 | join_set = sep_set; | |
109 | ||
110 | BOOST_CHECK_EQUAL( hull(split_set).lower(), hull(sep_set).lower() ); | |
111 | BOOST_CHECK_EQUAL( hull(split_set).lower(), hull(join_set).lower() ); | |
112 | ||
113 | split_interval_set<T> split_self = split_interval_set<T>().add(v0); | |
114 | separate_interval_set<T> sep_self = separate_interval_set<T>().add(v0).add(v1); | |
115 | interval_set<T> join_self = interval_set<T>().add(v1); | |
116 | ||
117 | split_self = split_self; | |
118 | sep_self = sep_self; | |
119 | join_self = join_self; | |
120 | ||
121 | BOOST_CHECK_EQUAL( split_self, split_self ); | |
122 | BOOST_CHECK_EQUAL( sep_self, sep_self ); | |
123 | BOOST_CHECK_EQUAL( join_self, join_self ); | |
124 | } | |
125 | ||
126 | template <class T> | |
127 | void interval_set_mixed_ctor_4_bicremental_types() | |
128 | { | |
129 | typedef interval_set<T> IntervalSetT; | |
130 | typedef typename IntervalSetT::interval_type IntervalT; | |
131 | ||
132 | T v1 = make<T>(1); | |
133 | T v2 = make<T>(2); | |
134 | T v3 = make<T>(3); | |
135 | T v4 = make<T>(4); | |
136 | T v5 = make<T>(5); | |
137 | ||
138 | IntervalT I1_3D = IntervalT::right_open(v1,v3); | |
139 | IntervalT I2_4D = IntervalT::right_open(v2,v4); | |
140 | IntervalT I4_5D = IntervalT::right_open(v4,v5); | |
141 | ||
142 | split_interval_set<T> split_set; | |
143 | split_set.add(I1_3D).add(I2_4D).add(I4_5D); | |
144 | BOOST_CHECK_EQUAL( split_set.iterative_size(), 4 ); | |
145 | separate_interval_set<T> sep_set(split_set); | |
146 | BOOST_CHECK_EQUAL( sep_set.iterative_size(), 4 ); | |
147 | interval_set<T> join_set(split_set); | |
148 | BOOST_CHECK_EQUAL( join_set.iterative_size(), 1 ); | |
149 | ||
150 | separate_interval_set<T> sep_set2; | |
151 | sep_set2.add(I1_3D).add(I2_4D).add(I4_5D); | |
152 | BOOST_CHECK_EQUAL( sep_set2.iterative_size(), 2 ); | |
153 | split_interval_set<T> split_set2(sep_set2); | |
154 | BOOST_CHECK_EQUAL( split_set2.iterative_size(), 2 ); | |
155 | interval_set<T> join_set2(sep_set2); | |
156 | BOOST_CHECK_EQUAL( join_set2.iterative_size(), 1 ); | |
157 | } | |
158 | ||
159 | template <class T> | |
160 | void interval_set_mixed_assign_4_bicremental_types() | |
161 | { | |
162 | typedef interval_set<T> IntervalSetT; | |
163 | typedef typename IntervalSetT::interval_type IntervalT; | |
164 | ||
165 | T v1 = make<T>(1); | |
166 | T v2 = make<T>(2); | |
167 | T v3 = make<T>(3); | |
168 | T v4 = make<T>(4); | |
169 | T v5 = make<T>(5); | |
170 | ||
171 | IntervalT I1_3D = IntervalT::right_open(v1,v3); | |
172 | IntervalT I2_4D = IntervalT::right_open(v2,v4); | |
173 | IntervalT I4_5D = IntervalT::right_open(v4,v5); | |
174 | ||
175 | split_interval_set<T> split_set; | |
176 | split_set.add(I1_3D).add(I2_4D).add(I4_5D); | |
177 | BOOST_CHECK_EQUAL( split_set.iterative_size(), 4 ); | |
178 | separate_interval_set<T> sep_set; | |
179 | sep_set = split_set; | |
180 | BOOST_CHECK_EQUAL( sep_set.iterative_size(), 4 ); | |
181 | interval_set<T> join_set; | |
182 | join_set = split_set; | |
183 | BOOST_CHECK_EQUAL( join_set.iterative_size(), 1 ); | |
184 | ||
185 | separate_interval_set<T> sep_set2; | |
186 | sep_set2.add(I1_3D).add(I2_4D).add(I4_5D); | |
187 | BOOST_CHECK_EQUAL( sep_set2.iterative_size(), 2 ); | |
188 | split_interval_set<T> split_set2; | |
189 | split_set2 = sep_set2; | |
190 | BOOST_CHECK_EQUAL( split_set2.iterative_size(), 2 ); | |
191 | interval_set<T> join_set2; | |
192 | join_set2 = sep_set2; | |
193 | BOOST_CHECK_EQUAL( join_set2.iterative_size(), 1 ); | |
194 | } | |
195 | ||
196 | ||
197 | template <class T> | |
198 | void interval_set_mixed_equal_4_bicremental_types() | |
199 | { | |
200 | typedef interval_set<T> IntervalSetT; | |
201 | typedef typename IntervalSetT::interval_type IntervalT; | |
202 | ||
203 | T v1 = make<T>(1); | |
204 | T v2 = make<T>(2); | |
205 | T v3 = make<T>(3); | |
206 | T v4 = make<T>(4); | |
207 | T v5 = make<T>(5); | |
208 | ||
209 | IntervalT I1_3D = IntervalT::right_open(v1,v3); | |
210 | IntervalT I2_4D = IntervalT::right_open(v2,v4); | |
211 | IntervalT I4_5D = IntervalT::right_open(v4,v5); | |
212 | ||
213 | interval_set<T> join_set; | |
214 | join_set.add(I1_3D).add(I2_4D).add(I4_5D); | |
215 | interval_set<T> join_set2 = join_set; | |
216 | BOOST_CHECK_EQUAL( join_set, join_set2 ); | |
217 | BOOST_CHECK_EQUAL( is_element_equal(join_set, join_set2), true ); | |
218 | ||
219 | separate_interval_set<T> sep_set; | |
220 | sep_set.add(I1_3D).add(I2_4D).add(I4_5D); | |
221 | ||
222 | separate_interval_set<T> sep_set2 = sep_set; | |
223 | BOOST_CHECK_EQUAL( sep_set, sep_set2 ); | |
224 | BOOST_CHECK_EQUAL( is_element_equal(sep_set2, sep_set), true ); | |
225 | ||
226 | split_interval_set<T> split_set; | |
227 | split_set.add(I1_3D).add(I2_4D).add(I4_5D); | |
228 | split_interval_set<T> split_set2 = split_set; | |
229 | BOOST_CHECK_EQUAL( split_set, split_set2 ); | |
230 | BOOST_CHECK_EQUAL( is_element_equal(split_set2, split_set), true ); | |
231 | ||
232 | BOOST_CHECK_EQUAL( is_element_equal(split_set, join_set), true ); | |
233 | BOOST_CHECK_EQUAL( is_element_equal(split_set, sep_set), true ); | |
234 | BOOST_CHECK_EQUAL( is_element_equal(join_set, sep_set), true ); | |
235 | BOOST_CHECK_EQUAL( is_element_equal(join_set, split_set), true ); | |
236 | BOOST_CHECK_EQUAL( is_element_equal(sep_set, join_set), true ); | |
237 | BOOST_CHECK_EQUAL( is_element_equal(sep_set, split_set), true ); | |
238 | } | |
239 | ||
240 | template <class T> | |
241 | void interval_set_mixed_contains_4_bicremental_types() | |
242 | { | |
243 | typedef interval_set<T> IntervalSetT; | |
244 | typedef typename IntervalSetT::interval_type IntervalT; | |
245 | ||
246 | split_interval_set<T> split_set; | |
247 | split_set.add(I_D(0,4)).add(I_D(4,8)); | |
248 | BOOST_CHECK_EQUAL( icl::contains(split_set, MK_v(4)), true ); | |
249 | BOOST_CHECK_EQUAL( icl::contains(split_set, C_D(2,5)), true ); | |
250 | ||
251 | interval_set<T> join_set_gap4(split_set.erase(MK_v(4))); | |
252 | BOOST_CHECK_EQUAL( icl::contains(join_set_gap4, MK_v(4)), false ); | |
253 | BOOST_CHECK_EQUAL( icl::contains(join_set_gap4, C_D(2,5)), false ); | |
254 | ||
255 | BOOST_CHECK_EQUAL( icl::contains(split_set, split_set), true ); | |
256 | BOOST_CHECK_EQUAL( icl::contains(split_set, join_set_gap4), true ); | |
257 | ||
258 | } | |
259 | ||
260 | template <class T> | |
261 | void interval_set_mixed_add_4_bicremental_types() | |
262 | { | |
263 | typedef interval_set<T> IntervalSetT; | |
264 | typedef typename IntervalSetT::interval_type IntervalT; | |
265 | ||
266 | T v1 = make<T>(1); | |
267 | T v2 = make<T>(2); | |
268 | T v3 = make<T>(3); | |
269 | T v4 = make<T>(4); | |
270 | T v5 = make<T>(5); | |
271 | ||
272 | IntervalT I1_3D = IntervalT::right_open(v1,v3); | |
273 | IntervalT I2_4D = IntervalT::right_open(v2,v4); | |
274 | IntervalT I4_5D = IntervalT::right_open(v4,v5); | |
275 | ||
276 | split_interval_set<T> split_set; | |
277 | split_set.add(I1_3D).add(I2_4D); | |
278 | split_set += I4_5D; | |
279 | BOOST_CHECK_EQUAL( split_set.iterative_size(), 4 ); | |
280 | separate_interval_set<T> sep_set; | |
281 | sep_set += split_set; | |
282 | BOOST_CHECK_EQUAL( sep_set.iterative_size(), 4 ); | |
283 | interval_set<T> join_set; | |
284 | join_set += split_set; | |
285 | BOOST_CHECK_EQUAL( join_set.iterative_size(), 1 ); | |
286 | ||
287 | separate_interval_set<T> sep_set2; | |
288 | sep_set2.add(I1_3D).add(I2_4D); | |
289 | sep_set2 += I4_5D; | |
290 | BOOST_CHECK_EQUAL( sep_set2.iterative_size(), 2 ); | |
291 | split_interval_set<T> split_set2; | |
292 | split_set2 += sep_set2; | |
293 | BOOST_CHECK_EQUAL( split_set2.iterative_size(), 2 ); | |
294 | interval_set<T> join_set2; | |
295 | join_set2 += sep_set2; | |
296 | BOOST_CHECK_EQUAL( join_set2.iterative_size(), 1 ); | |
297 | ||
298 | interval_set<T> join_set3; | |
299 | join_set3.add(v1).add(v3); | |
300 | join_set3 += v5; | |
301 | BOOST_CHECK_EQUAL( join_set3.iterative_size(), 3 ); | |
302 | split_interval_set<T> split_set3; | |
303 | split_set3 += join_set3; | |
304 | BOOST_CHECK_EQUAL( split_set3.iterative_size(), 3 ); | |
305 | separate_interval_set<T> sep_set3; | |
306 | sep_set3 += join_set3; | |
307 | BOOST_CHECK_EQUAL( join_set3.iterative_size(), 3 ); | |
308 | } | |
309 | ||
310 | template <class T> | |
311 | void interval_set_mixed_subtract_4_bicremental_types() | |
312 | { | |
313 | typedef interval_set<T> IntervalSetT; | |
314 | typedef typename IntervalSetT::interval_type IntervalT; | |
315 | ||
316 | T v0 = make<T>(0); | |
317 | T v2 = make<T>(2); | |
318 | T v3 = make<T>(3); | |
319 | T v4 = make<T>(4); | |
320 | T v5 = make<T>(5); | |
321 | T v6 = make<T>(6); | |
322 | T v7 = make<T>(7); | |
323 | T v8 = make<T>(8); | |
324 | T v9 = make<T>(9); | |
325 | ||
326 | IntervalT I0_4D = IntervalT::right_open(v0,v4); | |
327 | IntervalT I2_6D = IntervalT::right_open(v2,v6); | |
328 | IntervalT I3_6D = IntervalT::right_open(v3,v6); | |
329 | IntervalT I5_7D = IntervalT::right_open(v5,v7); | |
330 | IntervalT I7_8D = IntervalT::right_open(v7,v8); | |
331 | IntervalT I8_9D = IntervalT::right_open(v8,v9); | |
332 | IntervalT I8_9I = IntervalT::closed(v8,v9); | |
333 | ||
334 | split_interval_set<T> split_set; | |
335 | split_set.add(I0_4D).add(I2_6D).add(I5_7D).add(I7_8D).add(I8_9I); | |
336 | BOOST_CHECK_EQUAL( split_set.iterative_size(), 7 ); | |
337 | ||
338 | separate_interval_set<T> sep_set; | |
339 | sep_set.add(I0_4D).add(I2_6D).add(I5_7D).add(I7_8D).add(I8_9I); | |
340 | BOOST_CHECK_EQUAL( sep_set.iterative_size(), 3 ); | |
341 | ||
342 | interval_set<T> join_set; | |
343 | join_set.add(I0_4D).add(I2_6D).add(I5_7D).add(I7_8D).add(I8_9I); | |
344 | BOOST_CHECK_EQUAL( join_set.iterative_size(), 1 ); | |
345 | ||
346 | // Make sets to be subtracted | |
347 | split_interval_set<T> split_sub; | |
348 | split_sub.add(I3_6D).add(I8_9D); | |
349 | ||
350 | separate_interval_set<T> sep_sub; | |
351 | sep_sub.add(I3_6D).add(I8_9D); | |
352 | ||
353 | interval_set<T> join_sub; | |
354 | join_sub.add(I3_6D).add(I8_9D); | |
355 | ||
356 | //-------------------------------------------------------------------------- | |
357 | // Test for split_interval_set | |
358 | split_interval_set<T> split_diff = split_set; | |
359 | separate_interval_set<T> sep_diff = sep_set; | |
360 | interval_set<T> join_diff = join_set; | |
361 | ||
362 | //subtraction combinations | |
363 | split_diff -= split_sub; | |
364 | sep_diff -= split_sub; | |
365 | join_diff -= split_sub; | |
366 | ||
367 | BOOST_CHECK_EQUAL( split_diff.iterative_size(), 5 ); | |
368 | BOOST_CHECK_EQUAL( sep_diff.iterative_size(), 4 ); | |
369 | BOOST_CHECK_EQUAL( join_diff.iterative_size(), 3 ); | |
370 | ||
371 | BOOST_CHECK_EQUAL( is_element_equal(split_diff, split_diff), true ); | |
372 | BOOST_CHECK_EQUAL( is_element_equal(split_diff, sep_diff), true ); | |
373 | BOOST_CHECK_EQUAL( is_element_equal(split_diff, join_diff), true ); | |
374 | BOOST_CHECK_EQUAL( is_element_equal(sep_diff, split_diff), true ); | |
375 | BOOST_CHECK_EQUAL( is_element_equal(join_diff, split_diff), true ); | |
376 | ||
377 | //-------------------------------------------------------------------------- | |
378 | // Test for separate_interval_set. Reinitialize | |
379 | split_diff = split_set; | |
380 | sep_diff = sep_set; | |
381 | join_diff = join_set; | |
382 | ||
383 | //subtraction combinations | |
384 | split_diff -= sep_sub; | |
385 | sep_diff -= sep_sub; | |
386 | join_diff -= sep_sub; | |
387 | ||
388 | BOOST_CHECK_EQUAL( split_diff.iterative_size(), 5 ); | |
389 | BOOST_CHECK_EQUAL( sep_diff.iterative_size(), 4 ); | |
390 | BOOST_CHECK_EQUAL( join_diff.iterative_size(), 3 ); | |
391 | ||
392 | BOOST_CHECK_EQUAL( is_element_equal(sep_diff, sep_diff), true ); | |
393 | BOOST_CHECK_EQUAL( is_element_equal(sep_diff, split_diff), true ); | |
394 | BOOST_CHECK_EQUAL( is_element_equal(sep_diff, join_diff), true ); | |
395 | BOOST_CHECK_EQUAL( is_element_equal(split_diff, sep_diff), true ); | |
396 | BOOST_CHECK_EQUAL( is_element_equal(join_diff, sep_diff), true ); | |
397 | ||
398 | //-------------------------------------------------------------------------- | |
399 | // Test for interval_set. Reinitialize | |
400 | split_diff = split_set; | |
401 | sep_diff = sep_set; | |
402 | join_diff = join_set; | |
403 | ||
404 | //subtraction combinations | |
405 | split_diff -= join_sub; | |
406 | sep_diff -= join_sub; | |
407 | join_diff -= join_sub; | |
408 | ||
409 | BOOST_CHECK_EQUAL( split_diff.iterative_size(), 5 ); | |
410 | BOOST_CHECK_EQUAL( sep_diff.iterative_size(), 4 ); | |
411 | BOOST_CHECK_EQUAL( join_diff.iterative_size(), 3 ); | |
412 | ||
413 | BOOST_CHECK_EQUAL( is_element_equal(join_diff, join_diff), true ); | |
414 | BOOST_CHECK_EQUAL( is_element_equal(join_diff, split_diff), true ); | |
415 | BOOST_CHECK_EQUAL( is_element_equal(join_diff, sep_diff), true ); | |
416 | BOOST_CHECK_EQUAL( is_element_equal(sep_diff, join_diff), true ); | |
417 | BOOST_CHECK_EQUAL( is_element_equal(join_diff, join_diff), true ); | |
418 | } | |
419 | ||
420 | ||
421 | template <class T> | |
422 | void interval_set_mixed_erase_4_bicremental_types() | |
423 | { | |
424 | typedef interval_set<T> IntervalSetT; | |
425 | typedef typename IntervalSetT::interval_type IntervalT; | |
426 | ||
427 | T v0 = make<T>(0); | |
428 | T v2 = make<T>(2); | |
429 | T v3 = make<T>(3); | |
430 | T v4 = make<T>(4); | |
431 | T v5 = make<T>(5); | |
432 | T v6 = make<T>(6); | |
433 | T v7 = make<T>(7); | |
434 | T v8 = make<T>(8); | |
435 | T v9 = make<T>(9); | |
436 | ||
437 | IntervalT I0_4D = IntervalT::right_open(v0,v4); | |
438 | IntervalT I2_6D = IntervalT::right_open(v2,v6); | |
439 | IntervalT I3_6D = IntervalT::right_open(v3,v6); | |
440 | IntervalT I5_7D = IntervalT::right_open(v5,v7); | |
441 | IntervalT I7_8D = IntervalT::right_open(v7,v8); | |
442 | IntervalT I8_9D = IntervalT::right_open(v8,v9); | |
443 | IntervalT I8_9I = IntervalT::closed(v8,v9); | |
444 | ||
445 | split_interval_set<T> split_set; | |
446 | split_set.add(I0_4D).add(I2_6D).add(I5_7D).add(I7_8D).add(I8_9I); | |
447 | BOOST_CHECK_EQUAL( split_set.iterative_size(), 7 ); | |
448 | ||
449 | separate_interval_set<T> sep_set; | |
450 | sep_set.add(I0_4D).add(I2_6D).add(I5_7D).add(I7_8D).add(I8_9I); | |
451 | BOOST_CHECK_EQUAL( sep_set.iterative_size(), 3 ); | |
452 | ||
453 | interval_set<T> join_set; | |
454 | join_set.add(I0_4D).add(I2_6D).add(I5_7D).add(I7_8D).add(I8_9I); | |
455 | BOOST_CHECK_EQUAL( join_set.iterative_size(), 1 ); | |
456 | ||
457 | // Make sets to be subtracted | |
458 | split_interval_set<T> split_sub; | |
459 | split_sub.add(I3_6D).add(I8_9D); | |
460 | ||
461 | separate_interval_set<T> sep_sub; | |
462 | sep_sub.add(I3_6D).add(I8_9D); | |
463 | ||
464 | interval_set<T> join_sub; | |
465 | join_sub.add(I3_6D).add(I8_9D); | |
466 | ||
467 | //-------------------------------------------------------------------------- | |
468 | // Test for split_interval_set | |
469 | split_interval_set<T> split_diff = split_set; | |
470 | separate_interval_set<T> sep_diff = sep_set; | |
471 | interval_set<T> join_diff = join_set; | |
472 | ||
473 | //subtraction combinations | |
474 | erase(split_diff, split_sub); | |
475 | erase(sep_diff, split_sub); | |
476 | erase(join_diff, split_sub); | |
477 | ||
478 | BOOST_CHECK_EQUAL( split_diff.iterative_size(), 5 ); | |
479 | BOOST_CHECK_EQUAL( sep_diff.iterative_size(), 4 ); | |
480 | BOOST_CHECK_EQUAL( join_diff.iterative_size(), 3 ); | |
481 | ||
482 | BOOST_CHECK_EQUAL( is_element_equal(split_diff, split_diff), true ); | |
483 | BOOST_CHECK_EQUAL( is_element_equal(split_diff, sep_diff), true ); | |
484 | BOOST_CHECK_EQUAL( is_element_equal(split_diff, join_diff), true ); | |
485 | BOOST_CHECK_EQUAL( is_element_equal(sep_diff, split_diff), true ); | |
486 | BOOST_CHECK_EQUAL( is_element_equal(join_diff, split_diff), true ); | |
487 | ||
488 | //-------------------------------------------------------------------------- | |
489 | // Test for separate_interval_set. Reinitialize | |
490 | split_diff = split_set; | |
491 | sep_diff = sep_set; | |
492 | join_diff = join_set; | |
493 | ||
494 | //subtraction combinations | |
495 | erase(split_diff, sep_sub); | |
496 | erase(sep_diff, sep_sub); | |
497 | erase(join_diff, sep_sub); | |
498 | ||
499 | BOOST_CHECK_EQUAL( split_diff.iterative_size(), 5 ); | |
500 | BOOST_CHECK_EQUAL( sep_diff.iterative_size(), 4 ); | |
501 | BOOST_CHECK_EQUAL( join_diff.iterative_size(), 3 ); | |
502 | ||
503 | BOOST_CHECK_EQUAL( is_element_equal(sep_diff, sep_diff), true ); | |
504 | BOOST_CHECK_EQUAL( is_element_equal(sep_diff, split_diff), true ); | |
505 | BOOST_CHECK_EQUAL( is_element_equal(sep_diff, join_diff), true ); | |
506 | BOOST_CHECK_EQUAL( is_element_equal(split_diff, sep_diff), true ); | |
507 | BOOST_CHECK_EQUAL( is_element_equal(join_diff, sep_diff), true ); | |
508 | ||
509 | //-------------------------------------------------------------------------- | |
510 | // Test for interval_set. Reinitialize | |
511 | split_diff = split_set; | |
512 | sep_diff = sep_set; | |
513 | join_diff = join_set; | |
514 | ||
515 | //subtraction combinations | |
516 | erase(split_diff, join_sub); | |
517 | erase(sep_diff, join_sub); | |
518 | erase(join_diff, join_sub); | |
519 | ||
520 | BOOST_CHECK_EQUAL( split_diff.iterative_size(), 5 ); | |
521 | BOOST_CHECK_EQUAL( sep_diff.iterative_size(), 4 ); | |
522 | BOOST_CHECK_EQUAL( join_diff.iterative_size(), 3 ); | |
523 | ||
524 | BOOST_CHECK_EQUAL( is_element_equal(join_diff, join_diff), true ); | |
525 | BOOST_CHECK_EQUAL( is_element_equal(join_diff, split_diff), true ); | |
526 | BOOST_CHECK_EQUAL( is_element_equal(join_diff, sep_diff), true ); | |
527 | BOOST_CHECK_EQUAL( is_element_equal(sep_diff, join_diff), true ); | |
528 | BOOST_CHECK_EQUAL( is_element_equal(join_diff, join_diff), true ); | |
529 | } | |
530 | ||
531 | template <class T> | |
532 | void interval_set_mixed_basic_intersect_4_bicremental_types() | |
533 | { | |
534 | typedef interval_set<T> IntervalSetT; | |
535 | typedef typename IntervalSetT::interval_type IntervalT; | |
536 | ||
537 | T v0 = make<T>(0); | |
538 | T v1 = make<T>(1); | |
539 | T v2 = make<T>(2); | |
540 | T v3 = make<T>(3); | |
541 | T v6 = make<T>(6); | |
542 | T v7 = make<T>(7); | |
543 | T v8 = make<T>(8); | |
544 | T v9 = make<T>(9); | |
545 | ||
546 | IntervalT I0_3D = IntervalT::right_open(v0,v3); | |
547 | IntervalT I1_3D = IntervalT::right_open(v1,v3); | |
548 | IntervalT I1_8D = IntervalT::right_open(v1,v8); | |
549 | IntervalT I2_7D = IntervalT::right_open(v2,v7); | |
550 | IntervalT I2_3D = IntervalT::right_open(v2,v3); | |
551 | IntervalT I6_7D = IntervalT::right_open(v6,v7); | |
552 | IntervalT I6_8D = IntervalT::right_open(v6,v8); | |
553 | IntervalT I6_9D = IntervalT::right_open(v6,v9); | |
554 | ||
555 | //-------------------------------------------------------------------------- | |
556 | // split_interval_set | |
557 | //-------------------------------------------------------------------------- | |
558 | //split_A [0 3) [6 9) | |
559 | // &= [1 8) | |
560 | //split_AB -> [1 3) [6 8) | |
561 | // &= [2 7) | |
562 | // -> [2 3) [6 7) | |
563 | split_interval_set<T> split_A, split_B, split_AB, split_ab, split_ab2; | |
564 | ||
565 | split_A.add(I0_3D).add(I6_9D); | |
566 | split_AB = split_A; | |
567 | split_AB &= I1_8D; | |
568 | split_ab.add(I1_3D).add(I6_8D); | |
569 | ||
570 | BOOST_CHECK_EQUAL( split_AB, split_ab ); | |
571 | ||
572 | split_AB = split_A; | |
573 | (split_AB &= I1_8D) &= I2_7D; | |
574 | split_ab2.add(I2_3D).add(I6_7D); | |
575 | ||
576 | BOOST_CHECK_EQUAL( split_AB, split_ab2 ); | |
577 | ||
578 | ||
579 | //-------------------------------------------------------------------------- | |
580 | //split_A [0 3) [6 9) | |
581 | // &= 1 | |
582 | //split_AB -> [1] | |
583 | // += (1 7) | |
584 | // -> [1](1 7) | |
585 | split_A.add(I0_3D).add(I6_9D); | |
586 | split_AB = split_A; | |
587 | split_AB &= v1; | |
588 | split_ab.clear(); | |
589 | split_ab.add(v1); | |
590 | ||
591 | BOOST_CHECK_EQUAL( split_AB, split_ab ); | |
592 | ||
593 | split_AB = split_A; | |
594 | (split_AB &= v1) += IntervalT::open(v1,v7); | |
595 | split_ab2.clear(); | |
596 | split_ab2 += IntervalT::right_open(v1,v7); | |
597 | ||
598 | BOOST_CHECK_EQUAL( is_element_equal(split_AB, split_ab2), true ); | |
599 | } | |
600 | ||
601 | template <class T> | |
602 | void interval_set_mixed_intersect_4_bicremental_types() | |
603 | { | |
604 | typedef interval_set<T> IntervalSetT; | |
605 | typedef typename IntervalSetT::interval_type IntervalT; | |
606 | ||
607 | T v0 = make<T>(0); | |
608 | T v1 = make<T>(1); | |
609 | T v2 = make<T>(2); | |
610 | T v3 = make<T>(3); | |
611 | T v4 = make<T>(4); | |
612 | T v5 = make<T>(5); | |
613 | T v6 = make<T>(6); | |
614 | ||
615 | T v8 = make<T>(8); | |
616 | T v9 = make<T>(9); | |
617 | ||
618 | IntervalT I0_3D = IntervalT::right_open(v0,v3); | |
619 | IntervalT I1_2D = IntervalT::right_open(v1,v2); | |
620 | IntervalT I1_3D = IntervalT::right_open(v1,v3); | |
621 | IntervalT I2_3D = IntervalT::right_open(v2,v3); | |
622 | IntervalT I2_4D = IntervalT::right_open(v2,v4); | |
623 | IntervalT I5_8D = IntervalT::right_open(v5,v8); | |
624 | IntervalT I6_8D = IntervalT::right_open(v6,v8); | |
625 | IntervalT I6_9D = IntervalT::right_open(v6,v9); | |
626 | ||
627 | //-------------------------------------------------------------------------- | |
628 | // split_interval_set | |
629 | //-------------------------------------------------------------------------- | |
630 | //split_A [0 3) [6 9) | |
631 | //split_B &= [1 2)[2 4) [5 8) | |
632 | //split_AB -> [1 2)[2 3) [6 8) | |
633 | split_interval_set<T> split_A, split_B, split_AB, split_ab, split_ab_jn; | |
634 | separate_interval_set<T> sep_A, sep_B, sep_AB, sep_ab; | |
635 | interval_set<T> join_A, join_B, join_AB, join_ab; | |
636 | ||
637 | split_A.add(I0_3D).add(I6_9D); | |
638 | split_B.add(I1_2D).add(I2_4D).add(I5_8D); | |
639 | split_ab.add(I1_2D).add(I2_3D).add(I6_8D); | |
640 | split_ab_jn.add(I1_3D).add(I6_8D); | |
641 | split_AB = split_A; | |
642 | split_AB &= split_B; | |
643 | BOOST_CHECK_EQUAL( split_AB.iterative_size(), 3 ); | |
644 | BOOST_CHECK_EQUAL( split_AB, split_ab ); | |
645 | ||
646 | //split_A [0 3) [6 9) | |
647 | //sep_B &= [1 2)[2 4) [5 8) | |
648 | //split_AB -> [1 2)[2 3) [6 8) | |
649 | split_AB = split_A; | |
650 | sep_B = split_B; | |
651 | split_AB &= sep_B; | |
652 | BOOST_CHECK_EQUAL( split_AB.iterative_size(), 3 ); | |
653 | BOOST_CHECK_EQUAL( split_AB, split_ab ); | |
654 | ||
655 | //split_A [0 3) [6 9) | |
656 | //join_B &= [1 4) [5 8) | |
657 | //split_AB -> [1 3) [6 8) | |
658 | split_AB = split_A; | |
659 | join_B = split_B; | |
660 | split_AB &= join_B; | |
661 | ||
662 | BOOST_CHECK_EQUAL( split_AB.iterative_size(), 2 ); | |
663 | BOOST_CHECK_EQUAL( split_AB, split_ab_jn ); | |
664 | ||
665 | //-------------------------------------------------------------------------- | |
666 | // separate_interval_set | |
667 | //-------------------------------------------------------------------------- | |
668 | //sep_A [0 3) [6 9) | |
669 | //sep_B &= [1 2)[2 4) [5 8) | |
670 | //sep_AB -> [1 2)[2 3) [6 8) | |
671 | sep_ab = split_ab; | |
672 | BOOST_CHECK_EQUAL( sep_ab.iterative_size(), 3 ); | |
673 | ||
674 | sep_AB = split_A; | |
675 | sep_B = split_B; | |
676 | sep_AB &= sep_B; | |
677 | ||
678 | BOOST_CHECK_EQUAL( sep_AB.iterative_size(), 3 ); | |
679 | BOOST_CHECK_EQUAL( sep_AB, sep_ab ); | |
680 | ||
681 | //sep_A [0 3) [6 9) | |
682 | //split_B &= [1 2)[2 4) [5 8) | |
683 | //sep_AB -> [1 2)[2 3) [6 8) | |
684 | sep_AB = split_A; | |
685 | sep_AB &= split_B; | |
686 | ||
687 | BOOST_CHECK_EQUAL( sep_AB.iterative_size(), 3 ); | |
688 | BOOST_CHECK_EQUAL( sep_AB, sep_ab ); | |
689 | ||
690 | //sep_A [0 3) [6 9) | |
691 | //join_B &= [1 4) [5 8) | |
692 | //sep_AB -> [1 3) [6 8) | |
693 | separate_interval_set<T> sep_ab_jn = split_ab_jn; | |
694 | sep_AB = split_A; | |
695 | join_B = split_B; | |
696 | sep_AB &= join_B; | |
697 | ||
698 | BOOST_CHECK_EQUAL( sep_AB.iterative_size(), 2 ); | |
699 | BOOST_CHECK_EQUAL( sep_AB, sep_ab_jn ); | |
700 | ||
701 | //-------------------------------------------------------------------------- | |
702 | // separate_interval_set | |
703 | //-------------------------------------------------------------------------- | |
704 | //join_A [0 3) [6 9) | |
705 | //join_B &= [1 4) [5 8) | |
706 | //join_AB -> [1 3) [6 8) | |
707 | join_ab = split_ab; | |
708 | BOOST_CHECK_EQUAL( join_ab.iterative_size(), 2 ); | |
709 | ||
710 | join_AB = split_A; | |
711 | join_B = split_B; | |
712 | join_AB &= sep_B; | |
713 | ||
714 | BOOST_CHECK_EQUAL( join_AB.iterative_size(), 2 ); | |
715 | BOOST_CHECK_EQUAL( join_AB, join_ab ); | |
716 | ||
717 | //join_A [0 3) [6 9) | |
718 | //split_B &= [1 2)[2 4) [5 8) | |
719 | //join_AB -> [1 3) [6 8) | |
720 | join_AB = split_A; | |
721 | join_AB &= split_B; | |
722 | ||
723 | BOOST_CHECK_EQUAL( join_AB.iterative_size(), 2 ); | |
724 | BOOST_CHECK_EQUAL( join_AB, join_ab ); | |
725 | ||
726 | //join_A [0 3) [6 9) | |
727 | //sep_B &= [1 2)[2 4) [5 8) | |
728 | //join_AB -> [1 3) [6 8) | |
729 | join_AB = split_A; | |
730 | join_AB &= sep_B; | |
731 | ||
732 | BOOST_CHECK_EQUAL( join_AB.iterative_size(), 2 ); | |
733 | BOOST_CHECK_EQUAL( join_AB, join_ab ); | |
734 | ||
735 | } | |
736 | ||
737 | ||
738 | template <class T> | |
739 | void interval_set_mixed_disjoint_4_bicremental_types() | |
740 | { | |
741 | typedef interval_set<T> IntervalSetT; | |
742 | typedef typename IntervalSetT::interval_type IntervalT; | |
743 | ||
744 | T v0 = make<T>(0); | |
745 | T v2 = make<T>(2); | |
746 | T v3 = make<T>(3); | |
747 | T v4 = make<T>(4); | |
748 | T v6 = make<T>(6); | |
749 | ||
750 | IntervalT I0_2D = IntervalT::right_open(v0,v2); | |
751 | IntervalT I2_3D = IntervalT::right_open(v2,v3); | |
752 | IntervalT I3_4D = IntervalT::right_open(v3,v4); | |
753 | IntervalT I4_4I = IntervalT::closed(v4,v4); | |
754 | IntervalT C4_6D = IntervalT::open(v4,v6); | |
755 | IntervalT I6_6I = IntervalT::closed(v6,v6); | |
756 | ||
757 | //-------------------------------------------------------------------------- | |
758 | //split_A: [0 2) [4 4] [6 6] | |
759 | //split_B: [2 3)[3 4) (4 6) | |
760 | split_interval_set<T> split_A, split_B; | |
761 | ||
762 | split_A.add(I0_2D).add(I4_4I).add(I6_6I); | |
763 | split_B.add(I2_3D).add(I3_4D).add(C4_6D); | |
764 | ||
765 | separate_interval_set<T> sep_A(split_A), sep_B(split_B); | |
766 | interval_set<T> join_A(split_A), join_B(split_B); | |
767 | ||
768 | BOOST_CHECK_EQUAL( disjoint(split_A, split_B), true ); | |
769 | BOOST_CHECK_EQUAL( disjoint(split_A, sep_B), true ); | |
770 | BOOST_CHECK_EQUAL( disjoint(split_A, join_B), true ); | |
771 | ||
772 | BOOST_CHECK_EQUAL( disjoint(sep_A, split_B), true ); | |
773 | BOOST_CHECK_EQUAL( disjoint(sep_A, sep_B), true ); | |
774 | BOOST_CHECK_EQUAL( disjoint(sep_A, join_B), true ); | |
775 | ||
776 | BOOST_CHECK_EQUAL( disjoint(join_A, split_B), true ); | |
777 | BOOST_CHECK_EQUAL( disjoint(join_A, sep_B), true ); | |
778 | BOOST_CHECK_EQUAL( disjoint(join_A, join_B), true ); | |
779 | } | |
780 | ||
781 | template <class T> | |
782 | void interval_set_mixed_infix_plus_overload_4_bicremental_types() | |
783 | { | |
784 | typedef interval_set<T> IntervalSetT; | |
785 | typedef typename IntervalSetT::interval_type IntervalT; | |
786 | ||
787 | interval_set<T> join_a; | |
788 | separate_interval_set<T> sep_a; | |
789 | split_interval_set<T> split_a; | |
790 | ||
791 | join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9)); | |
792 | sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11)); | |
793 | split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11)); | |
794 | ||
795 | BOOST_CHECK_EQUAL(split_a + sep_a, sep_a + split_a ); | |
796 | BOOST_CHECK_EQUAL(split_a + join_a, join_a + split_a); | |
797 | BOOST_CHECK_EQUAL(sep_a + join_a, join_a + sep_a ); | |
798 | } | |
799 | ||
800 | template <class T> void interval_set_mixed_infix_pipe_overload_4_bicremental_types() | |
801 | { | |
802 | typedef interval_set<T> IntervalSetT; | |
803 | typedef typename IntervalSetT::interval_type IntervalT; | |
804 | ||
805 | interval_set<T> join_a; | |
806 | separate_interval_set<T> sep_a; | |
807 | split_interval_set<T> split_a; | |
808 | ||
809 | join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9)); | |
810 | sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11)); | |
811 | split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11)); | |
812 | ||
813 | BOOST_CHECK_EQUAL(split_a | sep_a, sep_a | split_a ); | |
814 | BOOST_CHECK_EQUAL(split_a | join_a, join_a | split_a); | |
815 | BOOST_CHECK_EQUAL(sep_a | join_a, join_a | sep_a ); | |
816 | } | |
817 | ||
818 | template <class T> | |
819 | void interval_set_mixed_infix_minus_overload_4_bicremental_types() | |
820 | { | |
821 | typedef interval_set<T> IntervalSetT; | |
822 | typedef typename IntervalSetT::interval_type IntervalT; | |
823 | ||
824 | interval_set<T> join_a, join_b; | |
825 | separate_interval_set<T> sep_a, sep_b; | |
826 | split_interval_set<T> split_a, split_b; | |
827 | ||
828 | join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9)); | |
829 | sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11)); | |
830 | split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11)); | |
831 | ||
832 | BOOST_CHECK_EQUAL(split_a - sep_a, (split_b = split_a) -= sep_a ); | |
833 | BOOST_CHECK_EQUAL(split_a - join_a, (split_b = split_a) -= join_a ); | |
834 | BOOST_CHECK_EQUAL(sep_a - join_a, (sep_b = sep_a) -= join_a ); | |
835 | ||
836 | BOOST_CHECK_EQUAL(sep_a - split_a, (sep_b = sep_a) -= split_a); | |
837 | BOOST_CHECK_EQUAL(join_a - split_a, (join_b = join_a) -= split_a); | |
838 | BOOST_CHECK_EQUAL(join_a - sep_a, (join_b = join_a) -= sep_a ); | |
839 | } | |
840 | ||
841 | template <class T> void interval_set_mixed_infix_et_overload_4_bicremental_types() | |
842 | { | |
843 | typedef interval_set<T> IntervalSetT; | |
844 | typedef typename IntervalSetT::interval_type IntervalT; | |
845 | ||
846 | interval_set<T> join_a; | |
847 | separate_interval_set<T> sep_a; | |
848 | split_interval_set<T> split_a; | |
849 | ||
850 | join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9)); | |
851 | sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11)); | |
852 | split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11)); | |
853 | ||
854 | BOOST_CHECK_EQUAL(split_a & sep_a, sep_a & split_a ); | |
855 | BOOST_CHECK_EQUAL(split_a & join_a, join_a & split_a); | |
856 | BOOST_CHECK_EQUAL(sep_a & join_a, join_a & sep_a ); | |
857 | } | |
858 | ||
859 | template <class T> void interval_set_mixed_infix_caret_overload_4_bicremental_types() | |
860 | { | |
861 | typedef interval_set<T> IntervalSetT; | |
862 | typedef typename IntervalSetT::interval_type IntervalT; | |
863 | ||
864 | interval_set<T> join_a; | |
865 | separate_interval_set<T> sep_a; | |
866 | split_interval_set<T> split_a; | |
867 | ||
868 | join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9)); | |
869 | sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11)); | |
870 | split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11)); | |
871 | ||
872 | BOOST_CHECK_EQUAL(split_a ^ sep_a, sep_a ^ split_a ); | |
873 | BOOST_CHECK_EQUAL(split_a ^ join_a, join_a ^ split_a); | |
874 | BOOST_CHECK_EQUAL(sep_a ^ join_a, join_a ^ sep_a ); | |
875 | } | |
876 | ||
877 | #endif // LIBS_ICL_TEST_TEST_INTERVAL_SET_MIXED_HPP_JOFA_090702 |