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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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 | { |
1441 | bool operator()(const Type& value)const |
1442 | { |
1443 | return icl::size(value.first) > 1 ; |
1444 | } |
1445 | }; |
1446 | |
1447 | |
1448 | template <class T, class U> |
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> |
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> |
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> |
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> |
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 | |