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>
interval_set_mixed_ctor_4_ordered_types()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>
interval_set_mixed_equal_4_ordered_types()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>
interval_set_mixed_assign_4_ordered_types()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>
interval_set_mixed_ctor_4_bicremental_types()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>
interval_set_mixed_assign_4_bicremental_types()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>
interval_set_mixed_equal_4_bicremental_types()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>
interval_set_mixed_contains_4_bicremental_types()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>
interval_set_mixed_add_4_bicremental_types()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>
interval_set_mixed_subtract_4_bicremental_types()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>
interval_set_mixed_erase_4_bicremental_types()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>
interval_set_mixed_basic_intersect_4_bicremental_types()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>
interval_set_mixed_intersect_4_bicremental_types()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>
interval_set_mixed_disjoint_4_bicremental_types()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>
interval_set_mixed_infix_plus_overload_4_bicremental_types()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
interval_set_mixed_infix_pipe_overload_4_bicremental_types()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>
interval_set_mixed_infix_minus_overload_4_bicremental_types()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
interval_set_mixed_infix_et_overload_4_bicremental_types()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
interval_set_mixed_infix_caret_overload_4_bicremental_types()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