1/*-----------------------------------------------------------------------------+
2Copyright (c) 2008-2012: Joachim Faulhaber
3+------------------------------------------------------------------------------+
4 Distributed under the Boost Software License, Version 1.0.
5 (See accompanying file LICENCE.txt or copy at
6 http://www.boost.org/LICENSE_1_0.txt)
7+-----------------------------------------------------------------------------*/
8#ifndef LIBS_ICL_TEST_TEST_INTERVAL_MAP_SHARED_HPP_JOFA_081005
9#define LIBS_ICL_TEST_TEST_INTERVAL_MAP_SHARED_HPP_JOFA_081005
10
11#include "portability.hpp"
12
13template
14<
15#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
16 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
17#else
18 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
19#endif
20 class T, class U
21>
22void interval_map_fundamentals_4_ordered_types()
23{
24 typedef IntervalMap<T,U> IntervalMapT;
25 typedef typename IntervalMapT::interval_type IntervalT;
26 typedef typename IntervalMapT::size_type size_T;
27
28 // ordered types is the largest set of instance types.
29 // Because we can not generate values via incrementation for e.g. string,
30 // we are able to test operations only for the most basic values
31 // identity_element (0, empty, T() ...) and unit_element.
32
33 T v0 = boost::icl::identity_element<T>::value();
34 T v1 = unit_element<T>::value();
35 IntervalT I0_0I(v0);
36 IntervalT I1_1I(v1);
37#ifndef BOOST_ICL_USE_STATIC_BOUNDED_INTERVALS
38 IntervalT I0_1I(v0, v1, interval_bounds::closed());
39#else
40 IntervalT I0_1I = icl::interval<T>::closed(v0, v1);
41#endif
42 U u1 = unit_element<U>::value();
43
44 //-------------------------------------------------------------------------
45 //empty set
46 //-------------------------------------------------------------------------
47 BOOST_CHECK_EQUAL(IntervalMapT().empty(), true);
48 BOOST_CHECK_EQUAL(icl::is_empty(IntervalMapT()), true);
49 BOOST_CHECK_EQUAL(cardinality(IntervalMapT()), boost::icl::identity_element<size_T>::value());
50 BOOST_CHECK_EQUAL(IntervalMapT().size(), boost::icl::identity_element<size_T>::value());
51 BOOST_CHECK_EQUAL(icl::size(IntervalMapT()), boost::icl::identity_element<size_T>::value());
52 BOOST_CHECK_EQUAL(interval_count(IntervalMapT()), 0);
53 BOOST_CHECK_EQUAL(IntervalMapT().iterative_size(), 0);
54 BOOST_CHECK_EQUAL(iterative_size(IntervalMapT()), 0);
55 BOOST_CHECK_EQUAL(IntervalMapT(), IntervalMapT());
56
57 IntervalT mt_interval = boost::icl::identity_element<IntervalT >::value();
58 BOOST_CHECK_EQUAL(mt_interval, IntervalT());
59 typename IntervalMapT::value_type mt_u1 = make_pair(mt_interval, u1);
60 IntervalMapT mt_map = boost::icl::identity_element<IntervalMapT >::value();
61 BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
62
63 //adding emptieness to emptieness yields emptieness ;)
64 mt_map.add(mt_u1).add(mt_u1);
65 BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
66 mt_map.insert(mt_u1).insert(mt_u1);
67 BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
68 (mt_map += mt_u1) += mt_u1;
69 BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
70 BOOST_CHECK_EQUAL(hull(mt_map), boost::icl::identity_element<IntervalT >::value());
71
72 //subtracting emptieness
73 mt_map.subtract(mt_u1).subtract(mt_u1);
74 BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
75
76 mt_map.erase(mt_interval).erase(mt_interval);
77 BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
78 (mt_map -= mt_u1) -= mt_u1;
79 BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
80
81 //subtracting elements form emptieness
82 typename IntervalMapT::domain_mapping_type v0_u1 = make_pair(v0,u1);
83 typename IntervalMapT::domain_mapping_type v1_u1 = make_pair(v1,u1);
84 //mt_map.subtract(make_pair(v0,u1)).subtract(make_pair(v1,u1));
85 mt_map.subtract(v0_u1).subtract(v1_u1);
86 BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
87 mt_map.erase(v0_u1).erase(v1_u1);
88 BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
89 (mt_map -= v0_u1) -= v1_u1;
90 BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
91
92 //subtracting intervals form emptieness
93 typename IntervalMapT::segment_type I0_0I_u1 = make_pair(I0_0I,u1);
94 typename IntervalMapT::segment_type I0_1I_u1 = make_pair(I0_1I,u1);
95 typename IntervalMapT::segment_type I1_1I_u1 = make_pair(I1_1I,u1);
96 mt_map.subtract(I0_1I_u1).subtract(I1_1I_u1);
97 BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
98 mt_map.erase(I0_1I_u1).erase(I1_1I_u1);
99 BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
100 (mt_map -= I0_1I_u1) -= I1_1I_u1;
101 BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
102
103 mt_map.erase(I0_1I).erase(I1_1I);
104 BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
105
106 //insecting emptieness
107 (mt_map &= mt_u1) &= mt_u1;
108 BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
109 (mt_map &= mt_interval) &= mt_interval;
110 BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
111
112
113
114 //-------------------------------------------------------------------------
115 //unary set
116 //-------------------------------------------------------------------------
117 IntervalMapT single_I0_0I_u1_from_element(v0_u1);
118 IntervalMapT single_I0_0I_u1_from_interval(I0_0I_u1);
119 IntervalMapT single_I0_0I_u1(single_I0_0I_u1_from_interval);
120
121 BOOST_CHECK_EQUAL(single_I0_0I_u1_from_element, single_I0_0I_u1_from_interval);
122 BOOST_CHECK_EQUAL(single_I0_0I_u1_from_element, single_I0_0I_u1);
123 BOOST_CHECK_EQUAL(hull(single_I0_0I_u1), I0_0I);
124 BOOST_CHECK_EQUAL(hull(single_I0_0I_u1).lower(), I0_0I.lower());
125 BOOST_CHECK_EQUAL(hull(single_I0_0I_u1).upper(), I0_0I.upper());
126
127 IntervalMapT single_I1_1I_u1_from_element(v1_u1);
128 IntervalMapT single_I1_1I_u1_from_interval(I1_1I_u1);
129 IntervalMapT single_I1_1I_u1(single_I1_1I_u1_from_interval);
130
131 BOOST_CHECK_EQUAL(single_I1_1I_u1_from_element, single_I1_1I_u1_from_interval);
132 BOOST_CHECK_EQUAL(single_I1_1I_u1_from_element, single_I1_1I_u1);
133
134 IntervalMapT single_I0_1I_u1_from_interval(I0_1I_u1);
135 IntervalMapT single_I0_1I_u1(single_I0_1I_u1_from_interval);
136
137 BOOST_CHECK_EQUAL(single_I0_1I_u1_from_interval, single_I0_1I_u1);
138 BOOST_CHECK_EQUAL(hull(single_I0_1I_u1), I0_1I);
139 BOOST_CHECK_EQUAL(hull(single_I0_1I_u1).lower(), I0_1I.lower());
140 BOOST_CHECK_EQUAL(hull(single_I0_1I_u1).upper(), I0_1I.upper());
141
142 //contains predicate
143 BOOST_CHECK_EQUAL(icl::contains(single_I0_0I_u1, v0), true);
144 BOOST_CHECK_EQUAL(icl::contains(single_I0_0I_u1, v0_u1), true);
145 BOOST_CHECK_EQUAL(icl::contains(single_I0_0I_u1, I0_0I_u1), true);
146
147 BOOST_CHECK_EQUAL(icl::contains(single_I1_1I_u1, v1), true);
148 BOOST_CHECK_EQUAL(icl::contains(single_I1_1I_u1, v1_u1), true);
149 BOOST_CHECK_EQUAL(icl::contains(single_I1_1I_u1, I1_1I_u1), true);
150
151 BOOST_CHECK_EQUAL(icl::contains(single_I0_1I_u1, v0), true);
152 BOOST_CHECK_EQUAL(icl::contains(single_I0_1I_u1, I0_1I_u1), true);
153 BOOST_CHECK_EQUAL(icl::contains(single_I0_1I_u1, v1), true);
154 BOOST_CHECK_EQUAL(icl::contains(single_I0_1I_u1, I1_1I_u1), true);
155
156 BOOST_CHECK_EQUAL(icl::contains(single_I0_1I_u1, single_I0_0I_u1), true);
157 BOOST_CHECK_EQUAL(icl::contains(single_I0_1I_u1, single_I1_1I_u1), true);
158 BOOST_CHECK_EQUAL(icl::contains(single_I0_1I_u1, single_I0_1I_u1), true);
159
160 BOOST_CHECK_EQUAL(cardinality(single_I0_0I_u1), unit_element<size_T>::value());
161 BOOST_CHECK_EQUAL(single_I0_0I_u1.size(), unit_element<size_T>::value());
162 BOOST_CHECK_EQUAL(interval_count(single_I0_0I_u1), 1);
163 BOOST_CHECK_EQUAL(single_I0_0I_u1.iterative_size(), 1);
164 BOOST_CHECK_EQUAL(iterative_size(single_I0_0I_u1), 1);
165
166}
167
168template
169<
170#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
171 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
172#else
173 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
174#endif
175 class T, class U
176>
177void interval_map_ctor_4_bicremental_types()
178{
179 typedef IntervalMap<T,U> IntervalMapT;
180 typedef typename IntervalMapT::interval_type IntervalT;
181
182 T v4 = make<T>(4);
183 U u2 = make<U>(2);
184 IntervalT I4_4I(v4);
185 typename IntervalMapT::domain_mapping_type v4_u2(v4,u2);
186 typename IntervalMapT::value_type I4_4I_u2(I4_4I,u2);
187
188 IntervalMapT _I4_4I_u2;
189 BOOST_CHECK_EQUAL( _I4_4I_u2.empty(), true );
190 IntervalMapT _I4_4I_u2_1;
191 IntervalMapT _I4_4I_u2_2;
192 IntervalMapT _I4_4I_u2_3;
193 _I4_4I_u2 += v4_u2;
194 _I4_4I_u2_1 += I4_4I_u2;
195 BOOST_CHECK_EQUAL( _I4_4I_u2, _I4_4I_u2_1 );
196 _I4_4I_u2_2.add(v4_u2);
197 BOOST_CHECK_EQUAL( _I4_4I_u2, _I4_4I_u2_2 );
198 _I4_4I_u2_3.add(I4_4I_u2);
199 BOOST_CHECK_EQUAL( _I4_4I_u2, _I4_4I_u2_3 );
200
201 _I4_4I_u2.clear();
202 _I4_4I_u2.add(I4_4I_u2).add(I4_4I_u2);
203 IntervalMapT _I4_4I_u4(make_pair(I4_4I, make<U>(4)));
204 BOOST_CHECK_EQUAL( _I4_4I_u2, _I4_4I_u4 );
205
206 _I4_4I_u2.clear();
207 _I4_4I_u2.insert(I4_4I_u2).insert(I4_4I_u2);
208 BOOST_CHECK_EQUAL( _I4_4I_u2, _I4_4I_u2_1 );
209
210 BOOST_CHECK_EQUAL( cardinality(_I4_4I_u2), unit_element<typename IntervalMapT::size_type>::value() );
211 BOOST_CHECK_EQUAL( _I4_4I_u2.size(), unit_element<typename IntervalMapT::size_type>::value() );
212 BOOST_CHECK_EQUAL( interval_count(_I4_4I_u2), 1 );
213 BOOST_CHECK_EQUAL( _I4_4I_u2.iterative_size(), 1 );
214 BOOST_CHECK_EQUAL( iterative_size(_I4_4I_u2), 1 );
215
216 if(has_dynamic_bounds<IntervalT>::value)
217 {
218 BOOST_CHECK_EQUAL( hull(_I4_4I_u2).lower(), v4 );
219 BOOST_CHECK_EQUAL( hull(_I4_4I_u2).upper(), v4 );
220 }
221
222 IntervalMapT _I4_4I_u2_copy(_I4_4I_u2);
223 IntervalMapT _I4_4I_u2_assigned;
224 _I4_4I_u2_assigned = _I4_4I_u2;
225 BOOST_CHECK_EQUAL( _I4_4I_u2, _I4_4I_u2_copy );
226 BOOST_CHECK_EQUAL( _I4_4I_u2, _I4_4I_u2_assigned );
227
228 _I4_4I_u2_assigned.clear();
229 BOOST_CHECK_EQUAL( true, _I4_4I_u2_assigned.empty() );
230
231 _I4_4I_u2_assigned.swap(_I4_4I_u2_copy);
232 BOOST_CHECK_EQUAL( true, _I4_4I_u2_copy.empty() );
233 BOOST_CHECK_EQUAL( _I4_4I_u2, _I4_4I_u2_assigned );
234}
235
236
237template
238<
239#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
240 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
241#else
242 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
243#endif
244 class T, class U
245>
246void interval_map_add_sub_4_bicremental_types()
247{
248 typedef IntervalMap<T,U> IntervalMapT;
249 typedef typename IntervalMapT::interval_type IntervalT;
250
251 T v0 = make<T>(0);
252 T v5 = make<T>(5);
253 T v6 = make<T>(6);
254 T v9 = make<T>(9);
255 U u1 = make<U>(1);
256#ifndef BOOST_ICL_USE_STATIC_BOUNDED_INTERVALS
257 IntervalT I5_6I(v5,v6, interval_bounds::closed());
258 IntervalT I5_9I(v5,v9, interval_bounds::closed());
259 IntervalT I0_9I = IntervalT::closed(v0, v9);
260#else
261 IntervalT I5_6I = icl::interval<T>::closed(v5,v6);
262 IntervalT I5_9I = icl::interval<T>::closed(v5,v9);
263 IntervalT I0_9I = icl::interval<T>::closed(v0,v9);
264#endif
265 typename IntervalMapT::domain_mapping_type v0_u1 = make_pair(v0, u1);
266 typename IntervalMapT::domain_mapping_type v9_u1 = make_pair(v9, u1);
267 typename IntervalMapT::value_type I5_6I_u1 = make_pair(I5_6I, u1);
268 typename IntervalMapT::value_type I5_9I_u1 = make_pair(I5_9I, u1);
269
270 BOOST_CHECK_EQUAL( IntervalMapT(I5_6I_u1).add(v0_u1).add(v9_u1),
271 IntervalMapT().add(v9_u1).add(I5_6I_u1).add(v0_u1) );
272
273 IntervalMapT map_A = IntervalMapT(I5_6I_u1).add(v0_u1).add(v9_u1);
274 IntervalMapT map_B = IntervalMapT().insert(v9_u1).insert(I5_6I_u1).insert(v0_u1);
275 BOOST_CHECK_EQUAL( map_A, map_B );
276 BOOST_CHECK_EQUAL( hull(map_A), I0_9I );
277 BOOST_CHECK_EQUAL( hull(map_A).lower(), I0_9I.lower() );
278 BOOST_CHECK_EQUAL( hull(map_A).upper(), I0_9I.upper() );
279
280 IntervalMapT map_A1 = map_A, map_B1 = map_B,
281 map_A2 = map_A, map_B2 = map_B;
282
283 map_A1.subtract(I5_6I_u1).subtract(v9_u1);
284 map_B1.erase(v9_u1).erase(I5_6I_u1);
285 BOOST_CHECK_EQUAL( map_A1, map_B1 );
286
287 map_B1 = map_B;
288 map_B2.erase(v9).erase(I5_6I);
289 BOOST_CHECK_EQUAL( map_A1, map_B2 );
290
291 map_A2.subtract(I5_9I_u1);
292 map_B2.erase(I5_9I);
293 BOOST_CHECK_EQUAL( map_A2, map_B2 );
294}
295
296template
297<
298#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
299 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
300#else
301 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
302#endif
303 class T, class U
304>
305void interval_map_distinct_4_bicremental_types()
306{
307 typedef IntervalMap<T,U> IntervalMapT;
308 typedef typename IntervalMap<T,U>::size_type size_T;
309 T v1 = make<T>(1);
310 T v3 = make<T>(3);
311 T v5 = make<T>(5);
312 U u1 = make<U>(1);
313 typename IntervalMapT::domain_mapping_type v1_u1(v1,u1);
314 typename IntervalMapT::domain_mapping_type v3_u1(v3,u1);
315 typename IntervalMapT::domain_mapping_type v5_u1(v5,u1);
316
317 size_T s3 = make<size_T>(3);
318
319 IntervalMapT is_1_3_5;
320 is_1_3_5.add(v1_u1).add(v3_u1).add(v5_u1);
321
322 BOOST_CHECK_EQUAL( cardinality(is_1_3_5), s3 );
323 BOOST_CHECK_EQUAL( is_1_3_5.size(), s3 );
324 BOOST_CHECK_EQUAL( interval_count(is_1_3_5), 3 );
325 BOOST_CHECK_EQUAL( is_1_3_5.iterative_size(), 3 );
326 BOOST_CHECK_EQUAL( iterative_size(is_1_3_5), 3 );
327}
328
329template
330<
331#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
332 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
333#else
334 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
335#endif
336 class T, class U
337>
338void interval_map_distinct_4_bicremental_continuous_types()
339{
340#ifndef BOOST_ICL_USE_STATIC_BOUNDED_INTERVALS
341
342 typedef IntervalMap<T,U> IntervalMapT;
343 typedef typename IntervalMapT::size_type size_T;
344 typedef typename IntervalMapT::difference_type diff_T;
345 T v1 = make<T>(1);
346 T v3 = make<T>(3);
347 T v5 = make<T>(5);
348 U u1 = make<U>(1);
349 typename IntervalMapT::domain_mapping_type v1_u1(v1,u1);
350 typename IntervalMapT::domain_mapping_type v3_u1(v3,u1);
351 typename IntervalMapT::domain_mapping_type v5_u1(v5,u1);
352
353 size_T s3 = make<size_T>(3);
354 diff_T d0 = make<diff_T>(0);
355 diff_T d2 = make<diff_T>(2);
356
357 IntervalMapT is_1_3_5;
358 is_1_3_5.add(v1_u1).add(v3_u1).add(v5_u1);
359
360 BOOST_CHECK_EQUAL( cardinality(is_1_3_5), s3 );
361 BOOST_CHECK_EQUAL( is_1_3_5.size(), s3 );
362 icl::length(is_1_3_5);
363 BOOST_CHECK_EQUAL( icl::length(is_1_3_5), d0 );
364 BOOST_CHECK_EQUAL( interval_count(is_1_3_5), 3 );
365 BOOST_CHECK_EQUAL( is_1_3_5.iterative_size(), 3 );
366 BOOST_CHECK_EQUAL( iterative_size(is_1_3_5), 3 );
367
368
369 IntervalMapT is_123_5;
370 is_123_5 = is_1_3_5;
371 //OPROM: open problem: Ambiguity resolving value_type and mapping_type for overloaded o= operators.
372 //is_123_5 += make_pair(IntervalT::open(v1,v3),u1); //error C2593: 'operator +=' is ambiguous
373 //is_123_5 += make_pair<IntervalT, U>(IntervalT::open(v1,v3),u1); //error C2593: 'operator +=' is ambiguous
374 //USASO: unsatisfctory solution 1: explicit IntervalMapT::value_type instead of make_pair
375 is_123_5 += typename IntervalMapT::value_type(icl::interval<T>::open(v1,v3),u1);
376 //USASO: unsatisfctory solution 2: not implementing mapping_type version of o=
377
378 BOOST_CHECK_EQUAL( cardinality(is_123_5), icl::infinity<size_T>::value() );
379 BOOST_CHECK_EQUAL( is_123_5.size(), icl::infinity<size_T>::value() );
380 BOOST_CHECK_EQUAL( icl::length(is_123_5), d2 );
381
382#endif //BOOST_ICL_USE_STATIC_BOUNDED_INTERVALS
383}
384
385template
386<
387#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
388 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
389#else
390 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
391#endif
392 class T, class U
393>
394void interval_map_isolate_4_bicremental_continuous_types()
395{
396#ifndef BOOST_ICL_USE_STATIC_BOUNDED_INTERVALS
397
398 typedef IntervalMap<T,U> IntervalMapT;
399 typedef typename IntervalMapT::interval_type IntervalT;
400 typedef typename IntervalMapT::size_type size_T;
401
402 T v0 = make<T>(0);
403 T v2 = make<T>(2);
404 T v4 = make<T>(4);
405 U u1 = make<U>(1);
406 IntervalT I0_4I = icl::interval<T>::closed(v0,v4);
407 IntervalT C0_2D = icl::interval<T>::open(v0,v2);
408 IntervalT C2_4D = icl::interval<T>::open(v2,v4);
409 typename IntervalMapT::value_type I0_4I_u1(I0_4I,u1);
410 typename IntervalMapT::value_type C0_2D_u1(C0_2D,u1);
411 typename IntervalMapT::value_type C2_4D_u1(C2_4D,u1);
412 // {[0 4]}
413 // - { (0,2) (2,4) }
414 // = {[0] [2] [4]}
415 IntervalMapT iso_map = IntervalMapT(I0_4I_u1);
416 IntervalMapT gap_set;
417 gap_set.add(C0_2D_u1).add(C2_4D_u1);
418 iso_map -= gap_set;
419
420 BOOST_CHECK_EQUAL( cardinality(iso_map), static_cast<size_T>(3) );
421 BOOST_CHECK_EQUAL( iso_map.iterative_size(), static_cast<std::size_t>(3) );
422 BOOST_CHECK_EQUAL( iterative_size(iso_map), static_cast<std::size_t>(3) );
423 BOOST_CHECK_EQUAL( iterative_size(iso_map), static_cast<std::size_t>(3) );
424
425 IntervalMapT iso_map2;
426 iso_map2.add(I0_4I_u1);
427 iso_map2.subtract(C0_2D_u1).subtract(C2_4D_u1);
428
429 IntervalMapT iso_map3(I0_4I_u1);
430 (iso_map3 -= C0_2D_u1) -= C2_4D_u1;
431
432 IntervalMapT iso_map4;
433 iso_map4.insert(I0_4I_u1);
434 iso_map4.erase(C0_2D_u1).erase(C2_4D_u1);
435
436 BOOST_CHECK_EQUAL( iso_map, iso_map2 );
437 BOOST_CHECK_EQUAL( iso_map, iso_map3 );
438 BOOST_CHECK_EQUAL( iso_map, iso_map4 );
439#endif //BOOST_ICL_USE_STATIC_BOUNDED_INTERVALS
440}
441
442
443template
444<
445#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
446 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
447#else
448 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
449#endif
450 class T, class U
451>
452void interval_map_contains_4_bicremental_types()
453{
454 typedef IntervalMap<T,U> IntervalMapT;
455 typedef typename IntervalMapT::set_type IntervalSetT;
456
457 IntervalMapT itv_map;
458 itv_map.add(K_v(3,1));
459
460 BOOST_CHECK_EQUAL( icl::contains(itv_map, MK_v(3)), true );
461 BOOST_CHECK_EQUAL( icl::contains(itv_map, K_v(3,1)), true );
462
463 BOOST_CHECK_EQUAL( icl::contains(IntervalMapT().add(K_v(3,1)), K_v(3,1)), true );
464 BOOST_CHECK_EQUAL( icl::contains(IntervalMapT().add(K_v(3,1)), MK_v(3)), true );
465 BOOST_CHECK_EQUAL( icl::contains(IntervalMapT().insert(K_v(3,1)), K_v(3,1)), true );
466 itv_map.clear();
467 BOOST_CHECK_EQUAL( icl::contains((itv_map += IIv(3,7,1)), IIv(3,7,1)), true );
468 BOOST_CHECK_EQUAL( icl::contains(itv_map, IIv(3,7,2)), false );
469 BOOST_CHECK_EQUAL( icl::contains(itv_map, I_I(3,7)), true );
470 BOOST_CHECK_EQUAL( icl::contains(itv_map, I_I(4,6)), true );
471 BOOST_CHECK_EQUAL( icl::contains((itv_map += CIv(7,9,1)),IIv(3,9,1)), true );
472 BOOST_CHECK_EQUAL( icl::contains(itv_map, I_I(4,8)), true );
473 BOOST_CHECK_EQUAL( icl::contains((itv_map += IIv(11,12,1)), IIv(3,12,1)), false );
474 BOOST_CHECK_EQUAL( icl::contains(itv_map, I_I(4,11)), false );
475
476 IntervalMapT itv_map0 = itv_map;
477
478 itv_map.clear();
479 IntervalMapT itv_map2(IIv(5,8,1));
480 itv_map2.add(K_v(9,1)).add(K_v(11,1));
481 itv_map += itv_map2;
482 BOOST_CHECK_EQUAL( icl::contains(itv_map, itv_map2), true );
483 IntervalSetT itv_set2;
484 icl::domain(itv_set2, itv_map2);
485 BOOST_CHECK_EQUAL( icl::contains(itv_map, itv_set2), true );
486}
487
488template
489<
490#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
491 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
492#else
493 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
494#endif
495 class T, class U
496>
497void interval_map_contains_key_objects_4_bicremental_types()
498{
499 typedef IntervalMap<T,U> IntervalMapT;
500 typedef typename IntervalMapT::set_type IntervalSetT;
501 IntervalMapT itv_map;
502
503 itv_map.add(IDv(1,3,1));
504 BOOST_CHECK_EQUAL( icl::contains(itv_map, MK_v(0)), false );
505 BOOST_CHECK_EQUAL( icl::contains(itv_map, MK_v(2)), true );
506 BOOST_CHECK_EQUAL( icl::contains(itv_map, MK_v(3)), false );
507
508 itv_map.add(IDv(3,6,2));
509 BOOST_CHECK_EQUAL( icl::contains(itv_map, I_I(0,0)), false );
510 contains(itv_map, I_I(2,4));
511 BOOST_CHECK_EQUAL( icl::contains(itv_map, I_I(2,4)), true );
512 BOOST_CHECK_EQUAL( icl::contains(itv_map, I_I(6,6)), false );
513
514 itv_map.add(IDv(8,9,2));
515
516 IntervalSetT itv_set;
517 itv_set.add(C_I(1,2)).add(C_D(2,6)).add(I_I(8,8));
518 BOOST_CHECK_EQUAL( icl::contains(itv_map, itv_set), true );
519 itv_set.add(I_I(1,4));
520 BOOST_CHECK_EQUAL( icl::contains(itv_map, itv_set), true );
521 itv_set.add(I_I(1,4));
522 BOOST_CHECK_EQUAL( icl::contains(itv_map, itv_set), true );
523 itv_set.add(I_I(7,7));
524 BOOST_CHECK_EQUAL( icl::contains(itv_map, itv_set), false );
525
526}
527
528
529template
530<
531#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
532 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
533#else
534 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
535#endif
536 class T, class U
537>
538void interval_map_operators_4_bicremental_types()
539{
540 typedef IntervalMap<T,U> IntervalMapT;
541 T v0 = make<T>(0);
542 T v1 = make<T>(1);
543 T v3 = make<T>(3);
544 T v5 = make<T>(5);
545 T v7 = make<T>(7);
546 T v8 = make<T>(8);
547 U u1 = make<U>(1);
548 //typename IntervalMapT::interval_type I3_5I(icl::interval<T>::closed(v3,v5));
549 typename IntervalMapT::value_type I0_1I_u1(icl::interval<T>::closed(v0,v1),u1);
550 typename IntervalMapT::value_type I3_5I_u1(icl::interval<T>::closed(v3,v5),u1);
551 typename IntervalMapT::value_type I7_8I_u1(icl::interval<T>::closed(v7,v8),u1);
552
553 IntervalMapT left, left2, right, all, section, complement;
554 left.add(I0_1I_u1).add(I3_5I_u1);
555 (right += I3_5I_u1) += I7_8I_u1;
556 BOOST_CHECK_EQUAL( disjoint(left, right), false );
557 BOOST_CHECK_EQUAL( intersects(left, right), true );
558
559 (all += left) += right;
560 (section += left) &= right;
561 all -= section;
562 complement += all;
563 //complement.erase(I3_5I);
564 icl::erase(complement, section);
565 BOOST_CHECK_EQUAL( disjoint(section, complement), true );
566 BOOST_CHECK_EQUAL( intersects(section, complement), false );
567}
568
569
570// Test for nontrivial intersection of interval maps with intervals and values
571template
572<
573#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
574 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
575#else
576 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
577#endif
578 class T, class U
579>
580void interval_map_base_intersect_4_bicremental_types()
581{
582 typedef IntervalMap<T,U> IntervalMapT;
583 typedef typename IntervalMapT::interval_type IntervalT;
584
585 T v0 = make<T>(0);
586 T v1 = make<T>(1);
587 T v2 = make<T>(2);
588 T v3 = make<T>(3);
589 T v4 = make<T>(4);
590 T v5 = make<T>(5);
591 T v6 = make<T>(6);
592 T v7 = make<T>(7);
593 T v8 = make<T>(8);
594 T v9 = make<T>(9);
595
596 U u1 = make<U>(1);
597
598 IntervalT I0_3D = icl::interval<T>::right_open(v0,v3);
599 IntervalT I1_3D = icl::interval<T>::right_open(v1,v3);
600 IntervalT I1_4D = icl::interval<T>::right_open(v1,v4);
601 IntervalT I1_8D = icl::interval<T>::right_open(v1,v8);
602 IntervalT I2_7D = icl::interval<T>::right_open(v2,v7);
603 IntervalT I2_3D = icl::interval<T>::right_open(v2,v3);
604 IntervalT I5_8D = icl::interval<T>::right_open(v5,v8);
605 IntervalT I6_7D = icl::interval<T>::right_open(v6,v7);
606 IntervalT I6_8D = icl::interval<T>::right_open(v6,v8);
607 IntervalT I6_9D = icl::interval<T>::right_open(v6,v9);
608
609 typename IntervalMapT::value_type I0_3D_1(I0_3D, u1);
610 typename IntervalMapT::value_type I6_9D_1(I6_9D, u1);
611 typename IntervalMapT::value_type I1_3D_1(I1_3D, u1);
612 typename IntervalMapT::value_type I6_8D_1(I6_8D, u1);
613 typename IntervalMapT::value_type I2_3D_1(I2_3D, u1);
614 typename IntervalMapT::value_type I6_7D_1(I6_7D, u1);
615
616 //--------------------------------------------------------------------------
617 //map_A [0 3) [6 9)
618 // 1 1
619 // &= [1 8)
620 //map_AB -> [1 3) [6 8)
621 // 1 1
622 // &= [2 7)
623 // -> [2 3) [6 7)
624 // 1 1
625 IntervalMap<T,U> map_A, map_AB, map_ab, map_ab2;
626 interval_set<T> set_B;
627 map_A.add(I0_3D_1).add(I6_9D_1);
628 map_AB = map_A;
629 map_AB &= I1_8D;
630 map_ab.add(I1_3D_1).add(I6_8D_1);
631
632 BOOST_CHECK_EQUAL( map_AB, map_ab );
633
634 map_AB = map_A;
635 (map_AB &= I1_8D) &= I2_7D;
636 map_ab2.add(I2_3D_1).add(I6_7D_1);
637
638 BOOST_CHECK_EQUAL( map_AB, map_ab2 );
639
640 //--------------------------------------------------------------------------
641 //map_A [0 3) [6 9)
642 // 1 1
643 // &= [1 4) [5 8)
644 //map_AB -> [1 3) [6 8)
645 // 1 1
646 // &= [2 4) [5 7)
647 // -> [2 3) [6 7)
648 // 1 1
649 map_A.clear();
650 map_A.add(I0_3D_1).add(I6_9D_1);
651 set_B.add(I1_4D).add(I5_8D);
652 map_AB = map_A;
653
654 map_AB &= set_B;
655 map_ab.clear();
656 map_ab.add(I1_3D_1).add(I6_8D_1);
657 BOOST_CHECK_EQUAL( map_AB, map_ab );
658
659 //--------------------------------------------------------------------------
660 //map_A [0 3) [6 9)
661 // 1 1
662 // &= 1
663 //map_AB -> [1]
664 // 1
665
666 map_A.clear();
667 map_A.add(I0_3D_1).add(I6_9D_1);
668 map_AB = map_A;
669 map_AB &= v1;
670 map_ab.clear();
671 map_ab.add(mapping_pair<T,U>(v1,u1));
672
673 BOOST_CHECK_EQUAL( map_AB, map_ab );
674}
675
676
677// Test for nontrivial erasure of interval maps with intervals and interval sets
678template
679<
680#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
681 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
682#else
683 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
684#endif
685 class T, class U
686>
687void interval_map_base_erase_4_bicremental_types()
688{
689 typedef IntervalMap<T,U> IntervalMapT;
690 typedef typename IntervalMapT::interval_type IntervalT;
691
692 T v0 = make<T>(0);
693 T v1 = make<T>(1);
694 T v2 = make<T>(2);
695 T v3 = make<T>(3);
696 T v4 = make<T>(4);
697 T v5 = make<T>(5);
698 T v6 = make<T>(6);
699 T v7 = make<T>(7);
700 T v8 = make<T>(8);
701 T v9 = make<T>(9);
702
703 U u1 = make<U>(1);
704
705 IntervalT I0_1D = icl::interval<T>::right_open(v0,v1);
706 IntervalT I0_2D = icl::interval<T>::right_open(v0,v2);
707 IntervalT I0_3D = icl::interval<T>::right_open(v0,v3);
708 IntervalT I1_3D = icl::interval<T>::right_open(v1,v3);
709 //IntervalT I1_4D = icl::interval<T>::right_open(v1,v4);
710 IntervalT I1_8D = icl::interval<T>::right_open(v1,v8);
711 IntervalT I2_4D = icl::interval<T>::right_open(v2,v4);
712 IntervalT I2_7D = icl::interval<T>::right_open(v2,v7);
713 IntervalT I2_3D = icl::interval<T>::right_open(v2,v3);
714 IntervalT I5_7D = icl::interval<T>::right_open(v5,v7);
715 //IntervalT I5_8D = icl::interval<T>::right_open(v5,v8);
716 IntervalT I6_7D = icl::interval<T>::right_open(v6,v7);
717 IntervalT I6_8D = icl::interval<T>::right_open(v6,v8);
718 IntervalT I6_9D = icl::interval<T>::right_open(v6,v9);
719 IntervalT I7_9D = icl::interval<T>::right_open(v7,v9);
720 IntervalT I8_9D = icl::interval<T>::right_open(v8,v9);
721
722 typename IntervalMapT::value_type I0_1D_1(I0_1D, u1);
723 typename IntervalMapT::value_type I0_3D_1(I0_3D, u1);
724 typename IntervalMapT::value_type I0_2D_1(I0_2D, u1);
725 typename IntervalMapT::value_type I6_9D_1(I6_9D, u1);
726 typename IntervalMapT::value_type I1_3D_1(I1_3D, u1);
727 typename IntervalMapT::value_type I6_8D_1(I6_8D, u1);
728 typename IntervalMapT::value_type I2_3D_1(I2_3D, u1);
729 typename IntervalMapT::value_type I6_7D_1(I6_7D, u1);
730 typename IntervalMapT::value_type I7_9D_1(I7_9D, u1);
731 typename IntervalMapT::value_type I8_9D_1(I8_9D, u1);
732
733 //--------------------------------------------------------------------------
734 //map_A [0 3) [6 9)
735 // 1 1
736 // erase [2 7)
737 //map_A2 -> [0 2) [7 9)
738 // 1 1
739 // erase [1 8)
740 // -> [0 1) [8 9)
741 // 1 1
742 IntervalMap<T,U> map_A, map_A2, map_A3, map_check2, map_check3;
743 interval_set<T> set_B;
744 map_A.add(I0_3D_1).add(I6_9D_1);
745 map_A2 = map_A;
746 map_A2.erase(I2_7D);
747 map_check2.add(I0_2D_1).add(I7_9D_1);
748 BOOST_CHECK_EQUAL( map_A2, map_check2 );
749
750 map_A3 = map_A2;
751 map_A3.erase(I1_8D);
752 map_check3.add(I0_1D_1).add(I8_9D_1);
753 BOOST_CHECK_EQUAL( map_A3, map_check3 );
754
755
756 //--------------------------------------------------------------------------
757 //map_A [0 3) [6 9)
758 // 1 1
759 // erase [2 7)
760 // -> [0 2) [7 9)
761 // 1 1
762 // erase [1 8)
763 // -> [0 1) [8 9)
764 // 1 1
765 map_A3 = map_A;
766 map_A3.erase(I2_7D).erase(I1_8D);
767 BOOST_CHECK_EQUAL( map_A3, map_check3 );
768
769 //--------------------------------------------------------------------------
770 //map_A [0 3) [6 9)
771 // 1 1
772 // -= [2 7)
773 // -> [0 2) [7 9)
774 // 1 1
775 // -= [1 8)
776 // -> [0 1) [8 9)
777 // 1 1
778 map_A3 = map_A;
779 (map_A3 -= I2_7D) -= I1_8D;
780 BOOST_CHECK_EQUAL( map_A3, map_check3 );
781
782 //--------------------------------------------------------------------------
783 //map_A [0 3) [6 9)
784 // 1 1
785 // erase [2 4) [5 7)
786 // -> [0 2) [7 9)
787 // 1 1
788 map_A3 = map_A;
789 set_B.add(I2_4D).add(I5_7D);
790 map_A3 -= set_B;
791 BOOST_CHECK_EQUAL( map_A3, map_check2 );
792}
793
794
795// Test first_collision
796template
797<
798#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
799 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
800#else
801 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
802#endif
803 class T, class U
804>
805void interval_map_base_is_disjoint_4_bicremental_types()
806{
807 typedef IntervalMap<T,U> IntervalMapT;
808 typedef typename IntervalMapT::interval_type IntervalT;
809 typedef typename IntervalMap<T,U>::interval_set_type IntervalSetT;
810
811 T v0 = make<T>(0);
812 T v1 = make<T>(1);
813 T v3 = make<T>(3);
814 T v5 = make<T>(5);
815 T v6 = make<T>(6);
816 T v7 = make<T>(7);
817 T v8 = make<T>(8);
818 T v9 = make<T>(9);
819
820 U u1 = make<U>(1);
821
822 IntervalT I0_1D = icl::interval<T>::right_open(v0,v1);
823 IntervalT I1_3D = icl::interval<T>::right_open(v1,v3);
824 IntervalT I3_6D = icl::interval<T>::right_open(v3,v6);
825 IntervalT I5_7D = icl::interval<T>::right_open(v5,v7);
826 IntervalT I6_8D = icl::interval<T>::right_open(v6,v8);
827 IntervalT I8_9D = icl::interval<T>::right_open(v8,v9);
828
829 typename IntervalMapT::value_type I0_1D_1(I0_1D, u1);
830 typename IntervalMapT::value_type I1_3D_1(I1_3D, u1);
831 typename IntervalMapT::value_type I3_6D_1(I3_6D, u1);
832 typename IntervalMapT::value_type I5_7D_1(I5_7D, u1);
833 typename IntervalMapT::value_type I6_8D_1(I6_8D, u1);
834 typename IntervalMapT::value_type I8_9D_1(I8_9D, u1);
835
836 //--------------------------------------------------------------------------
837 //map_A [1 3) [6 8)
838 // 1 1
839 //map_B [0 1) [3 6) [8 9)
840 // 1 1 1
841 IntervalMapT map_A, map_B;
842 IntervalSetT set_A, set_B;
843
844 map_A.add(I1_3D_1).add(I6_8D_1);
845 map_B.add(I0_1D_1).add(I3_6D_1).add(I8_9D_1);
846 BOOST_CHECK_EQUAL( disjoint(map_A, map_B), true );
847 BOOST_CHECK_EQUAL( disjoint(map_B, map_A), true );
848 BOOST_CHECK_EQUAL( intersects(map_A, map_B), false );
849 BOOST_CHECK_EQUAL( intersects(map_B, map_A), false );
850
851 icl::domain(set_A, map_A);
852 icl::domain(set_B, map_B);
853 BOOST_CHECK_EQUAL( disjoint(map_A, set_B), true );
854 BOOST_CHECK_EQUAL( disjoint(set_B, map_A), true );
855 BOOST_CHECK_EQUAL( disjoint(set_A, map_B), true );
856 BOOST_CHECK_EQUAL( disjoint(map_B, set_A), true );
857 BOOST_CHECK_EQUAL( intersects(map_A, set_B), false );
858 BOOST_CHECK_EQUAL( intersects(set_B, map_A), false );
859 BOOST_CHECK_EQUAL( intersects(set_A, map_B), false );
860 BOOST_CHECK_EQUAL( intersects(map_B, set_A), false );
861
862 map_A += I5_7D_1;
863
864 BOOST_CHECK_EQUAL( disjoint(map_A, map_B), false );
865 BOOST_CHECK_EQUAL( disjoint(map_B, map_A), false );
866 BOOST_CHECK_EQUAL( intersects(map_A, map_B), true );
867 BOOST_CHECK_EQUAL( intersects(map_B, map_A), true );
868
869 icl::domain(set_A, map_A);
870 icl::domain(set_B, map_B);
871 BOOST_CHECK_EQUAL( disjoint(map_A, set_B), false );
872 BOOST_CHECK_EQUAL( disjoint(set_B, map_A), false );
873 BOOST_CHECK_EQUAL( disjoint(set_A, map_B), false );
874 BOOST_CHECK_EQUAL( disjoint(map_B, set_A), false );
875 BOOST_CHECK_EQUAL( intersects(map_A, set_B), true );
876 BOOST_CHECK_EQUAL( intersects(set_B, map_A), true );
877 BOOST_CHECK_EQUAL( intersects(set_A, map_B), true );
878 BOOST_CHECK_EQUAL( intersects(map_B, set_A), true );
879}
880
881template
882<
883#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
884 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
885#else
886 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
887#endif
888 class T, class U
889>
890void interval_map_flip_4_bicremental_types()
891{
892 typedef IntervalMap<T,U> IntervalMapT;
893 typedef IntervalMapT IMap;
894
895 IntervalMapT set_a;
896 //[0 2)
897 // 1
898 // [1 3)
899 // 1
900 //[0 1) [2 3) : {[0 2)->1} ^= ([2 3)->1)
901 // 1 1
902 //BOOST_CHECK_EQUAL(IMap(IDv(0,2,1)) ^= (IDv(1,3,1)), IMap(IDv(0,1,1)) + IDv(2,3,1));
903 set_a = IMap(IDv(0,2,1));
904 IntervalMapT set_b = set_a;
905 BOOST_CHECK_EQUAL(set_a ^= IDv(1,3,1), IMap(IDv(0,1,1)) + IDv(2,3,1));
906}
907
908template
909<
910#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
911 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
912#else
913 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
914#endif
915 class T, class U
916>
917void interval_map_infix_plus_overload_4_bicremental_types()
918{
919 typedef IntervalMap<T,U> IntervalMapT;
920 typedef typename IntervalMapT::interval_type IntervalT;
921 typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
922 std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
923 mapping_pair<T,U> map_pair = K_v(4,3);
924
925 IntervalMapT map_a, map_b;
926 map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
927 map_b.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
928
929 BOOST_CHECK_EQUAL(map_a + map_b, map_b + map_a);
930 //This checks all cases of is_interval_map_derivative<T>
931 BOOST_CHECK_EQUAL(map_a + val_pair1, val_pair1 + map_a);
932 BOOST_CHECK_EQUAL(map_b + val_pair2, val_pair2 + map_b);
933 BOOST_CHECK_EQUAL(map_b + map_pair, map_pair + map_b);
934}
935
936template
937<
938#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
939 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
940#else
941 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
942#endif
943 class T, class U
944>
945void interval_map_infix_pipe_overload_4_bicremental_types()
946{
947 typedef IntervalMap<T,U> IntervalMapT;
948 typedef typename IntervalMapT::interval_type IntervalT;
949 typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
950 std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
951 mapping_pair<T,U> map_pair = K_v(4,3);
952
953 IntervalMapT map_a, map_b;
954 map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
955 map_b.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
956
957 BOOST_CHECK_EQUAL(map_a | map_b, map_b | map_a);
958 //This checks all cases of is_interval_map_derivative<T>
959 BOOST_CHECK_EQUAL(map_a | val_pair1, val_pair1 | map_a);
960 BOOST_CHECK_EQUAL(map_b | val_pair2, val_pair2 | map_b);
961 BOOST_CHECK_EQUAL(map_b | map_pair, map_pair | map_b);
962}
963
964
965
966template
967<
968#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
969 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
970#else
971 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
972#endif
973 class T, class U
974>
975void interval_map_infix_minus_overload_4_bicremental_types()
976{
977 typedef IntervalMap<T,U> IntervalMapT;
978 typedef typename IntervalMapT::interval_type IntervalT;
979
980 typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
981 std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
982 mapping_pair<T,U> map_pair = K_v(4,3);
983
984 IntervalT itv = C_D(4,11);
985 typename IntervalMapT::interval_mapping_type itv_v = CDv(4,11,3);
986
987 IntervalMapT map_a, map_b, map_c;
988 map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
989 map_b.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
990 map_c = map_a;
991
992 interval_set<T> join_set_a;
993 separate_interval_set<T> sep_set_a;
994 split_interval_set<T> split_set_a;
995 join_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,9));
996 sep_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,11));
997 split_set_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
998
999 //Happy day overloading
1000 BOOST_CHECK_EQUAL(map_a - map_b, (map_c = map_a) -= map_b);
1001 BOOST_CHECK_EQUAL(map_a - map_b, map_c);
1002
1003 //This checks all cases of is_interval_map_derivative<T>
1004 BOOST_CHECK_EQUAL((map_a - val_pair1) + val_pair1, (map_a + val_pair1) - val_pair1);
1005 BOOST_CHECK_EQUAL((map_b - val_pair2) + val_pair2, (map_b + val_pair2) - val_pair2);
1006 BOOST_CHECK_EQUAL((map_b - map_pair) + map_pair, (map_b + map_pair) - map_pair);
1007
1008 //This checks all cases of is_interval_set_derivative<T>
1009 BOOST_CHECK_EQUAL(map_a - itv, (map_a + itv_v) - itv);
1010 BOOST_CHECK_EQUAL(map_b - MK_v(8), (IIv(8,8,3) + map_b) - MK_v(8));
1011
1012 //This checks all cases of is_interval_set_companion<T>
1013 BOOST_CHECK_EQUAL(map_a - split_set_a, ((split_set_a & map_a) + map_a) - split_set_a);
1014 BOOST_CHECK_EQUAL(map_a - sep_set_a, ((sep_set_a & map_a) + map_a) - sep_set_a);
1015 BOOST_CHECK_EQUAL(map_a - join_set_a, ((join_set_a & map_a) + map_a) - join_set_a);
1016}
1017
1018
1019template
1020<
1021#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
1022 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
1023#else
1024 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
1025#endif
1026 class T, class U
1027>
1028void interval_map_infix_et_overload_4_bicremental_types()
1029{
1030 typedef IntervalMap<T,U> IntervalMapT;
1031 typedef typename IntervalMapT::interval_type IntervalT;
1032
1033 typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
1034 std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
1035 mapping_pair<T,U> map_pair = K_v(4,3);
1036
1037 IntervalT itv = C_D(4,11);
1038
1039 IntervalMapT map_a, map_b;
1040 map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
1041 map_b.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
1042
1043 interval_set<T> join_set_a;
1044 separate_interval_set<T> sep_set_a;
1045 split_interval_set<T> split_set_a;
1046 join_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,9));
1047 sep_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,11));
1048 split_set_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
1049
1050 //Happy day overloading
1051 BOOST_CHECK_EQUAL(map_a & map_b, map_b & map_a);
1052
1053 //This checks all cases of is_interval_map_derivative<T>
1054 BOOST_CHECK_EQUAL(map_a & val_pair1, val_pair1 & map_a);
1055 BOOST_CHECK_EQUAL(map_b & val_pair2, val_pair2 & map_b);
1056 BOOST_CHECK_EQUAL(map_b & map_pair, map_pair & map_b);
1057
1058 //This checks all cases of is_interval_set_derivative<T>
1059 BOOST_CHECK_EQUAL(map_a & itv, itv & map_a);
1060 BOOST_CHECK_EQUAL(map_b & MK_v(8), MK_v(8) & map_b);
1061
1062 //This checks all cases of is_interval_set_companion<T>
1063 BOOST_CHECK_EQUAL(map_a & split_set_a, split_set_a & map_a);
1064 BOOST_CHECK_EQUAL(map_a & sep_set_a, sep_set_a & map_a);
1065 BOOST_CHECK_EQUAL(map_a & join_set_a, join_set_a & map_a);
1066}
1067
1068
1069template
1070<
1071#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
1072 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
1073#else
1074 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
1075#endif
1076 class T, class U
1077>
1078void interval_map_infix_caret_overload_4_bicremental_types()
1079{
1080 typedef IntervalMap<T,U> IntervalMapT;
1081 typedef typename IntervalMapT::interval_type IntervalT;
1082
1083 typename IntervalMapT::interval_mapping_type val_pair1 = IDv(6,9,1);
1084 std::pair<const IntervalT, U> val_pair2 = IDv(3,5,3);
1085 mapping_pair<T,U> map_pair = K_v(4,3);
1086
1087 //IntervalT itv = C_D(4,11);
1088
1089 IntervalMapT map_a, map_b;
1090 map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
1091 map_b.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
1092
1093 interval_set<T> join_set_a;
1094 separate_interval_set<T> sep_set_a;
1095 split_interval_set<T> split_set_a;
1096 join_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,9));
1097 sep_set_a .add(I_D(0,4)).add(I_I(4,6)).add(I_D(5,11));
1098 split_set_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
1099
1100 //Happy day overloading
1101 BOOST_CHECK_EQUAL(map_a ^ map_b, map_b ^ map_a);
1102
1103 //This checks all cases of is_interval_map_derivative<T>
1104 BOOST_CHECK_EQUAL(map_a ^ val_pair1, val_pair1 ^ map_a);
1105 BOOST_CHECK_EQUAL(map_b ^ val_pair2, val_pair2 ^ map_b);
1106 BOOST_CHECK_EQUAL(map_b ^ map_pair, map_pair ^ map_b);
1107}
1108
1109template
1110<
1111#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
1112 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
1113#else
1114 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
1115#endif
1116 class T, class U
1117>
1118void interval_map_find_4_bicremental_types()
1119{
1120 typedef IntervalMap<T,U> IntervalMapT;
1121 typedef typename IntervalMapT::const_iterator c_iterator;
1122
1123 IntervalMapT map_a;
1124 map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
1125 // {(1 3) [6 8)[8 9)[9 11)
1126 // 1 3 4 3
1127 // 5? 6?
1128 c_iterator found1 = map_a.find(MK_v(6));
1129 c_iterator found2 = icl::find(map_a, MK_v(6));
1130
1131 BOOST_CHECK ( found1 == found2 );
1132 BOOST_CHECK_EQUAL( found1->second, found2->second );
1133 BOOST_CHECK_EQUAL( found1->second, MK_u(3) );
1134 BOOST_CHECK_EQUAL( map_a(MK_v(6)), MK_u(3) );
1135
1136 found1 = map_a.find(MK_v(5));
1137
1138 BOOST_CHECK_EQUAL( found1 == map_a.end(), true );
1139 BOOST_CHECK_EQUAL( map_a(MK_v(5)), MK_u(0) );
1140 BOOST_CHECK_EQUAL( map_a(MK_v(8)), MK_u(4) );
1141
1142 /*JODO fix err for boost::chrono instantiation
1143 T k_2 = MK_v( 2);
1144 T k_11 = MK_v(11);
1145 //LAW map c; key k: k in dom(c) => contains(c, (k, find(c, k)->second))
1146 BOOST_CHECK( icl::contains(map_a, K_v(k_2, icl::find(map_a, k_2)->second)) );
1147 BOOST_CHECK( icl::contains(map_a, K_v(k_11, map_a.find(k_11)->second)) );
1148 */
1149 BOOST_CHECK( icl::contains(map_a, MK_v(2)) );
1150 BOOST_CHECK( icl::contains(map_a, MK_v(10)) );
1151 BOOST_CHECK( !icl::contains(map_a, MK_v(1)) );
1152 BOOST_CHECK( !icl::contains(map_a, MK_v(3)) );
1153 BOOST_CHECK( !icl::contains(map_a, MK_v(12)) );
1154
1155 BOOST_CHECK( icl::intersects(map_a, MK_v(2)) );
1156 BOOST_CHECK( icl::intersects(map_a, MK_v(10)) );
1157 BOOST_CHECK( !icl::intersects(map_a, MK_v(1)) );
1158 BOOST_CHECK( !icl::intersects(map_a, MK_v(3)) );
1159 BOOST_CHECK( !icl::intersects(map_a, MK_v(12)) );
1160}
1161
1162
1163template
1164<
1165#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
1166 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
1167#else
1168 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
1169#endif
1170 class T, class U
1171>
1172void interval_map_find_4_numeric_continuous_types()
1173{
1174#ifndef BOOST_ICL_TEST_CHRONO
1175 typedef IntervalMap<T,U> IntervalMapT;
1176 typedef typename IntervalMapT::interval_type IntervalT;
1177 typedef typename IntervalMapT::const_iterator c_iterator;
1178
1179 T q_1_2 = MK_v(1) / MK_v(2);//JODO Doesn't work with chrono
1180 T q_3_2 = MK_v(3) / MK_v(2);
1181 T q_1_3 = MK_v(1) / MK_v(3);
1182 T q_2_3 = MK_v(2) / MK_v(3);
1183 T q_4_3 = MK_v(4) / MK_v(3);
1184 T q_5_3 = MK_v(5) / MK_v(3);
1185
1186 IntervalMapT map_a;
1187 map_a.add(MK_seg(IntervalT(q_1_3, q_2_3), 1)).add(MK_seg(IntervalT(q_4_3, q_5_3), 2));
1188 // {[1/3 2/3) [4/3 5/3)}
1189 // 1 2
1190
1191 c_iterator found1 = map_a.find(q_1_2);
1192 c_iterator found2 = icl::find(map_a, q_1_2);
1193 BOOST_CHECK ( found1 == found2 );
1194 BOOST_CHECK_EQUAL( found1->second, found2->second );
1195 BOOST_CHECK_EQUAL( found1->second, MK_u(1) );
1196
1197 found1 = map_a.find(q_3_2);
1198 found2 = icl::find(map_a, q_3_2);
1199 BOOST_CHECK ( found1 == found2 );
1200 BOOST_CHECK_EQUAL( found1->second, found2->second );
1201 BOOST_CHECK_EQUAL( found1->second, MK_u(2) );
1202
1203 if( mpl::or_<mpl::not_<is_static_left_open<IntervalT> >, boost::is_signed<T> >::value )
1204 {
1205 found1 = map_a.find(MK_v(0));
1206 found2 = icl::find(map_a, MK_v(0));
1207 BOOST_CHECK ( found1 == found2 );
1208 BOOST_CHECK ( found1 == map_a.end() );
1209 }
1210
1211 found1 = map_a.find(MK_v(1));
1212 found2 = icl::find(map_a, MK_v(1));
1213 BOOST_CHECK ( found1 == found2 );
1214 BOOST_CHECK ( found1 == map_a.end() );
1215
1216 if( mpl::or_<mpl::not_<is_static_left_open<IntervalT> >, boost::is_signed<T> >::value )
1217 {
1218 BOOST_CHECK( !icl::contains(map_a, MK_v(0)) );
1219 }
1220 BOOST_CHECK( icl::contains(map_a, q_1_2) );
1221 BOOST_CHECK( !icl::contains(map_a, MK_v(1)) );
1222 BOOST_CHECK( icl::contains(map_a, q_3_2) );
1223 BOOST_CHECK( !icl::contains(map_a, MK_v(2)) );
1224#endif
1225}
1226
1227
1228template
1229<
1230#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
1231 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
1232#else
1233 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
1234#endif
1235 class T, class U
1236>
1237void interval_map_range_4_bicremental_types()
1238{
1239 typedef IntervalMap<T,U> IntervalMapT;
1240 typedef typename IntervalMapT::interval_type IntervalT;
1241 typedef typename IntervalMapT::const_iterator c_iterator;
1242
1243 IntervalMapT map_a;
1244 map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
1245 // {(1 3) [6 8)[8 9)[9 11)
1246 // 1 3 4 3
1247 // [2 7) := itv
1248
1249 IntervalT itv = I_D(2, 7);
1250 c_iterator lwb1 = icl::find(map_a, itv);
1251 c_iterator lwb2 = map_a.lower_bound(itv);
1252
1253 BOOST_CHECK ( lwb1 == lwb2 );
1254 BOOST_CHECK_EQUAL( lwb1->second, lwb2->second );
1255 BOOST_CHECK_EQUAL( lwb1->second, MK_u(1) );
1256
1257 c_iterator upb1 = map_a.upper_bound(itv);
1258 BOOST_CHECK_EQUAL( upb1->second, MK_u(4) );
1259
1260 std::pair<c_iterator,c_iterator> exterior = map_a.equal_range(itv);
1261 BOOST_CHECK ( lwb1 == exterior.first );
1262 BOOST_CHECK ( upb1 == exterior.second );
1263}
1264
1265
1266template
1267<
1268#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
1269 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
1270#else
1271 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
1272#endif
1273 class T, class U
1274>
1275void interval_map_set_4_bicremental_types()
1276{
1277 typedef IntervalMap<T,U> IntervalMapT;
1278
1279 IntervalMapT map_a;
1280 map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
1281
1282 BOOST_CHECK_EQUAL( icl::contains(map_a.set(CDv(2,10,4)), CDv(2,10,4)), true );
1283 BOOST_CHECK_EQUAL( icl::contains(map_a.set(K_v(4,5)), K_v(4,5)), true );
1284 BOOST_CHECK_EQUAL( icl::contains(map_a.set(K_v(4,5)).set(CDv(3,5,6)), CDv(3,5,6)), true );
1285}
1286
1287
1288template
1289<
1290 class T, class U, class Trt,
1291#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
1292 ICL_IntervalMap_TEMPLATE(T,U,Traits,Trt) IntervalMap
1293#else
1294 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap
1295#endif
1296>
1297void interval_map_inclusion_compare_4_bicremental_types()
1298{
1299 typedef IntervalMap<T,U,Trt> IntervalMapT;
1300 typedef typename IntervalMap<T,U,Trt>::set_type IntervalSetT;
1301
1302 IntervalMapT itv_map_sub_a, itv_map_a, itv_map_a2, itv_map_super_a,
1303 itv_map_b, itv_map_c;
1304 itv_map_sub_a.add(IDv(2,4,1)).add(IIv(6,7,3));
1305 itv_map_a = itv_map_sub_a;
1306 itv_map_a.add(IIv(9,9,1));
1307 itv_map_a2 = itv_map_a;
1308 itv_map_c = itv_map_sub_a;
1309 itv_map_c.erase(MK_v(7)).add(IIv(11,11,2));
1310 itv_map_b = itv_map_a;
1311 itv_map_b.set(IIv(6,7,2));
1312
1313
1314 BOOST_CHECK_EQUAL( inclusion_compare(IntervalMapT(), IntervalMapT()), inclusion::equal );
1315 BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, itv_map_a), inclusion::equal );
1316 BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, itv_map_a2), inclusion::equal );
1317
1318 BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, IntervalMapT()), inclusion::superset );
1319 BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, itv_map_sub_a), inclusion::superset );
1320 BOOST_CHECK_EQUAL( inclusion_compare(IntervalMapT(), itv_map_a), inclusion::subset );
1321 BOOST_CHECK_EQUAL( inclusion_compare(itv_map_sub_a, itv_map_a), inclusion::subset );
1322
1323 BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, itv_map_b), inclusion::unrelated );
1324 BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, itv_map_c), inclusion::unrelated );
1325
1326 IntervalSetT set_sub_a, set_a, set_a2, set_b, set_c;
1327 icl::domain(set_a, itv_map_a);
1328 icl::domain(set_a2, itv_map_a2);
1329 icl::domain(set_sub_a, itv_map_sub_a);
1330
1331 BOOST_CHECK_EQUAL( inclusion_compare(IntervalMapT(), IntervalSetT()), inclusion::equal );
1332 BOOST_CHECK_EQUAL( inclusion_compare(IntervalSetT(), IntervalMapT()), inclusion::equal );
1333 BOOST_CHECK_EQUAL( inclusion_compare(IntervalSetT(), IntervalSetT()), inclusion::equal );
1334
1335 BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, set_a), inclusion::equal );
1336 BOOST_CHECK_EQUAL( inclusion_compare(set_a, itv_map_a), inclusion::equal );
1337 BOOST_CHECK_EQUAL( inclusion_compare(set_a, set_a2), inclusion::equal );
1338
1339 BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, IntervalSetT()), inclusion::superset );
1340 BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, set_sub_a), inclusion::superset );
1341
1342 BOOST_CHECK_EQUAL( inclusion_compare(IntervalSetT(), itv_map_a), inclusion::subset );
1343 BOOST_CHECK_EQUAL( inclusion_compare(set_sub_a, itv_map_a), inclusion::subset );
1344
1345 BOOST_CHECK_EQUAL( inclusion_compare(set_a, IntervalSetT()), inclusion::superset );
1346 BOOST_CHECK_EQUAL( inclusion_compare(set_a, set_sub_a), inclusion::superset );
1347
1348 BOOST_CHECK_EQUAL( inclusion_compare(IntervalSetT(), set_a), inclusion::subset );
1349 BOOST_CHECK_EQUAL( inclusion_compare(set_sub_a, set_a), inclusion::subset );
1350
1351 BOOST_CHECK_EQUAL( inclusion_compare(set_a, itv_map_c), inclusion::unrelated );
1352 BOOST_CHECK_EQUAL( inclusion_compare(itv_map_c, set_a), inclusion::unrelated );
1353
1354}
1355
1356template
1357<
1358 class T, class U, class Trt,
1359#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
1360 ICL_IntervalMap_TEMPLATE(T,U,Traits,Trt) IntervalMap
1361#else
1362 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap
1363#endif
1364>
1365void interval_map_std_copy_via_inserter_4_bicremental_types()
1366{
1367 typedef IntervalMap<T,U,Trt> IntervalMapT; //Nedded for the test value generator
1368 typedef typename IntervalMapT::interval_type IntervalT;
1369
1370 // Check equality of copying using handcoded loop or std::copy via inserter.
1371 typedef std::pair<IntervalT, U> SegmentT;
1372 std::vector<SegmentT> seg_vec_a;
1373 IntervalMapT std_copied_map;
1374
1375 // For an empty sequence
1376 test_interval_map_copy_via_inserter(seg_vec_a, std_copied_map);
1377
1378 // For an singleton sequence
1379 seg_vec_a.push_back(IDv(0,1,1));
1380 test_interval_map_copy_via_inserter(seg_vec_a, std_copied_map);
1381
1382 // Two separate segments
1383 seg_vec_a.push_back(IDv(3,5,1));
1384 test_interval_map_copy_via_inserter(seg_vec_a, std_copied_map);
1385
1386 // Touching case
1387 seg_vec_a.push_back(IDv(5,7,1));
1388 test_interval_map_copy_via_inserter(seg_vec_a, std_copied_map);
1389
1390 // Overlapping case
1391 seg_vec_a.push_back(IDv(6,9,1));
1392 test_interval_map_copy_via_inserter(seg_vec_a, std_copied_map);
1393
1394}
1395
1396
1397template
1398<
1399 class T, class U, class Trt,
1400#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
1401 ICL_IntervalMap_TEMPLATE(T,U,Traits,Trt) IntervalMap
1402#else
1403 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap
1404#endif
1405>
1406void interval_map_element_iter_4_discrete_types()
1407{
1408 typedef IntervalMap<T,U,Trt> IntervalMapT;
1409 typedef std::vector<std::pair<T,U> > VectorT;
1410
1411 IntervalMapT map_a;
1412 map_a.insert(IIv(1,3,1)).insert(IIv(6,7,2));
1413
1414 typename IntervalMapT::atomized_type ato_map_a;
1415 //ReptatorT el_it = elements_begin(map_a);
1416
1417 VectorT vec(5), cev(5);
1418 vec[0]=sK_v(1,1);vec[1]=sK_v(2,1);vec[2]=sK_v(3,1);vec[3]=sK_v(6,2);vec[4]=sK_v(7,2);
1419 cev[0]=sK_v(7,2);cev[1]=sK_v(6,2);cev[2]=sK_v(3,1);cev[3]=sK_v(2,1);cev[4]=sK_v(1,1);
1420
1421 VectorT dest;
1422 std::copy(elements_begin(map_a), elements_end(map_a), std::back_inserter(dest));
1423 BOOST_CHECK_EQUAL( vec == dest, true );
1424
1425 dest.clear();
1426 std::copy(elements_rbegin(map_a), elements_rend(map_a), std::back_inserter(dest));
1427 BOOST_CHECK_EQUAL( cev == dest, true );
1428
1429 dest.clear();
1430 std::reverse_copy(elements_rbegin(map_a), elements_rend(map_a), std::back_inserter(dest));
1431 BOOST_CHECK_EQUAL( vec == dest, true );
1432
1433 dest.clear();
1434 std::reverse_copy(elements_begin(map_a), elements_end(map_a), std::back_inserter(dest));
1435 BOOST_CHECK_EQUAL( cev == dest, true );
1436
1437}
1438
1439
1440template
1441<
1442#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
1443 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
1444#else
1445 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
1446#endif
1447 class T, class U
1448>
1449void interval_map_intersects_4_bicremental_types()
1450{
1451 // Test of intersects and disjoint for domain_type and interval_type.
1452 typedef IntervalMap<T,U> IntervalMapT;
1453
1454 IntervalMapT map_a;
1455 map_a.add(CDv(1,3,1)).add(IDv(8,9,1)).add(IIv(6,11,3));
1456
1457 BOOST_CHECK( icl::is_interval_container<IntervalMapT>::value );
1458 BOOST_CHECK( icl::has_domain_type<IntervalMapT>::value );
1459 BOOST_CHECK( (boost::is_same<T, typename domain_type_of<IntervalMapT>::type>::value) );
1460
1461 BOOST_CHECK( icl::intersects(map_a, MK_v(2) ) );
1462 BOOST_CHECK( icl::intersects(map_a, MK_v(11)) );
1463 BOOST_CHECK( icl::disjoint(map_a, MK_v(1) ) );
1464 BOOST_CHECK( icl::disjoint(map_a, MK_v(12)) );
1465
1466 BOOST_CHECK( icl::intersects(map_a, I_D(2,3)) );
1467 BOOST_CHECK( icl::intersects(map_a, I_D(6,8)) );
1468 BOOST_CHECK( icl::disjoint(map_a, I_D(3,5)) );
1469 BOOST_CHECK( icl::disjoint(map_a, I_D(12,14)) );
1470
1471 //-------------------------------------+
1472 // (1 3) [6 8)[8 9)[9 11]
1473 // 1 3 4 3
1474 mapping_pair<T,U> map_pair_2_1 = K_v(2,1);
1475 BOOST_CHECK( icl::intersects(map_a, map_pair_2_1 ) );
1476 BOOST_CHECK( icl::intersects(map_a, K_v(6,3) ) );
1477 BOOST_CHECK( icl::intersects(map_a, IDv(6,8,3) ) );
1478 BOOST_CHECK( icl::intersects(map_a, CIv(8,11,3) ) );
1479 BOOST_CHECK( icl::intersects(map_a, IIv(6,11,3) ) );
1480 BOOST_CHECK( icl::intersects(map_a, IIv(6,11,5) ) );
1481 BOOST_CHECK(!icl::intersects(map_a, IDv(4,6,5) ) );
1482
1483 BOOST_CHECK( icl::disjoint(map_a, IDv(4,6,5) ) );
1484 BOOST_CHECK(!icl::disjoint(map_a, IDv(0,12,1) ) );
1485}
1486
1487
1488template
1489<
1490#if (defined(__GNUC__) && (__GNUC__ < 4)) //MEMO Can be simplified, if gcc-3.4 is obsolete
1491 ICL_IntervalMap_TEMPLATE(T,U,Traits,partial_absorber) IntervalMap,
1492#else
1493 ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
1494#endif
1495 class T, class U
1496>
1497void interval_map_move_4_discrete_types()
1498{
1499# ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
1500 typedef IntervalMap<T,U> IntervalMapT;
1501
1502 IntervalMapT map_A(boost::move(IntervalMapT(IDv(0,4,2))));
1503 IntervalMapT map_B(boost::move(IntervalMapT(IDv(0,2,1)).add(IDv(2,4,1)).add(IDv(0,4,1))));
1504
1505 BOOST_CHECK( icl::is_element_equal(map_A, map_B) );
1506 BOOST_CHECK_EQUAL( map_A, join(map_B) );
1507
1508 map_A = boost::move(IntervalMapT(IIv(1,4,2)));
1509 map_B = boost::move(IntervalMapT(CIv(0,2,1)).insert(IDv(3,5,1)).add(CDv(0,5,1)));
1510
1511 BOOST_CHECK( icl::is_element_equal(map_A, map_B) );
1512 BOOST_CHECK_EQUAL( map_A, join(map_B) );
1513
1514# endif // BOOST_NO_CXX11_RVALUE_REFERENCES
1515}
1516
1517
1518#endif // LIBS_ICL_TEST_TEST_INTERVAL_MAP_SHARED_HPP_JOFA_081005
1519

source code of boost/libs/icl/test/test_interval_map_shared.hpp