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