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_ICL_interval_map_mixed_hpp_JOFA_081005__
9 #define LIBS_ICL_TEST_TEST_ICL_interval_map_mixed_hpp_JOFA_081005__
10
11
12 //------------------------------------------------------------------------------
13 //- part1: Basic operations and predicates
14 //------------------------------------------------------------------------------
15
16 template <class T, class U>
interval_map_mixed_ctor_4_ordered_types()17 void interval_map_mixed_ctor_4_ordered_types()
18 {
19 typedef interval_map<T,U> IntervalMapT;
20 typedef split_interval_map<T,U> SplitIntervalMapT;
21
22 T v0 = boost::icl::identity_element<T>::value();
23 U u1 = unit_element<U>::value();
24
25 SplitIntervalMapT split_map(mapping_pair<T,U>(v0,u1));
26 //JODO: clang err: ctor ambiguous. Should compile
27 //JODO CLANG SplitIntervalMapT split_map(make_pair(v0,u1));
28 IntervalMapT join_map(split_map);
29
30 BOOST_CHECK_EQUAL( hull(split_map).lower(), hull(join_map).lower() );
31 BOOST_CHECK_EQUAL( hull(split_map).upper(), hull(join_map).upper() );
32 }
33
34 template <class T, class U>
interval_map_mixed_equal_4_ordered_types()35 void interval_map_mixed_equal_4_ordered_types()
36 {
37 typedef interval_map<T,U> IntervalMapT;
38 typedef split_interval_map<T,U> SplitIntervalMapT;
39 typedef typename IntervalMapT::interval_type IntervalT;
40
41 T v0 = boost::icl::identity_element<T>::value();
42 U u1 = unit_element<U>::value();
43
44 SplitIntervalMapT split_empty, split_single(mapping_pair<T,U>(v0,u1));
45 IntervalMapT join_empty, join_single(mapping_pair<T,U>(v0,u1));
46 //JODO CLANG SplitIntervalMapT split_empty, split_single(make_pair(v0,u1));
47 //JODO CLANG IntervalMapT join_empty, join_single(make_pair(v0,u1));
48
49 // mixed ==-equality is a strange thing. Most times is does not
50 // make sense. It is better to allow only for same type == equality.
51 BOOST_CHECK_EQUAL( split_empty == split_empty, true );
52 BOOST_CHECK_EQUAL( join_empty == join_empty, true );
53
54 // There were Problems with operator== and emtpy sets.
55 BOOST_CHECK_EQUAL( split_empty == split_single, false );
56 BOOST_CHECK_EQUAL( join_empty == join_single, false );
57
58 BOOST_CHECK_EQUAL( split_single == split_empty, false );
59 BOOST_CHECK_EQUAL( join_single == join_empty, false );
60
61 BOOST_CHECK_EQUAL( is_element_equal(split_empty, split_empty), true );
62 BOOST_CHECK_EQUAL( is_element_equal(split_empty, join_empty), true );
63
64 BOOST_CHECK_EQUAL( is_element_equal(join_empty, split_empty), true );
65 BOOST_CHECK_EQUAL( is_element_equal(join_empty, join_empty), true );
66
67 //--------------------------------------------------------------------------
68 BOOST_CHECK_EQUAL( is_element_equal(split_empty, split_single), false );
69 BOOST_CHECK_EQUAL( is_element_equal(split_empty, join_single), false );
70
71 BOOST_CHECK_EQUAL( is_element_equal(join_empty, split_single), false );
72 BOOST_CHECK_EQUAL( is_element_equal(join_empty, join_single), false );
73
74 BOOST_CHECK_EQUAL( is_element_equal(split_single, split_empty), false );
75 BOOST_CHECK_EQUAL( is_element_equal(split_single, join_empty), false );
76
77 BOOST_CHECK_EQUAL( is_element_equal(join_single, split_empty), false );
78 BOOST_CHECK_EQUAL( is_element_equal(join_single, join_empty), false );
79 }
80
81 template <class T, class U>
interval_map_mixed_assign_4_ordered_types()82 void interval_map_mixed_assign_4_ordered_types()
83 {
84 typedef interval_map<T,U> IntervalMapT;
85 typedef split_interval_map<T,U> SplitIntervalMapT;
86 typedef typename IntervalMapT::interval_type IntervalT;
87
88 T v0 = boost::icl::identity_element<T>::value();
89 T v1 = unit_element<T>::value();
90 U u1 = unit_element<U>::value();
91
92 mapping_pair<T,U> v0_u1(v0,u1);
93 mapping_pair<T,U> v1_u1(v1,u1);
94
95 SplitIntervalMapT split_map;
96 IntervalMapT join_map;
97 split_map.add(v0_u1); //NOTE: make_pair(v0,u1); fails
98 join_map = split_map; //=t T& T::operator=(const P&) ...
99
100
101 BOOST_CHECK_EQUAL( hull(split_map).lower(), hull(join_map).lower() );
102 BOOST_CHECK_EQUAL( hull(split_map).upper(), hull(join_map).upper() );
103
104 SplitIntervalMapT split_self = SplitIntervalMapT().add(v0_u1);
105 IntervalMapT join_self = IntervalMapT().add(v1_u1);
106
107 split_self = split_self;
108 join_self = join_self;
109
110 BOOST_CHECK_EQUAL( split_self, split_self );
111 BOOST_CHECK_EQUAL( join_self, join_self );
112 }
113
114 template <class T, class U>
interval_map_mixed_ctor_4_bicremental_types()115 void interval_map_mixed_ctor_4_bicremental_types()
116 {
117 typedef interval_map<T,U> IntervalMapT;
118 typedef split_interval_map<T,U> SplitIntervalMapT;
119 typedef typename IntervalMapT::interval_type IntervalT;
120
121 U u1 = make<U>(1);
122 T v1 = make<T>(1);
123 T v2 = make<T>(2);
124 T v3 = make<T>(3);
125 T v4 = make<T>(4);
126 T v5 = make<T>(5);
127
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 std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
134 std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
135 std::pair<IntervalT,U> I4_5D_1(I4_5D, u1);
136
137 SplitIntervalMapT split_map;
138 split_map.add(I1_3D_1).add(I2_4D_1).add(I4_5D_1);
139 BOOST_CHECK_EQUAL( iterative_size(split_map), 4 );
140 IntervalMapT join_map(split_map);
141 }
142
143
144 template <class T, class U>
interval_map_mixed_assign_4_bicremental_types()145 void interval_map_mixed_assign_4_bicremental_types()
146 {
147 typedef interval_map<T,U> IntervalMapT;
148 typedef split_interval_map<T,U> SplitIntervalMapT;
149 typedef typename IntervalMapT::interval_type IntervalT;
150
151 U u1 = make<U>(1);
152
153 T v1 = make<T>(1);
154 T v2 = make<T>(2);
155 T v3 = make<T>(3);
156 T v4 = make<T>(4);
157 T v5 = make<T>(5);
158
159 IntervalT I1_3D = IntervalT::right_open(v1,v3);
160 IntervalT I2_4D = IntervalT::right_open(v2,v4);
161 IntervalT I4_5D = IntervalT::right_open(v4,v5);
162
163 std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
164 std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
165 std::pair<IntervalT,U> I4_5D_1(I4_5D, u1);
166
167 SplitIntervalMapT split_map;
168 split_map.add(I1_3D_1).add(I2_4D_1).add(I4_5D_1);
169 BOOST_CHECK_EQUAL( iterative_size(split_map), 4 );
170 IntervalMapT join_map;
171 join_map = split_map;
172 BOOST_CHECK_EQUAL( iterative_size(join_map), 3 );
173 }
174
175
176 template <class T, class U>
interval_map_mixed_equal_4_bicremental_types()177 void interval_map_mixed_equal_4_bicremental_types()
178 {
179 typedef interval_map<T,U> IntervalMapT;
180 typedef split_interval_map<T,U> SplitIntervalMapT;
181 typedef typename IntervalMapT::interval_type IntervalT;
182
183 U u1 = make<U>(1);
184
185 T v1 = make<T>(1);
186 T v2 = make<T>(2);
187 T v3 = make<T>(3);
188 T v4 = make<T>(4);
189 T v5 = make<T>(5);
190
191 IntervalT I1_3D = IntervalT::right_open(v1,v3);
192 IntervalT I2_4D = IntervalT::right_open(v2,v4);
193 IntervalT I4_5D = IntervalT::right_open(v4,v5);
194
195 std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
196 std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
197 std::pair<IntervalT,U> I4_5D_1(I4_5D, u1);
198
199 IntervalMapT join_map;
200 join_map.add(I1_3D_1).add(I2_4D_1).add(I4_5D_1);
201 IntervalMapT join_map2 = join_map;
202 BOOST_CHECK_EQUAL( join_map, join_map2 );
203 BOOST_CHECK_EQUAL( is_element_equal(join_map, join_map2), true );
204
205 SplitIntervalMapT split_map;
206 split_map.add(I1_3D_1).add(I2_4D_1).add(I4_5D_1);
207 SplitIntervalMapT split_map2 = split_map;
208 BOOST_CHECK_EQUAL( split_map, split_map2 );
209 BOOST_CHECK_EQUAL( is_element_equal(split_map2, split_map), true );
210
211 BOOST_CHECK_EQUAL( is_element_equal(split_map, join_map), true );
212 BOOST_CHECK_EQUAL( is_element_equal(join_map, split_map), true );
213 }
214
215
216 template <class T, class U, class Trt>
partial_interval_map_mixed_inclusion_compare_4_bicremental_types()217 void partial_interval_map_mixed_inclusion_compare_4_bicremental_types()
218 {
219 typedef interval_map<T,U,Trt> IntervalMapT;
220 typedef typename IntervalMapT::interval_type IntervalT;
221
222 //--------------------------------------------------------------------------
223 // equalities
224 // { 0 1 2 3 4 5 8 9 }
225 // {[0,2)[2,3](3,6) (7,9]}
226 // ->2 ->1 ->1 ->2
227 split_interval_map<T,U,Trt> split_map;
228 interval_map<T,U,Trt> join_map;
229 split_interval_set<T> split_set;
230 separate_interval_set<T> sep_set;
231 interval_set<T> join_set;
232
233 split_map.add(IDv(0,2,2)).add(IIv(2,3,1)).add(CDv(3,6,1)).add(CIv(7,9,2));
234 join_map = split_map;
235 icl::domain(split_set, split_map);
236 icl::domain(sep_set, split_map);
237 icl::domain(join_set, split_map);
238
239 iterative_size(split_map);
240 BOOST_CHECK_EQUAL( iterative_size(split_map), 4 );
241 BOOST_CHECK_EQUAL( iterative_size(join_map), 3 );
242 BOOST_CHECK_EQUAL( iterative_size(split_set), 4 );
243 BOOST_CHECK_EQUAL( iterative_size(sep_set), 4 );
244 BOOST_CHECK_EQUAL( iterative_size(join_set), 2 );
245
246 BOOST_CHECK_EQUAL( inclusion_compare(split_map, join_map), inclusion::equal );
247 BOOST_CHECK_EQUAL( inclusion_compare(join_map, split_map), inclusion::equal );
248
249 BOOST_CHECK_EQUAL( inclusion_compare(split_map, split_set), inclusion::equal );
250 BOOST_CHECK_EQUAL( inclusion_compare(split_map, sep_set ), inclusion::equal );
251 BOOST_CHECK_EQUAL( inclusion_compare(split_map, join_set ), inclusion::equal );
252 BOOST_CHECK_EQUAL( inclusion_compare(join_map , split_set), inclusion::equal );
253 BOOST_CHECK_EQUAL( inclusion_compare(join_map , sep_set ), inclusion::equal );
254 BOOST_CHECK_EQUAL( inclusion_compare(join_map , join_set ), inclusion::equal );
255
256 BOOST_CHECK_EQUAL( inclusion_compare(split_set, split_map), inclusion::equal );
257 BOOST_CHECK_EQUAL( inclusion_compare(sep_set , split_map), inclusion::equal );
258 BOOST_CHECK_EQUAL( inclusion_compare(join_set , split_map), inclusion::equal );
259 BOOST_CHECK_EQUAL( inclusion_compare(split_set, join_map ), inclusion::equal );
260 BOOST_CHECK_EQUAL( inclusion_compare(sep_set , join_map ), inclusion::equal );
261 BOOST_CHECK_EQUAL( inclusion_compare(join_set , join_map ), inclusion::equal );
262
263 //--------------------------------------------------------------------------
264 // inclusions
265 // { 0 1 2 3 4 5 8 9 }
266 // {[0, 2)[2, 3](3, 6) (7, 9]}
267 // ->2 ->1 ->1 ->2
268 // {[0, 2) [3,3](3, 6) (7, 9]}
269 // ->2 ->1 ->1 ->2
270 split_interval_map<T,U,Trt> split_sub_map1 = split_map;
271 split_sub_map1.erase(MK_v(2));
272 BOOST_CHECK_EQUAL( icl::contains(split_sub_map1, MK_v(2)), false );
273
274 interval_map<T,U,Trt> join_sub_map2;
275 join_sub_map2 = split_map;
276 join_sub_map2.erase(MK_v(1));
277 BOOST_CHECK_EQUAL( icl::contains(join_sub_map2, MK_v(1)), false );
278
279 split_interval_set<T> split_sub_set1;
280 separate_interval_set<T> sep_sub_set1;
281 interval_set<T> join_sub_set1;
282
283 icl::domain(split_sub_set1, split_sub_map1);
284 icl::domain(sep_sub_set1, split_sub_map1);
285 icl::domain(join_sub_set1, split_sub_map1);
286
287 BOOST_CHECK_EQUAL( inclusion_compare(split_sub_map1, split_map), inclusion::subset );
288 BOOST_CHECK_EQUAL( inclusion_compare( join_sub_map2, split_map), inclusion::subset );
289 BOOST_CHECK_EQUAL( inclusion_compare(split_sub_map1, join_map), inclusion::subset );
290 BOOST_CHECK_EQUAL( inclusion_compare( join_sub_map2, join_map), inclusion::subset );
291
292 BOOST_CHECK_EQUAL( inclusion_compare(split_sub_set1, split_map), inclusion::subset );
293 BOOST_CHECK_EQUAL( inclusion_compare( sep_sub_set1, split_map), inclusion::subset );
294 BOOST_CHECK_EQUAL( inclusion_compare( join_sub_set1, split_map), inclusion::subset );
295 BOOST_CHECK_EQUAL( inclusion_compare(split_sub_set1, join_map), inclusion::subset );
296 BOOST_CHECK_EQUAL( inclusion_compare( sep_sub_set1, join_map), inclusion::subset );
297 BOOST_CHECK_EQUAL( inclusion_compare( join_sub_set1, join_map), inclusion::subset );
298
299 BOOST_CHECK_EQUAL( inclusion_compare(split_map, split_sub_map1), inclusion::superset );
300 BOOST_CHECK_EQUAL( inclusion_compare(split_map, join_sub_map2), inclusion::superset );
301 BOOST_CHECK_EQUAL( inclusion_compare( join_map, split_sub_map1), inclusion::superset );
302 BOOST_CHECK_EQUAL( inclusion_compare( join_map, join_sub_map2), inclusion::superset );
303
304 BOOST_CHECK_EQUAL( inclusion_compare(split_map, split_sub_set1), inclusion::superset );
305 BOOST_CHECK_EQUAL( inclusion_compare(split_map, sep_sub_set1), inclusion::superset );
306 BOOST_CHECK_EQUAL( inclusion_compare(split_map, join_sub_set1), inclusion::superset );
307 BOOST_CHECK_EQUAL( inclusion_compare( join_map, split_sub_set1), inclusion::superset );
308 BOOST_CHECK_EQUAL( inclusion_compare( join_map, sep_sub_set1), inclusion::superset );
309 BOOST_CHECK_EQUAL( inclusion_compare( join_map, join_sub_set1), inclusion::superset );
310
311 split_interval_map<T,U,Trt> split_unrel_map11 = split_sub_map1;
312 split_unrel_map11.set(CIv(7,9,1));
313 BOOST_CHECK_EQUAL( split_unrel_map11(MK_v(8)), MK_u(1) );
314
315 interval_map<T,U,Trt> join_unrel_map21 = join_sub_map2;
316 join_unrel_map21.set(K_v(0,1));
317 BOOST_CHECK_EQUAL( join_unrel_map21(MK_v(0)), MK_u(1) );
318
319 BOOST_CHECK_EQUAL( inclusion_compare(split_unrel_map11, split_map), inclusion::unrelated );
320 BOOST_CHECK_EQUAL( inclusion_compare( join_unrel_map21, split_map), inclusion::unrelated );
321 BOOST_CHECK_EQUAL( inclusion_compare(split_unrel_map11, join_map), inclusion::unrelated );
322 BOOST_CHECK_EQUAL( inclusion_compare( join_unrel_map21, join_map), inclusion::unrelated );
323
324 BOOST_CHECK_EQUAL( inclusion_compare(split_map, split_unrel_map11), inclusion::unrelated );
325 BOOST_CHECK_EQUAL( inclusion_compare(split_map, join_unrel_map21), inclusion::unrelated );
326 BOOST_CHECK_EQUAL( inclusion_compare( join_map, split_unrel_map11), inclusion::unrelated );
327 BOOST_CHECK_EQUAL( inclusion_compare( join_map, join_unrel_map21), inclusion::unrelated );
328
329 split_interval_map<T,U,Trt> split_unrel_map1 = split_sub_map1;
330 split_unrel_map1.add(IDv(11,12,1));
331 BOOST_CHECK_EQUAL( split_unrel_map1(MK_v(11)), MK_u(1) );
332
333 interval_map<T,U,Trt> join_unrel_map2 = join_sub_map2;
334 join_unrel_map2.add(K_v(6,1));
335 BOOST_CHECK_EQUAL( join_unrel_map2(MK_v(6)), MK_u(1) );
336 }
337
338
339 template <class T, class U, class Trt>
partial_interval_map_mixed_contains_4_bicremental_types()340 void partial_interval_map_mixed_contains_4_bicremental_types()
341 {
342 typedef interval_map<T,U,Trt> IntervalMapT;
343 typedef typename IntervalMapT::interval_type IntervalT;
344 //--------------------------------------------------------------------------
345 // { 0 1 2 3 4 5 8 9 }
346 // {[0,2)[2,3](3,6) (7,9]}
347 // ->2 ->1 ->1 ->2
348 split_interval_map<T,U,Trt> split_map;
349 interval_map<T,U,Trt> join_map;
350 split_interval_set<T> split_set;
351 separate_interval_set<T> sep_set;
352 interval_set<T> join_set;
353
354 split_map.add(IDv(0,2,2)).add(IIv(2,3,1)).add(CDv(3,6,1)).add(CIv(7,9,2));
355 join_map = split_map;
356 icl::domain(split_set, split_map);
357 icl::domain(sep_set, split_map);
358 icl::domain(join_set, split_map);
359
360 BOOST_CHECK_EQUAL( iterative_size(split_map), 4 );
361 BOOST_CHECK_EQUAL( iterative_size(join_map), 3 );
362 BOOST_CHECK_EQUAL( iterative_size(split_set), 4 );
363 BOOST_CHECK_EQUAL( iterative_size(sep_set), 4 );
364 BOOST_CHECK_EQUAL( iterative_size(join_set), 2 );
365
366 // Key types
367 BOOST_CHECK_EQUAL( icl::contains(split_map, MK_v(0)), true );
368 BOOST_CHECK_EQUAL( icl::contains(split_map, MK_v(5)), true );
369 BOOST_CHECK_EQUAL( icl::contains(split_map, MK_v(9)), true );
370
371 BOOST_CHECK_EQUAL( icl::contains(split_map, I_D(2,3)), true );
372 BOOST_CHECK_EQUAL( icl::contains(split_map, I_D(0,6)), true );
373 BOOST_CHECK_EQUAL( icl::contains(split_map, I_D(0,7)), false );
374 BOOST_CHECK_EQUAL( icl::contains(join_map, I_D(2,3)), true );
375 BOOST_CHECK_EQUAL( icl::contains(join_map, I_D(0,6)), true );
376 BOOST_CHECK_EQUAL( icl::contains(join_map, I_D(0,7)), false );
377
378 // Map types
379 BOOST_CHECK_EQUAL( icl::contains(join_map, K_v(1,2)), true );
380 BOOST_CHECK_EQUAL( icl::contains(join_map, K_v(5,1)), true );
381 BOOST_CHECK_EQUAL( icl::contains(join_map, K_v(9,2)), true );
382
383 BOOST_CHECK_EQUAL( icl::contains(split_map, IDv(2,6,1)), true );
384 BOOST_CHECK_EQUAL( icl::contains(split_map, IDv(1,6,1)), false );
385 BOOST_CHECK_EQUAL( icl::contains(split_map, IIv(8,9,2)), true );
386 BOOST_CHECK_EQUAL( icl::contains(split_map, IIv(8,9,3)), false );
387 BOOST_CHECK_EQUAL( icl::contains(join_map, IDv(2,6,1)), true );
388 BOOST_CHECK_EQUAL( icl::contains(join_map, IDv(1,6,1)), false );
389 BOOST_CHECK_EQUAL( icl::contains(join_map, IIv(8,9,2)), true );
390 BOOST_CHECK_EQUAL( icl::contains(join_map, IIv(8,9,3)), false );
391
392 BOOST_CHECK_EQUAL( icl::contains(split_map, join_map), true );
393 BOOST_CHECK_EQUAL( icl::contains(join_map, split_map), true );
394 BOOST_CHECK_EQUAL( icl::within(split_map, join_map), true );
395 BOOST_CHECK_EQUAL( icl::within(join_map, split_map), true );
396
397 //--------------------------------------------------------------------------
398 // inclusions
399 // { 0 1 2 3 4 5 8 9 }
400 // {[0, 2)[2, 3](3, 6) (7, 9]}
401 // ->2 ->1 ->1 ->2
402 // {[0, 2) [3,3](3, 6) (7, 9]}
403 // ->2 ->1 ->1 ->2
404 split_interval_map<T,U,Trt> split_sub_map1 = split_map;
405 split_sub_map1.erase(MK_v(2));
406 BOOST_CHECK_EQUAL( icl::contains(split_sub_map1, MK_v(2)), false );
407
408 interval_map<T,U,Trt> join_sub_map2;
409 join_sub_map2 = split_map;
410 join_sub_map2.erase(MK_v(1));
411 BOOST_CHECK_EQUAL( icl::contains(join_sub_map2, MK_v(1)), false );
412
413 split_interval_set<T> split_sub_set1;
414 separate_interval_set<T> sep_sub_set1;
415 interval_set<T> join_sub_set1;
416
417 icl::domain(split_sub_set1, split_sub_map1);
418 icl::domain(sep_sub_set1, split_sub_map1);
419 icl::domain(join_sub_set1, split_sub_map1);
420
421 BOOST_CHECK_EQUAL( icl::within(split_sub_map1, split_map), true );
422 BOOST_CHECK_EQUAL( icl::within(join_sub_map2, split_map), true );
423 BOOST_CHECK_EQUAL( icl::within(split_sub_map1, join_map ), true );
424 BOOST_CHECK_EQUAL( icl::within(join_sub_map2, join_map ), true );
425
426 BOOST_CHECK_EQUAL( icl::contains(split_map, split_sub_map1), true );
427 BOOST_CHECK_EQUAL( icl::contains(split_map, join_sub_map2), true );
428 BOOST_CHECK_EQUAL( icl::contains(join_map, split_sub_map1), true );
429 BOOST_CHECK_EQUAL( icl::contains(join_map, join_sub_map2), true );
430
431 BOOST_CHECK_EQUAL( icl::contains(split_map, split_sub_set1), true );
432 BOOST_CHECK_EQUAL( icl::contains(split_map, sep_sub_set1), true );
433 BOOST_CHECK_EQUAL( icl::contains(split_map, join_sub_set1), true );
434 BOOST_CHECK_EQUAL( icl::contains(join_map, split_sub_set1), true );
435 BOOST_CHECK_EQUAL( icl::contains(join_map, sep_sub_set1), true );
436 BOOST_CHECK_EQUAL( icl::contains(join_map, join_sub_set1), true );
437
438 split_interval_map<T,U,Trt> split_unrel_map11 = split_sub_map1;
439 split_unrel_map11.set(CIv(7,9,1));
440 BOOST_CHECK_EQUAL( split_unrel_map11(MK_v(8)), MK_u(1) );
441
442 interval_map<T,U,Trt> join_unrel_map21 = join_sub_map2;
443 join_unrel_map21.set(K_v(0,1));
444 BOOST_CHECK_EQUAL( join_unrel_map21(MK_v(0)), MK_u(1) );
445
446 BOOST_CHECK_EQUAL( icl::contains(split_unrel_map11, split_map), false );
447 BOOST_CHECK_EQUAL( icl::contains(join_unrel_map21, split_map), false );
448 BOOST_CHECK_EQUAL( icl::contains(split_unrel_map11, join_map), false );
449 BOOST_CHECK_EQUAL( icl::contains(join_unrel_map21, join_map), false );
450
451 BOOST_CHECK_EQUAL( icl::within(split_unrel_map11, split_map), false );
452 BOOST_CHECK_EQUAL( icl::within(join_unrel_map21, split_map), false );
453 BOOST_CHECK_EQUAL( icl::within(split_unrel_map11, join_map), false );
454 BOOST_CHECK_EQUAL( icl::within(join_unrel_map21, join_map), false );
455
456 BOOST_CHECK_EQUAL( icl::contains(split_map, split_unrel_map11), false );
457 BOOST_CHECK_EQUAL( icl::contains(split_map, join_unrel_map21), false );
458 BOOST_CHECK_EQUAL( icl::contains(join_map, split_unrel_map11), false );
459 BOOST_CHECK_EQUAL( icl::contains(join_map, join_unrel_map21), false );
460
461 }
462
463 //------------------------------------------------------------------------------
464 //- part2: Operations
465 //------------------------------------------------------------------------------
466
467 template <class T, class U>
interval_map_mixed_add_4_bicremental_types()468 void interval_map_mixed_add_4_bicremental_types()
469 {
470 typedef interval_map<T,U> IntervalMapT;
471 typedef split_interval_map<T,U> SplitIntervalMapT;
472 typedef typename IntervalMapT::interval_type IntervalT;
473 U u1 = make<U>(1);
474
475 T v1 = make<T>(1);
476 T v2 = make<T>(2);
477 T v3 = make<T>(3);
478 T v4 = make<T>(4);
479 T v5 = make<T>(5);
480
481 IntervalT I1_3D = IntervalT::right_open(v1,v3);
482 IntervalT I2_4D = IntervalT::right_open(v2,v4);
483 IntervalT I4_5D = IntervalT::right_open(v4,v5);
484
485 std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
486 std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
487 std::pair<IntervalT,U> I4_5D_1(I4_5D, u1);
488 mapping_pair<T,U> v1_1(v1, u1);
489 mapping_pair<T,U> v3_1(v3, u1);
490 mapping_pair<T,U> v5_1(v5, u1);
491
492 SplitIntervalMapT split_map;
493 split_map.add(I1_3D_1).add(I2_4D_1);
494 split_map += I4_5D_1;
495 BOOST_CHECK_EQUAL( iterative_size(split_map), 4 );
496 IntervalMapT join_map;
497 join_map += split_map;
498 BOOST_CHECK_EQUAL( iterative_size(join_map), 3 );
499
500 IntervalMapT join_map3;
501 join_map3.add(v1_1).add(v3_1);
502 join_map3 += v5_1;
503 BOOST_CHECK_EQUAL( iterative_size(join_map3), 3 );
504 SplitIntervalMapT split_map3;
505 split_map3 += join_map3;
506 BOOST_CHECK_EQUAL( iterative_size(split_map3), 3 );
507 }
508
509 template <class T, class U>
interval_map_mixed_add2_4_bicremental_types()510 void interval_map_mixed_add2_4_bicremental_types()
511 {
512 typedef interval_map<T,U> IntervalMapT;
513 typedef split_interval_map<T,U> SplitIntervalMapT;
514 typedef typename IntervalMapT::interval_type IntervalT;
515
516 U u1 = make<U>(1);
517
518 T v1 = make<T>(1);
519 T v2 = make<T>(2);
520 T v3 = make<T>(3);
521 T v4 = make<T>(4);
522 T v5 = make<T>(5);
523
524 IntervalT I1_3D = IntervalT::right_open(v1,v3);
525 IntervalT I2_4D = IntervalT::right_open(v2,v4);
526 IntervalT I4_5D = IntervalT::right_open(v4,v5);
527
528 std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
529 std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
530 std::pair<IntervalT,U> I4_5D_1(I4_5D, u1);
531 mapping_pair<T,U> v1_1(v1, u1);
532 mapping_pair<T,U> v3_1(v3, u1);
533 mapping_pair<T,U> v5_1(v5, u1);
534
535 SplitIntervalMapT split_map;
536 split_map.add(I1_3D_1).add(I2_4D_1);
537 split_map |= I4_5D_1;
538 BOOST_CHECK_EQUAL( iterative_size(split_map), 4 );
539 IntervalMapT join_map;
540 join_map |= split_map;
541 BOOST_CHECK_EQUAL( iterative_size(join_map), 3 );
542
543 IntervalMapT join_map3;
544 join_map3.add(v1_1).add(v3_1);
545 join_map3 |= v5_1;
546 BOOST_CHECK_EQUAL( iterative_size(join_map3), 3 );
547 SplitIntervalMapT split_map3;
548 split_map3 |= join_map3;
549 BOOST_CHECK_EQUAL( iterative_size(split_map3), 3 );
550 }
551
552
553 template <class T, class U>
interval_map_mixed_subtract_4_bicremental_types()554 void interval_map_mixed_subtract_4_bicremental_types()
555 {
556 typedef interval_map<T,U> IntervalMapT;
557 typedef split_interval_map<T,U> SplitIntervalMapT;
558 typedef typename IntervalMapT::interval_type IntervalT;
559
560 U u1 = make<U>(1);
561
562 T v0 = make<T>(0);
563 T v2 = make<T>(2);
564 T v3 = make<T>(3);
565 T v4 = make<T>(4);
566 T v5 = make<T>(5);
567 T v6 = make<T>(6);
568 T v7 = make<T>(7);
569 T v8 = make<T>(8);
570 T v9 = make<T>(9);
571
572 IntervalT I0_4D = IntervalT::right_open(v0,v4);
573 IntervalT I2_6D = IntervalT::right_open(v2,v6);
574 IntervalT I3_6D = IntervalT::right_open(v3,v6);
575 IntervalT I5_7D = IntervalT::right_open(v5,v7);
576 IntervalT I7_8D = IntervalT::right_open(v7,v8);
577 IntervalT I8_9D = IntervalT::right_open(v8,v9);
578 IntervalT I8_9I = IntervalT::closed(v8,v9);
579
580 std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
581 std::pair<IntervalT,U> I2_6D_1(I2_6D, u1);
582 std::pair<IntervalT,U> I3_6D_1(I3_6D, u1);
583 std::pair<IntervalT,U> I5_7D_1(I5_7D, u1);
584 std::pair<IntervalT,U> I7_8D_1(I7_8D, u1);
585 std::pair<IntervalT,U> I8_9D_1(I8_9D, u1);
586 std::pair<IntervalT,U> I8_9I_1(I8_9I, u1);
587
588 SplitIntervalMapT split_map;
589 split_map.add(I0_4D_1).add(I2_6D_1).add(I5_7D_1).add(I7_8D_1).add(I8_9I_1);
590 BOOST_CHECK_EQUAL( iterative_size(split_map), 7 );
591
592 IntervalMapT join_map;
593 join_map.add(I0_4D_1).add(I2_6D_1).add(I5_7D_1).add(I7_8D_1).add(I8_9I_1);
594 BOOST_CHECK_EQUAL( iterative_size(join_map), 5 );
595
596 // Make maps to be subtracted
597 SplitIntervalMapT split_sub;
598 split_sub.add(I3_6D_1).add(I8_9D_1);
599
600 IntervalMapT join_sub;
601 join_sub.add(I3_6D_1).add(I8_9D_1);
602
603 //--------------------------------------------------------------------------
604 // Test for split_interval_map
605 SplitIntervalMapT split_diff = split_map;
606 IntervalMapT join_diff = join_map;
607
608 //subtraction combinations
609 split_diff -= split_sub;
610 join_diff -= split_sub;
611
612 BOOST_CHECK_EQUAL( iterative_size(split_diff), 7 );
613 BOOST_CHECK_EQUAL( iterative_size(join_diff), 5 );
614
615 BOOST_CHECK_EQUAL( is_element_equal(split_diff, split_diff), true );
616 BOOST_CHECK_EQUAL( is_element_equal(split_diff, join_diff), true );
617 BOOST_CHECK_EQUAL( is_element_equal(join_diff, split_diff), true );
618
619 //--------------------------------------------------------------------------
620 // Test for interval_map. Reinitialize
621 split_diff = split_map;
622 join_diff = join_map;
623
624 //subtraction combinations
625 split_diff -= join_sub;
626 join_diff -= join_sub;
627
628 BOOST_CHECK_EQUAL( iterative_size(split_diff), 7 );
629 BOOST_CHECK_EQUAL( iterative_size(join_diff), 5 );
630
631 BOOST_CHECK_EQUAL( is_element_equal(join_diff, join_diff), true );
632 BOOST_CHECK_EQUAL( is_element_equal(join_diff, split_diff), true );
633 BOOST_CHECK_EQUAL( is_element_equal(split_diff, join_diff), true );
634 }
635
636
637 template <class T, class U>
interval_map_mixed_erase_4_bicremental_types()638 void interval_map_mixed_erase_4_bicremental_types()
639 {
640 typedef interval_map<T,U> IntervalMapT;
641 typedef split_interval_map<T,U> SplitIntervalMapT;
642 typedef typename IntervalMapT::interval_type IntervalT;
643
644 U u1 = make<U>(1);
645
646 T v0 = make<T>(0);
647 T v2 = make<T>(2);
648 T v3 = make<T>(3);
649 T v4 = make<T>(4);
650 T v5 = make<T>(5);
651 T v6 = make<T>(6);
652 T v7 = make<T>(7);
653 T v8 = make<T>(8);
654 T v9 = make<T>(9);
655
656 IntervalT I0_4D = IntervalT::right_open(v0,v4);
657 IntervalT I2_6D = IntervalT::right_open(v2,v6);
658 IntervalT I3_6D = IntervalT::right_open(v3,v6);
659 IntervalT I5_7D = IntervalT::right_open(v5,v7);
660 IntervalT I7_8D = IntervalT::right_open(v7,v8);
661 IntervalT I8_9D = IntervalT::right_open(v8,v9);
662 IntervalT I8_9I = IntervalT::closed(v8,v9);
663
664 std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
665 std::pair<IntervalT,U> I2_6D_1(I2_6D, u1);
666 std::pair<IntervalT,U> I3_6D_1(I3_6D, u1);
667 std::pair<IntervalT,U> I5_7D_1(I5_7D, u1);
668 std::pair<IntervalT,U> I7_8D_1(I7_8D, u1);
669 std::pair<IntervalT,U> I8_9D_1(I8_9D, u1);
670 std::pair<IntervalT,U> I8_9I_1(I8_9I, u1);
671
672 SplitIntervalMapT split_map;
673 split_map.add(I0_4D_1).add(I2_6D_1).add(I5_7D_1).add(I7_8D_1).add(I8_9I_1);
674 BOOST_CHECK_EQUAL( iterative_size(split_map), 7 );
675
676 IntervalMapT join_map;
677 join_map.add(I0_4D_1).add(I2_6D_1).add(I5_7D_1).add(I7_8D_1).add(I8_9I_1);
678 BOOST_CHECK_EQUAL( iterative_size(join_map), 5 );
679
680 // Make sets to be erased
681 SplitIntervalMapT split_sub;
682 split_sub.add(I3_6D_1).add(I8_9D_1);
683
684 IntervalMapT join_sub;
685 join_sub.add(I3_6D_1).add(I8_9D_1);
686
687 //--------------------------------------------------------------------------
688 // Test for split_interval_map
689 SplitIntervalMapT split_diff = split_map;
690 IntervalMapT join_diff = join_map;
691
692 //subtraction combinations
693 erase(split_diff, split_sub);
694 erase(join_diff, split_sub);
695
696 BOOST_CHECK_EQUAL( iterative_size(split_diff), 6 );
697 BOOST_CHECK_EQUAL( iterative_size(join_diff), 5 );
698
699 BOOST_CHECK_EQUAL( is_element_equal(split_diff, split_diff), true );
700 BOOST_CHECK_EQUAL( is_element_equal(split_diff, join_diff), true );
701 BOOST_CHECK_EQUAL( is_element_equal(join_diff, split_diff), true );
702
703 //--------------------------------------------------------------------------
704 // Test for interval_map. Reinitialize
705 split_diff = split_map;
706 join_diff = join_map;
707
708 //subtraction combinations
709 erase(split_diff, join_sub);
710 erase(join_diff, join_sub);
711
712 BOOST_CHECK_EQUAL( iterative_size(split_diff), 6 );
713 BOOST_CHECK_EQUAL( iterative_size(join_diff), 5 );
714
715 BOOST_CHECK_EQUAL( is_element_equal(join_diff, join_diff), true );
716 BOOST_CHECK_EQUAL( is_element_equal(join_diff, split_diff), true );
717 BOOST_CHECK_EQUAL( is_element_equal(split_diff, join_diff), true );
718 }
719
720
721 template <class T, class U>
interval_map_mixed_erase2_4_bicremental_types()722 void interval_map_mixed_erase2_4_bicremental_types()
723 {
724 typedef interval_map<T,U> IntervalMapT;
725 typedef split_interval_map<T,U> SplitIntervalMapT;
726 typedef interval_set<T> IntervalSetT;
727 typedef split_interval_set<T> SplitIntervalSetT;
728 typedef typename IntervalMapT::interval_type IntervalT;
729
730 U u1 = make<U>(1);
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 v5 = make<T>(5);
737 T v6 = make<T>(6);
738 T v7 = make<T>(7);
739 T v8 = make<T>(8);
740 T v9 = make<T>(9);
741
742 IntervalT I0_4D = IntervalT::right_open(v0,v4);
743 IntervalT I2_6D = IntervalT::right_open(v2,v6);
744 IntervalT I3_6D = IntervalT::right_open(v3,v6);
745 IntervalT I5_7D = IntervalT::right_open(v5,v7);
746 IntervalT I7_8D = IntervalT::right_open(v7,v8);
747 IntervalT I8_9D = IntervalT::right_open(v8,v9);
748 IntervalT I8_9I = IntervalT::closed(v8,v9);
749
750 std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
751 std::pair<IntervalT,U> I2_6D_1(I2_6D, u1);
752 std::pair<IntervalT,U> I3_6D_1(I3_6D, u1);
753 std::pair<IntervalT,U> I5_7D_1(I5_7D, u1);
754 std::pair<IntervalT,U> I7_8D_1(I7_8D, u1);
755 std::pair<IntervalT,U> I8_9D_1(I8_9D, u1);
756 std::pair<IntervalT,U> I8_9I_1(I8_9I, u1);
757
758 SplitIntervalMapT split_map;
759 split_map.add(I0_4D_1).add(I2_6D_1).add(I5_7D_1).add(I7_8D_1).add(I8_9I_1);
760 BOOST_CHECK_EQUAL( iterative_size(split_map), 7 );
761
762 IntervalMapT join_map;
763 join_map.add(I0_4D_1).add(I2_6D_1).add(I5_7D_1).add(I7_8D_1).add(I8_9I_1);
764 BOOST_CHECK_EQUAL( iterative_size(join_map), 5 );
765
766 // Make sets to be erased
767 SplitIntervalSetT split_sub;
768 split_sub.add(I3_6D).add(I8_9D);
769
770 IntervalSetT join_sub;
771 join_sub.add(I3_6D).add(I8_9D);
772
773 //--------------------------------------------------------------------------
774 // Test for split_interval_map
775 SplitIntervalMapT split_diff = split_map;
776 IntervalMapT join_diff = join_map;
777 SplitIntervalMapT split_diff2 = split_map;
778 IntervalMapT join_diff2 = join_map;
779
780 //erase combinations
781 erase(split_diff, split_sub);
782 erase(join_diff, split_sub);
783
784 BOOST_CHECK_EQUAL( iterative_size(split_diff), 5 );
785 BOOST_CHECK_EQUAL( iterative_size(join_diff), 4 );
786
787 BOOST_CHECK_EQUAL( is_element_equal(split_diff, split_diff), true );
788 BOOST_CHECK_EQUAL( is_element_equal(split_diff, join_diff), true );
789 BOOST_CHECK_EQUAL( is_element_equal(join_diff, split_diff), true );
790
791 //subtraction combinations
792 split_diff2 -= split_sub;
793 join_diff2 -= split_sub;
794
795 BOOST_CHECK_EQUAL( iterative_size(split_diff2), 5 );
796 BOOST_CHECK_EQUAL( iterative_size(join_diff2), 4 );
797
798 BOOST_CHECK_EQUAL( is_element_equal(split_diff2, split_diff2), true );
799 BOOST_CHECK_EQUAL( is_element_equal(split_diff2, join_diff2), true );
800 BOOST_CHECK_EQUAL( is_element_equal(join_diff2, split_diff2), true );
801
802 //--------------------------------------------------------------------------
803 // Test for interval_map. Reinitialize
804 split_diff = split_map;
805 join_diff = join_map;
806 split_diff2 = split_map;
807 join_diff2 = join_map;
808
809 //erase combinations
810 erase(split_diff, join_sub);
811 erase(join_diff, join_sub);
812
813 BOOST_CHECK_EQUAL( iterative_size(split_diff), 5 );
814 BOOST_CHECK_EQUAL( iterative_size(join_diff), 4 );
815
816 BOOST_CHECK_EQUAL( is_element_equal(join_diff, join_diff), true );
817 BOOST_CHECK_EQUAL( is_element_equal(join_diff, split_diff), true );
818 BOOST_CHECK_EQUAL( is_element_equal(split_diff, join_diff), true );
819
820 //subtraction combinations
821 split_diff2 -= join_sub;
822 join_diff2 -= join_sub;
823
824 BOOST_CHECK_EQUAL( iterative_size(split_diff2), 5 );
825 BOOST_CHECK_EQUAL( iterative_size(join_diff2), 4 );
826
827 BOOST_CHECK_EQUAL( is_element_equal(join_diff2, join_diff2), true );
828 BOOST_CHECK_EQUAL( is_element_equal(join_diff2, split_diff2), true );
829 BOOST_CHECK_EQUAL( is_element_equal(split_diff2, join_diff2), true );
830 }
831
832
833 template <class T, class U>
interval_map_mixed_insert_erase_4_bicremental_types()834 void interval_map_mixed_insert_erase_4_bicremental_types()
835 {
836 typedef interval_map<T,U> IntervalMapT;
837 typedef split_interval_map<T,U> SplitIntervalMapT;
838 typedef typename IntervalMapT::interval_type IntervalT;
839
840 U u1 = make<U>(1);
841
842 T v0 = make<T>(0);
843 T v2 = make<T>(2);
844 T v3 = make<T>(3);
845 T v4 = make<T>(4);
846 T v5 = make<T>(5);
847 T v6 = make<T>(6);
848 T v7 = make<T>(7);
849 T v8 = make<T>(8);
850 T v9 = make<T>(9);
851
852 IntervalT I0_4D = IntervalT::right_open(v0,v4);
853 IntervalT I2_6D = IntervalT::right_open(v2,v6);
854 IntervalT I3_6D = IntervalT::right_open(v3,v6);
855 IntervalT I5_7D = IntervalT::right_open(v5,v7);
856 IntervalT I7_8D = IntervalT::right_open(v7,v8);
857 IntervalT I8_9D = IntervalT::right_open(v8,v9);
858 IntervalT I8_9I = IntervalT::closed(v8,v9);
859
860 std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
861 std::pair<IntervalT,U> I2_6D_1(I2_6D, u1);
862 std::pair<IntervalT,U> I3_6D_1(I3_6D, u1);
863 std::pair<IntervalT,U> I5_7D_1(I5_7D, u1);
864 std::pair<IntervalT,U> I7_8D_1(I7_8D, u1);
865 std::pair<IntervalT,U> I8_9D_1(I8_9D, u1);
866 std::pair<IntervalT,U> I8_9I_1(I8_9I, u1);
867
868 SplitIntervalMapT split_A, split_B, split_all, split_X;
869 IntervalMapT join_A, join_B, join_all, join_X;
870
871 split_all.insert(I0_4D_1).insert(I2_6D_1).insert(I5_7D_1).insert(I7_8D_1).insert(I8_9I_1);
872 split_A.insert(I0_4D_1).insert(I2_6D_1).insert(I5_7D_1);
873 split_B.insert(I7_8D_1).insert(I8_9I_1);
874
875 join_all.insert(I0_4D_1).insert(I2_6D_1).insert(I5_7D_1).insert(I7_8D_1).insert(I8_9I_1);
876 join_A.insert(I0_4D_1).insert(I2_6D_1).insert(I5_7D_1);
877 join_B.insert(I7_8D_1).insert(I8_9I_1);
878
879 //-------------------------------------------------------------------------
880 insert(split_X, split_A);
881 BOOST_CHECK_EQUAL( split_X, split_A );
882 insert(split_X, split_B);
883 BOOST_CHECK_EQUAL( split_X, split_all );
884
885 erase(split_X, split_B);
886 BOOST_CHECK_EQUAL( split_X, split_A );
887 erase(split_X, split_A);
888 BOOST_CHECK_EQUAL( split_X, SplitIntervalMapT() );
889
890 //-------------------------------------------------------------------------
891 insert(join_X, join_A);
892 BOOST_CHECK_EQUAL( join_X, join_A );
893 insert(join_X, join_B);
894 BOOST_CHECK_EQUAL( join_X, join_all );
895
896 erase(join_X, join_B);
897 BOOST_CHECK_EQUAL( join_X, join_A );
898 erase(join_X, join_A);
899 BOOST_CHECK_EQUAL( join_X, IntervalMapT() );
900
901 //-------------------------------------------------------------------------
902 split_X.clear();
903 insert(split_X, join_A);
904 BOOST_CHECK_EQUAL( is_element_equal(split_X, split_A), true );
905 insert(split_X, join_B);
906 BOOST_CHECK_EQUAL( is_element_equal(split_X, split_all), true );
907
908 erase(split_X, join_B);
909 BOOST_CHECK_EQUAL( is_element_equal(split_X, split_A), true );
910 erase(split_X, join_A);
911 BOOST_CHECK_EQUAL( is_element_equal(split_X, SplitIntervalMapT()), true );
912
913 //-------------------------------------------------------------------------
914 split_X.clear();
915 insert(join_X, split_A);
916 BOOST_CHECK_EQUAL( is_element_equal(join_X, split_A), true );
917 insert(join_X, split_B);
918 BOOST_CHECK_EQUAL( is_element_equal(join_X, join_all), true );
919
920 erase(join_X, split_B);
921 BOOST_CHECK_EQUAL( is_element_equal(join_X, split_A), true );
922 erase(join_X, split_A);
923 BOOST_CHECK_EQUAL( is_element_equal(join_X, IntervalMapT()), true );
924 }
925
926 template <class T, class U>
interval_map_mixed_insert_erase2_4_bicremental_types()927 void interval_map_mixed_insert_erase2_4_bicremental_types()
928 {
929 typedef interval_map<T,U> IntervalMapT;
930 typedef split_interval_map<T,U> SplitIntervalMapT;
931 typedef interval_set<T> IntervalSetT;
932 typedef split_interval_set<T> SplitIntervalSetT;
933 typedef typename IntervalMapT::interval_type IntervalT;
934
935 U u1 = make<U>(1);
936
937 T v0 = make<T>(0);
938 T v2 = make<T>(2);
939 T v3 = make<T>(3);
940 T v4 = make<T>(4);
941 T v5 = make<T>(5);
942 T v6 = make<T>(6);
943 T v7 = make<T>(7);
944 T v8 = make<T>(8);
945 T v9 = make<T>(9);
946
947 IntervalT I0_4D = IntervalT::right_open(v0,v4);
948 IntervalT I2_6D = IntervalT::right_open(v2,v6);
949 IntervalT I3_6D = IntervalT::right_open(v3,v6);
950 IntervalT I5_7D = IntervalT::right_open(v5,v7);
951 IntervalT I7_8D = IntervalT::right_open(v7,v8);
952 IntervalT I8_9D = IntervalT::right_open(v8,v9);
953 IntervalT I8_9I = IntervalT::closed(v8,v9);
954
955 std::pair<IntervalT,U> I0_4D_1(I0_4D, u1);
956 std::pair<IntervalT,U> I2_6D_1(I2_6D, u1);
957 std::pair<IntervalT,U> I3_6D_1(I3_6D, u1);
958 std::pair<IntervalT,U> I5_7D_1(I5_7D, u1);
959 std::pair<IntervalT,U> I7_8D_1(I7_8D, u1);
960 std::pair<IntervalT,U> I8_9D_1(I8_9D, u1);
961 std::pair<IntervalT,U> I8_9I_1(I8_9I, u1);
962
963 SplitIntervalMapT split_A, split_B, split_all, split_X;
964 IntervalMapT join_A, join_B, join_all, join_X;
965 SplitIntervalSetT split_dA, split_dB;
966 IntervalSetT join_dA, join_dB;
967
968 split_all.insert(I0_4D_1).insert(I2_6D_1).insert(I5_7D_1).insert(I7_8D_1).insert(I8_9I_1);
969 split_A.insert(I0_4D_1).insert(I2_6D_1).insert(I5_7D_1);
970 split_B.insert(I7_8D_1).insert(I8_9I_1);
971
972 join_all.insert(I0_4D_1).insert(I2_6D_1).insert(I5_7D_1).insert(I7_8D_1).insert(I8_9I_1);
973 join_A.insert(I0_4D_1).insert(I2_6D_1).insert(I5_7D_1);
974 join_B.insert(I7_8D_1).insert(I8_9I_1);
975
976 icl::domain(split_dA, split_A);
977 icl::domain(split_dB, split_B);
978 icl::domain(join_dA, join_A);
979 icl::domain(join_dB, join_B);
980
981 //-------------------------------------------------------------------------
982 insert(split_X, split_A);
983 BOOST_CHECK_EQUAL( split_X, split_A );
984 insert(split_X, split_B);
985 BOOST_CHECK_EQUAL( split_X, split_all );
986
987 erase(split_X, split_dB);
988 BOOST_CHECK_EQUAL( split_X, split_A );
989 erase(split_X, split_dA);
990 BOOST_CHECK_EQUAL( split_X, SplitIntervalMapT() );
991
992 //-------------------------------------------------------------------------
993 insert(join_X, join_A);
994 BOOST_CHECK_EQUAL( join_X, join_A );
995 insert(join_X, join_B);
996 BOOST_CHECK_EQUAL( join_X, join_all );
997
998 erase(join_X, join_dB);
999 BOOST_CHECK_EQUAL( join_X, join_A );
1000 erase(join_X, join_dA);
1001 BOOST_CHECK_EQUAL( join_X, IntervalMapT() );
1002
1003 //-------------------------------------------------------------------------
1004 split_X.clear();
1005 insert(split_X, join_A);
1006 BOOST_CHECK_EQUAL( is_element_equal(split_X, split_A), true );
1007 insert(split_X, join_B);
1008 BOOST_CHECK_EQUAL( is_element_equal(split_X, split_all), true );
1009
1010 erase(split_X, join_dB);
1011 BOOST_CHECK_EQUAL( is_element_equal(split_X, split_A), true );
1012 erase(split_X, join_dA);
1013 BOOST_CHECK_EQUAL( is_element_equal(split_X, SplitIntervalMapT()), true );
1014
1015 //-------------------------------------------------------------------------
1016 split_X.clear();
1017 insert(join_X, split_A);
1018 BOOST_CHECK_EQUAL( is_element_equal(join_X, split_A), true );
1019 insert(join_X, split_B);
1020 BOOST_CHECK_EQUAL( is_element_equal(join_X, join_all), true );
1021
1022 erase(join_X, split_dB);
1023 BOOST_CHECK_EQUAL( is_element_equal(join_X, split_A), true );
1024 erase(join_X, split_dA);
1025 BOOST_CHECK_EQUAL( is_element_equal(join_X, IntervalMapT()), true );
1026 }
1027
1028 template <class T, class U>
interval_map_mixed_basic_intersect_4_bicremental_types()1029 void interval_map_mixed_basic_intersect_4_bicremental_types()
1030 {
1031 typedef interval_map<T,U> IntervalMapT;
1032 typedef split_interval_map<T,U> SplitIntervalMapT;
1033 typedef interval_set<T> IntervalSetT;
1034 typedef split_interval_set<T> SplitIntervalSetT;
1035 typedef typename IntervalMapT::interval_type IntervalT;
1036
1037 U u1 = make<U>(1);
1038 U u2 = make<U>(2);
1039 U u3 = make<U>(3);
1040
1041 T v0 = make<T>(0);
1042 T v1 = make<T>(1);
1043 T v2 = make<T>(2);
1044 T v3 = make<T>(3);
1045
1046
1047 T v6 = make<T>(6);
1048 T v7 = make<T>(7);
1049 T v8 = make<T>(8);
1050 T v9 = make<T>(9);
1051
1052 IntervalT I0_3D = IntervalT::right_open(v0,v3);
1053 IntervalT I1_3D = IntervalT::right_open(v1,v3);
1054 IntervalT I1_8D = IntervalT::right_open(v1,v8);
1055 IntervalT I2_7D = IntervalT::right_open(v2,v7);
1056 IntervalT I2_3D = IntervalT::right_open(v2,v3);
1057 IntervalT I6_7D = IntervalT::right_open(v6,v7);
1058 IntervalT I6_8D = IntervalT::right_open(v6,v8);
1059 IntervalT I6_9D = IntervalT::right_open(v6,v9);
1060
1061 std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
1062 std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
1063 std::pair<IntervalT,U> I1_3D_2(I1_3D, u2);
1064 std::pair<IntervalT,U> I1_8D_1(I1_8D, u1);
1065 std::pair<const IntervalT,U> I2_7D_1(I2_7D, u1);
1066 std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
1067 std::pair<IntervalT,U> I2_3D_3(I2_3D, u3);
1068 std::pair<IntervalT,U> I6_7D_1(I6_7D, u1);
1069 std::pair<IntervalT,U> I6_7D_3(I6_7D, u3);
1070 std::pair<IntervalT,U> I6_8D_1(I6_8D, u1);
1071 std::pair<IntervalT,U> I6_8D_2(I6_8D, u2);
1072 std::pair<IntervalT,U> I6_9D_1(I6_9D, u1);
1073
1074 //--------------------------------------------------------------------------
1075 // split_interval_map
1076 //--------------------------------------------------------------------------
1077 //split_A [0 3) [6 9)
1078 // &= [1 8)
1079 //split_AB -> [1 3) [6 8)
1080 // &= [2 7)
1081 // -> [2 3) [6 7)
1082 SplitIntervalMapT split_A, split_B, split_AB, split_ab, split_ab2;
1083
1084 split_A.add(I0_3D_1).add(I6_9D_1);
1085 split_AB = split_A;
1086 split_AB &= I1_8D_1;
1087 split_ab.add(I1_3D_2).add(I6_8D_2);
1088
1089 BOOST_CHECK_EQUAL( split_AB, split_ab );
1090
1091 split_AB = split_A;
1092 (split_AB &= I1_8D_1) &= I2_7D_1;
1093 split_ab2.add(I2_3D_3).add(I6_7D_3);
1094
1095 BOOST_CHECK_EQUAL( split_AB, split_ab2 );
1096
1097
1098 //--------------------------------------------------------------------------
1099 //split_A [0 3) [6 9)
1100 // 1 1
1101 // &= 1
1102 // 1
1103 //split_AB -> [1]
1104 // 2
1105 // += (1 7)
1106 // 2
1107 // -> [1](1 7)
1108 // 2 2
1109 split_A.clear();
1110 split_A.add(I0_3D_1).add(I6_9D_1);
1111 split_AB = split_A;
1112 split_AB &= mapping_pair<T,U>(v1,u1);
1113 split_ab.clear();
1114 split_ab.add(mapping_pair<T,U>(v1,u2));
1115
1116 BOOST_CHECK_EQUAL( split_AB, split_ab );
1117
1118 split_AB = split_A;
1119 split_AB &= mapping_pair<T,U>(v1,u1);
1120 split_AB += make_pair(IntervalT::open(v1,v7), u2);
1121 split_ab2.clear();
1122 split_ab2 += make_pair(IntervalT::right_open(v1,v7), u2);
1123
1124 BOOST_CHECK_EQUAL( is_element_equal(split_AB, split_ab2), true );
1125 }
1126
1127
1128 template <class T, class U>
interval_map_mixed_basic_intersect2_4_bicremental_types()1129 void interval_map_mixed_basic_intersect2_4_bicremental_types()
1130 {
1131 typedef interval_map<T,U> IntervalMapT;
1132 typedef split_interval_map<T,U> SplitIntervalMapT;
1133 typedef interval_set<T> IntervalSetT;
1134 typedef split_interval_set<T> SplitIntervalSetT;
1135 typedef typename IntervalMapT::interval_type IntervalT;
1136
1137 U u1 = make<U>(1);
1138 U u2 = make<U>(2);
1139 U u3 = make<U>(3);
1140
1141 T v0 = make<T>(0);
1142 T v1 = make<T>(1);
1143 T v2 = make<T>(2);
1144 T v3 = make<T>(3);
1145
1146
1147 T v6 = make<T>(6);
1148 T v7 = make<T>(7);
1149 T v8 = make<T>(8);
1150 T v9 = make<T>(9);
1151
1152 IntervalT I0_3D = IntervalT::right_open(v0,v3);
1153 IntervalT I1_3D = IntervalT::right_open(v1,v3);
1154 IntervalT I1_8D = IntervalT::right_open(v1,v8);
1155 IntervalT I2_7D = IntervalT::right_open(v2,v7);
1156 IntervalT I2_3D = IntervalT::right_open(v2,v3);
1157 IntervalT I6_7D = IntervalT::right_open(v6,v7);
1158 IntervalT I6_8D = IntervalT::right_open(v6,v8);
1159 IntervalT I6_9D = IntervalT::right_open(v6,v9);
1160
1161 std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
1162 std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
1163 std::pair<IntervalT,U> I1_3D_2(I1_3D, u2);
1164 std::pair<IntervalT,U> I1_8D_1(I1_8D, u1);
1165 std::pair<IntervalT,U> I2_7D_1(I2_7D, u1);
1166 std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
1167 std::pair<IntervalT,U> I2_3D_3(I2_3D, u3);
1168 std::pair<IntervalT,U> I6_7D_1(I6_7D, u1);
1169 std::pair<IntervalT,U> I6_7D_3(I6_7D, u3);
1170 std::pair<IntervalT,U> I6_8D_1(I6_8D, u1);
1171 std::pair<IntervalT,U> I6_8D_2(I6_8D, u2);
1172 std::pair<IntervalT,U> I6_9D_1(I6_9D, u1);
1173
1174 //--------------------------------------------------------------------------
1175 // split_interval_map
1176 //--------------------------------------------------------------------------
1177 //split_A [0 3) [6 9)
1178 // &= [1 8)
1179 //split_AB -> [1 3) [6 8)
1180 // &= [2 7)
1181 // -> [2 3) [6 7)
1182 SplitIntervalMapT split_A, split_B, split_AB, split_ab, split_ab2;
1183
1184 split_A.add(I0_3D_1).add(I6_9D_1);
1185 split_AB = split_A;
1186 split_AB &= I1_8D;
1187 split_ab.add(I1_3D_1).add(I6_8D_1);
1188
1189 BOOST_CHECK_EQUAL( split_AB, split_ab );
1190
1191 split_AB = split_A;
1192 (split_AB &= I1_8D) &= I2_7D;
1193 split_ab2.add(I2_3D_1).add(I6_7D_1);
1194
1195 BOOST_CHECK_EQUAL( split_AB, split_ab2 );
1196
1197 //--------------------------------------------------------------------------
1198 //split_A [0 3) [6 9)
1199 // 1 1
1200 // &= 1
1201 // 1
1202 //split_AB -> [1]
1203 // 2
1204 // += (1 7)
1205 // 2
1206 // -> [1](1 7)
1207 // 2 2
1208 split_A.clear();
1209 split_A.add(I0_3D_1).add(I6_9D_1);
1210 split_AB = split_A;
1211 split_AB &= v1;
1212 split_ab.clear();
1213 split_ab.add(mapping_pair<T,U>(v1,u1));
1214
1215 BOOST_CHECK_EQUAL( split_AB, split_ab );
1216
1217 split_AB = split_A;
1218 split_AB &= IntervalT(v1);
1219 split_AB += make_pair(IntervalT::open(v1,v7), u1);
1220 split_ab2.clear();
1221 split_ab2 += make_pair(IntervalT::right_open(v1,v7), u1);
1222
1223 BOOST_CHECK_EQUAL( is_element_equal(split_AB, split_ab2), true );
1224
1225 split_interval_map<T,U> left, right;
1226 left. add(IDv(0,2,2));
1227 right.add(IDv(0,2,2));
1228 BOOST_CHECK_EQUAL( is_element_equal(left, right), true );
1229
1230 split_interval_set<T> left2, right2;
1231 left2. add(I_D(0,2));
1232 right2.add(I_D(0,1));
1233 is_element_equal(left2, right2);
1234 BOOST_CHECK_EQUAL( is_element_equal(left2, right2), false );
1235 }
1236
1237
1238 template <class T, class U>
interval_map_mixed_intersect_4_bicremental_types()1239 void interval_map_mixed_intersect_4_bicremental_types()
1240 {
1241 typedef interval_map<T,U> IntervalMapT;
1242 typedef split_interval_map<T,U> SplitIntervalMapT;
1243 typedef interval_set<T> IntervalSetT;
1244 typedef split_interval_set<T> SplitIntervalSetT;
1245 typedef typename IntervalMapT::interval_type IntervalT;
1246
1247 U u1 = make<U>(1);
1248 U u2 = make<U>(2);
1249
1250
1251 T v0 = make<T>(0);
1252 T v1 = make<T>(1);
1253 T v2 = make<T>(2);
1254 T v3 = make<T>(3);
1255 T v4 = make<T>(4);
1256 T v5 = make<T>(5);
1257 T v6 = make<T>(6);
1258
1259 T v8 = make<T>(8);
1260 T v9 = make<T>(9);
1261
1262 IntervalT I0_3D = IntervalT::right_open(v0,v3);
1263 IntervalT I1_2D = IntervalT::right_open(v1,v2);
1264 IntervalT I1_3D = IntervalT::right_open(v1,v3);
1265 IntervalT I2_3D = IntervalT::right_open(v2,v3);
1266 IntervalT I2_4D = IntervalT::right_open(v2,v4);
1267 IntervalT I5_8D = IntervalT::right_open(v5,v8);
1268 IntervalT I6_8D = IntervalT::right_open(v6,v8);
1269 IntervalT I6_9D = IntervalT::right_open(v6,v9);
1270
1271 std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
1272 std::pair<IntervalT,U> I1_2D_1(I1_2D, u1);
1273 std::pair<IntervalT,U> I1_2D_2(I1_2D, u2);
1274 std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
1275 std::pair<IntervalT,U> I1_3D_2(I1_3D, u2);
1276 std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
1277 std::pair<IntervalT,U> I2_3D_2(I2_3D, u2);
1278 std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
1279 std::pair<IntervalT,U> I5_8D_1(I5_8D, u1);
1280 std::pair<IntervalT,U> I6_8D_1(I6_8D, u1);
1281 std::pair<IntervalT,U> I6_8D_2(I6_8D, u2);
1282 std::pair<IntervalT,U> I6_9D_1(I6_9D, u1);
1283
1284 //--------------------------------------------------------------------------
1285 // split_interval_set
1286 //--------------------------------------------------------------------------
1287 //split_A [0 3) [6 9)
1288 // 1 1
1289 //split_B &= [1 2)[2 4) [5 8)
1290 // 1 1 1
1291 //split_AB -> [1 2)[2 3) [6 8)
1292 // 2 2 2
1293 SplitIntervalMapT split_A, split_B, split_AB, split_ab, split_ab_jn;
1294 IntervalMapT join_A, join_B, join_AB, join_ab;
1295
1296 split_A.add(I0_3D_1).add(I6_9D_1);
1297 split_B.add(I1_2D_1).add(I2_4D_1).add(I5_8D_1);
1298 split_ab.add(I1_2D_2).add(I2_3D_2).add(I6_8D_2);
1299 split_ab_jn.add(I1_3D_2).add(I6_8D_2);
1300 split_AB = split_A;
1301 split_AB &= split_B;
1302 BOOST_CHECK_EQUAL( iterative_size(split_AB), 3 );
1303 BOOST_CHECK_EQUAL( split_AB, split_ab );
1304
1305 //split_A [0 3) [6 9)
1306 // 1 1
1307 //join_B &= [1 4) [5 8)
1308 // 1 1
1309 //split_AB -> [1 3) [6 8)
1310 // 2 2
1311 split_AB = split_A;
1312 join_B = split_B;
1313 split_AB &= join_B;
1314
1315 BOOST_CHECK_EQUAL( iterative_size(split_AB), 2 );
1316 BOOST_CHECK_EQUAL( split_AB, split_ab_jn );
1317 }
1318
1319
1320
1321 template <class T, class U>
interval_map_mixed_intersect2_4_bicremental_types()1322 void interval_map_mixed_intersect2_4_bicremental_types()
1323 {
1324 typedef interval_map<T,U> IntervalMapT;
1325 typedef split_interval_map<T,U> SplitIntervalMapT;
1326 typedef interval_set<T> IntervalSetT;
1327 typedef split_interval_set<T> SplitIntervalSetT;
1328 typedef typename IntervalMapT::interval_type IntervalT;
1329
1330 U u1 = make<U>(1);
1331 U u2 = make<U>(2);
1332
1333
1334 T v0 = make<T>(0);
1335 T v1 = make<T>(1);
1336 T v2 = make<T>(2);
1337 T v3 = make<T>(3);
1338 T v4 = make<T>(4);
1339 T v5 = make<T>(5);
1340 T v6 = make<T>(6);
1341
1342 T v8 = make<T>(8);
1343 T v9 = make<T>(9);
1344
1345 IntervalT I0_3D = IntervalT::right_open(v0,v3);
1346 IntervalT I1_2D = IntervalT::right_open(v1,v2);
1347 IntervalT I1_3D = IntervalT::right_open(v1,v3);
1348 IntervalT I2_3D = IntervalT::right_open(v2,v3);
1349 IntervalT I2_4D = IntervalT::right_open(v2,v4);
1350 IntervalT I5_8D = IntervalT::right_open(v5,v8);
1351 IntervalT I6_8D = IntervalT::right_open(v6,v8);
1352 IntervalT I6_9D = IntervalT::right_open(v6,v9);
1353
1354 std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
1355 std::pair<IntervalT,U> I1_2D_1(I1_2D, u1);
1356 std::pair<IntervalT,U> I1_2D_2(I1_2D, u2);
1357 std::pair<IntervalT,U> I1_3D_1(I1_3D, u1);
1358 std::pair<IntervalT,U> I1_3D_2(I1_3D, u2);
1359 std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
1360 std::pair<IntervalT,U> I2_3D_2(I2_3D, u2);
1361 std::pair<IntervalT,U> I2_4D_1(I2_4D, u1);
1362 std::pair<IntervalT,U> I5_8D_1(I5_8D, u1);
1363 std::pair<IntervalT,U> I6_8D_1(I6_8D, u1);
1364 std::pair<IntervalT,U> I6_8D_2(I6_8D, u2);
1365 std::pair<IntervalT,U> I6_9D_1(I6_9D, u1);
1366
1367 //--------------------------------------------------------------------------
1368 // split_interval_set
1369 //--------------------------------------------------------------------------
1370 //split_A [0 3) [6 9)
1371 // 1 1
1372 //split_B &= [1 2)[2 4) [5 8)
1373 //split_AB -> [1 2)[2 3) [6 8)
1374 // 1 1 1
1375 SplitIntervalMapT split_A, split_AB, split_ab, split_ab_jn;
1376 SplitIntervalSetT split_B;
1377 IntervalMapT join_A, join_AB, join_ab;
1378 IntervalSetT join_B;
1379
1380 split_A.add(I0_3D_1).add(I6_9D_1);
1381 split_B.add(I1_2D).add(I2_4D).add(I5_8D);
1382 split_ab.add(I1_2D_1).add(I2_3D_1).add(I6_8D_1);
1383 split_ab_jn.add(I1_3D_1).add(I6_8D_1);
1384 split_AB = split_A;
1385 split_AB &= split_B;
1386 BOOST_CHECK_EQUAL( iterative_size(split_AB), 3 );
1387 BOOST_CHECK_EQUAL( split_AB, split_ab );
1388
1389 //split_A [0 3) [6 9)
1390 // 1 1
1391 //join_B &= [1 4) [5 8)
1392 //split_AB -> [1 3) [6 8)
1393 // 1 1
1394 split_AB = split_A;
1395 join_B = split_B;
1396 split_AB &= join_B;
1397
1398 BOOST_CHECK_EQUAL( iterative_size(split_AB), 2 );
1399 BOOST_CHECK_EQUAL( split_AB, split_ab_jn );
1400 }
1401
1402
1403 template <class T, class U>
interval_map_mixed_disjoint_4_bicremental_types()1404 void interval_map_mixed_disjoint_4_bicremental_types()
1405 {
1406 typedef interval_map<T,U> IntervalMapT;
1407 typedef split_interval_map<T,U> SplitIntervalMapT;
1408 typedef interval_set<T> IntervalSetT;
1409 typedef split_interval_set<T> SplitIntervalSetT;
1410 typedef typename IntervalMapT::interval_type IntervalT;
1411
1412 U u1 = make<U>(1);
1413 T v0 = make<T>(0);
1414 T v2 = make<T>(2);
1415 T v3 = make<T>(3);
1416 T v4 = make<T>(4);
1417 T v6 = make<T>(6);
1418
1419 IntervalT I0_2D = IntervalT::right_open(v0,v2);
1420 IntervalT I2_3D = IntervalT::right_open(v2,v3);
1421 IntervalT I3_4D = IntervalT::right_open(v3,v4);
1422 IntervalT I4_4I = IntervalT::closed(v4,v4);
1423 IntervalT C4_6D = IntervalT::open(v4,v6);
1424 IntervalT I6_6I = IntervalT::closed(v6,v6);
1425
1426 std::pair<IntervalT,U> I0_2D_1(I0_2D, u1);
1427 std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
1428 std::pair<IntervalT,U> I3_4D_1(I3_4D, u1);
1429 std::pair<IntervalT,U> I4_4I_1(I4_4I, u1);
1430 std::pair<IntervalT,U> C4_6D_1(C4_6D, u1);
1431 std::pair<IntervalT,U> I6_6I_1(I6_6I, u1);
1432
1433 //--------------------------------------------------------------------------
1434 //split_A: [0 2) [4 4] [6 6]
1435 //split_B: [2 3)[3 4) (4 6)
1436 SplitIntervalMapT split_A, split_B;
1437
1438 split_A.add(I0_2D_1).add(I4_4I_1).add(I6_6I_1);
1439 split_B.add(I2_3D_1).add(I3_4D_1).add(C4_6D_1);
1440
1441 IntervalMapT join_A(split_A), join_B(split_B);
1442
1443 BOOST_CHECK_EQUAL( disjoint(split_A, split_B), true );
1444 BOOST_CHECK_EQUAL( disjoint(split_A, join_B), true );
1445
1446 BOOST_CHECK_EQUAL( disjoint(join_A, split_B), true );
1447 BOOST_CHECK_EQUAL( disjoint(join_A, join_B), true );
1448 }
1449
1450 template<class Type>
1451 struct size_greater_1 : public icl::property<Type>
1452 {
operator ()size_greater_11453 bool operator()(const Type& value)const
1454 {
1455 return icl::size(value.first) > 1 ;
1456 }
1457 };
1458
1459
1460 template <class T, class U>
interval_map_mixed_erase_if_4_integral_types()1461 void interval_map_mixed_erase_if_4_integral_types()
1462 {
1463 typedef interval_map<T,U> IntervalMapT;
1464 typedef split_interval_map<T,U> SplitIntervalMapT;
1465 typedef interval_set<T> IntervalSetT;
1466 typedef split_interval_set<T> SplitIntervalSetT;
1467 typedef typename IntervalMapT::interval_type IntervalT;
1468
1469 U u1 = make<U>(1);
1470 T v0 = make<T>(0);
1471 T v2 = make<T>(2);
1472 T v3 = make<T>(3);
1473 T v4 = make<T>(4);
1474 T v6 = make<T>(6);
1475
1476 IntervalT I0_3D = IntervalT::right_open(v0,v3);
1477 IntervalT I2_3D = IntervalT::right_open(v2,v3);
1478 IntervalT I3_4D = IntervalT::right_open(v3,v4);
1479 IntervalT I4_4I = IntervalT::closed(v4,v4);
1480 IntervalT C4_6D = IntervalT::open(v4,v6);
1481 IntervalT I6_6I = IntervalT::closed(v6,v6);
1482
1483 std::pair<IntervalT,U> I0_3D_1(I0_3D, u1);
1484 std::pair<IntervalT,U> I2_3D_1(I2_3D, u1);
1485 std::pair<IntervalT,U> I3_4D_1(I3_4D, u1);
1486 std::pair<IntervalT,U> I4_4I_1(I4_4I, u1);
1487 std::pair<IntervalT,U> C4_6D_1(C4_6D, u1);
1488 std::pair<IntervalT,U> I6_6I_1(I6_6I, u1);
1489
1490 //--------------------------------------------------------------------------
1491 //split_A: [0 2) [4 4] [6 6]
1492 //split_B: [2 3)[3 4) (4 6)
1493 SplitIntervalMapT split_A, split_B;
1494
1495 split_A.add(I0_3D_1).add(I4_4I_1).add(I6_6I_1);
1496 split_B.add(I4_4I_1).add(I6_6I_1);
1497
1498 icl::erase_if(size_greater_1<typename SplitIntervalMapT::value_type>(), split_A);
1499
1500 BOOST_CHECK_EQUAL( split_A, split_B );
1501 }
1502
1503 //------------------------------------------------------------------------------
1504 //- infix operators
1505 //------------------------------------------------------------------------------
1506
1507 template <class T, class U>
interval_map_mixed_infix_plus_overload_4_bicremental_types()1508 void interval_map_mixed_infix_plus_overload_4_bicremental_types()
1509 {
1510 typedef interval_map<T,U> IntervalMapT;
1511 typedef typename IntervalMapT::interval_type IntervalT;
1512
1513 interval_map<T,U> join_a;
1514 split_interval_map<T,U> split_a;
1515
1516 join_a .add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
1517 split_a.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
1518
1519 BOOST_CHECK_EQUAL(split_a + join_a, join_a + split_a);
1520 }
1521
1522 template <class T, class U>
interval_map_mixed_infix_pipe_overload_4_bicremental_types()1523 void interval_map_mixed_infix_pipe_overload_4_bicremental_types()
1524 {
1525 typedef interval_map<T,U> IntervalMapT;
1526 interval_map<T,U> join_a;
1527 split_interval_map<T,U> split_a;
1528
1529 join_a .add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
1530 split_a.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
1531
1532 BOOST_CHECK_EQUAL(split_a | join_a, join_a | split_a);
1533 }
1534
1535 template <class T, class U>
interval_map_mixed_infix_minus_overload_4_bicremental_types()1536 void interval_map_mixed_infix_minus_overload_4_bicremental_types()
1537 {
1538 typedef interval_map<T,U> IntervalMapT;
1539 interval_map<T,U> join_a, join_b;
1540 split_interval_map<T,U> split_a, split_b;
1541
1542 join_a .add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
1543 split_a.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
1544
1545 join_b .add(CDv(1,3,1)).add(IIv(6,11,3));
1546 split_b.add(IDv(0,9,2)).add(IIv(3,6,1));
1547
1548 BOOST_CHECK_EQUAL(split_a - join_a, (split_b = split_a) -= join_a);
1549 BOOST_CHECK_EQUAL(split_a - join_a, split_b);
1550
1551 BOOST_CHECK_EQUAL(join_a - split_a, (join_b = join_a) -= split_a);
1552 BOOST_CHECK_EQUAL(join_a - split_a, join_b);
1553 }
1554
1555 template <class T, class U>
interval_map_mixed_infix_et_overload_4_bicremental_types()1556 void interval_map_mixed_infix_et_overload_4_bicremental_types()
1557 {
1558 typedef interval_map<T,U> IntervalMapT;
1559 interval_map<T,U> join_a, join_b;
1560 split_interval_map<T,U> split_a, split_b;
1561
1562 join_a .add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
1563 split_a.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
1564
1565 BOOST_CHECK_EQUAL(split_a & join_a, join_a & split_a);
1566 BOOST_CHECK_EQUAL(split_a & join_a, (split_b = split_a) &= join_a);
1567 BOOST_CHECK_EQUAL(split_a & join_a, split_b);
1568
1569 BOOST_CHECK_EQUAL(join_a & split_a, (split_b = split_a) &= join_a);
1570 BOOST_CHECK_EQUAL(join_a & split_a, split_b);
1571 }
1572
1573
1574
1575 #endif // LIBS_ICL_TEST_TEST_ICL_interval_map_mixed_hpp_JOFA_081005__
1576
1577
1578