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