1/*-----------------------------------------------------------------------------+
2Copyright (c) 2008-2010: 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_shared_hpp_JOFA_100306__
9#define LIBS_ICL_TEST_TEST_ICL_interval_shared_hpp_JOFA_100306__
10
11#include <boost/icl/interval_set.hpp>
12
13template <class DomainT, ICL_COMPARE Compare,
14 ICL_INTERVAL(ICL_COMPARE) Interval>
15void test_inner_complement(const ICL_INTERVAL_TYPE(Interval,DomainT,Compare)& itv1,
16 const ICL_INTERVAL_TYPE(Interval,DomainT,Compare)& itv2)
17{
18 typedef interval_set<DomainT,Compare,Interval> ItvSetT;
19 typedef ICL_INTERVAL_TYPE(Interval,DomainT,Compare) IntervalT;
20
21 BOOST_CHECK_EQUAL(icl::length(inner_complement(itv1,itv2)), icl::distance(itv1,itv2));
22 BOOST_CHECK_EQUAL(icl::length(inner_complement(itv1,itv2)), icl::distance(itv2,itv1));
23 BOOST_CHECK_EQUAL(icl::length(inner_complement(itv2,itv1)), icl::distance(itv1,itv2));
24 BOOST_CHECK_EQUAL(icl::length(inner_complement(itv2,itv1)), icl::distance(itv2,itv1));
25
26 IntervalT in_comp = inner_complement(itv1,itv2);
27 ItvSetT itvset, inner_comp;
28 itvset.add(itv1).add(itv2);
29 ItvSetT hullset = ItvSetT(hull(itvset));
30 inner_comp = hullset - itvset;
31 IntervalT inner_comp_itv;
32 if(inner_comp.begin() != inner_comp.end())
33 inner_comp_itv = *inner_comp.begin();
34
35 BOOST_CHECK_EQUAL(inner_complement(itv1,itv2), inner_comp_itv);
36 BOOST_CHECK_EQUAL(inner_complement(itv2,itv1), inner_comp_itv);
37 BOOST_CHECK_EQUAL(icl::length(inner_comp), icl::distance(itv1,itv2));
38 BOOST_CHECK_EQUAL(icl::length(inner_comp), icl::distance(itv2,itv1));
39
40 BOOST_CHECK(icl::disjoint(itv1, in_comp));
41 BOOST_CHECK(icl::disjoint(itv2, in_comp));
42
43 IntervalT itv1_comp = hull(itv1, in_comp);
44 IntervalT itv2_comp = hull(itv2, in_comp);
45
46 if(!icl::is_empty(in_comp))
47 {
48 BOOST_CHECK(icl::intersects(itv1_comp, in_comp));
49 BOOST_CHECK(icl::intersects(itv2_comp, in_comp));
50
51 BOOST_CHECK_EQUAL(itv1_comp & itv2_comp, in_comp);
52 BOOST_CHECK_EQUAL( icl::is_empty(itv1_comp & itv2_comp), icl::disjoint(itv1_comp, itv2_comp));
53 BOOST_CHECK_EQUAL(!icl::is_empty(itv1_comp & itv2_comp), icl::intersects(itv1_comp, itv2_comp));
54 }
55}
56
57template <class IntervalT>
58void test_inner_complement_(const IntervalT& itv1, const IntervalT& itv2)
59{
60 typedef typename interval_traits<IntervalT>::domain_type DomainT;
61 // For the test of plain interval types we assume that std::less is
62 // the compare functor
63 test_inner_complement<DomainT, std::less, IntervalT>(itv1, itv2);
64}
65
66#ifndef BOOST_ICL_USE_STATIC_BOUNDED_INTERVALS
67
68void interval_ctor_specific()
69{
70 BOOST_CHECK_EQUAL(icl::length(icl::interval<double>::type()), 0.0);
71 BOOST_CHECK_EQUAL(icl::cardinality(icl::interval<double>::closed(5.0, 5.0)), 1);
72 BOOST_CHECK_EQUAL(icl::cardinality(icl::interval<std::string>::closed("test", "test")), 1);
73 BOOST_CHECK_EQUAL(icl::cardinality(icl::interval<std::string>::closed("best","test")),
74 icl::cardinality(icl::interval<double>::closed(0.0,0.1)));
75 BOOST_CHECK_EQUAL(icl::cardinality(icl::interval<std::string>::right_open("best","test")),
76 icl::infinity<size_type_of<icl::interval<std::string>::type>::type >::value() );
77 BOOST_CHECK_EQUAL(icl::cardinality(icl::interval<double>::right_open(0.0, 1.0)),
78 icl::infinity<size_type_of<icl::interval<double>::type>::type >::value() );
79}
80
81#endif // ndef BOOST_ICL_USE_STATIC_BOUNDED_INTERVALS
82
83template <class T>
84void interval_equal_4_integral_types()
85{
86 typedef typename icl::interval<T>::type IntervalT;
87 T v2 = make<T>(2);
88 T v3 = make<T>(3);
89 T v7 = make<T>(7);
90 T v8 = make<T>(8);
91 BOOST_CHECK_EQUAL(IntervalT(), IntervalT(v7,v3));
92
93 //I: (I)nside = closed bound
94 //C: left open bound
95 //D: right open bound
96 IntervalT I3_7I = icl::interval<T>::closed(v3,v7);
97 IntervalT I3__8D = icl::interval<T>::right_open(v3,v8);
98 IntervalT C2__7I = icl::interval<T>::left_open(v2,v7);
99 IntervalT C2___8D = icl::interval<T>::open(v2,v8);
100
101 BOOST_CHECK_EQUAL( I3_7I , I3_7I );
102 BOOST_CHECK_EQUAL( I3_7I , I3__8D );
103 BOOST_CHECK_EQUAL( I3_7I , C2__7I );
104 BOOST_CHECK_EQUAL( I3_7I , C2___8D );
105
106 BOOST_CHECK_EQUAL( I3__8D, I3__8D );
107 BOOST_CHECK_EQUAL( I3__8D, C2__7I );
108 BOOST_CHECK_EQUAL( I3__8D, C2___8D );
109
110 BOOST_CHECK_EQUAL( C2__7I , C2__7I );
111 BOOST_CHECK_EQUAL( C2__7I , C2___8D );
112
113 BOOST_CHECK_EQUAL( C2___8D, C2___8D );
114}
115
116template <class T>
117void interval_less_4_integral_types()
118{
119 typedef typename icl::interval<T>::type IntervalT;
120 T v2 = make<T>(2);
121 T v3 = make<T>(3);
122 T v4 = make<T>(4);
123 T v7 = make<T>(7);
124 T v8 = make<T>(8);
125 BOOST_CHECK_EQUAL(IntervalT() < IntervalT(v7,v3), false);
126 BOOST_CHECK_EQUAL(icl::interval<T>::open(v2,v3) < icl::interval<T>::right_open(v7,v7), false);
127 BOOST_CHECK_EQUAL(icl::interval<T>::left_open(v3,v3) < icl::interval<T>::closed(v7,v3), false);
128
129 BOOST_CHECK_EQUAL(IntervalT() < IntervalT(v3,v4), false);
130 BOOST_CHECK_EQUAL(icl::interval<T>::open(v2,v3) < icl::interval<T>::right_open(v7,v8), false);
131 BOOST_CHECK_NE (icl::interval<T>::open(v2,v3), icl::interval<T>::right_open(v7,v8));
132
133 //I: (I)nside = closed bound
134 //C: left open bound
135 //D: right open bound
136 IntervalT I3_7I = icl::interval<T>::closed(v3,v7);
137 IntervalT I4_7I = icl::interval<T>::closed(v4,v7);
138
139 IntervalT I3__8D = icl::interval<T>::right_open(v3,v8);
140 IntervalT C2__7I = icl::interval<T>::left_open(v2,v7);
141 IntervalT C2___8D = icl::interval<T>::open(v2,v8);
142
143 BOOST_CHECK_EQUAL( I3_7I < I3_7I , false);
144 BOOST_CHECK_EQUAL( I3_7I < I3__8D , false);
145 BOOST_CHECK_EQUAL( I3_7I < C2__7I , false);
146 BOOST_CHECK_EQUAL( I3_7I < C2___8D , false);
147
148 BOOST_CHECK_EQUAL( I3_7I < I4_7I , true);
149
150
151 BOOST_CHECK_EQUAL( I3__8D< I3__8D , false);
152 BOOST_CHECK_EQUAL( I3__8D< C2__7I , false);
153 BOOST_CHECK_EQUAL( I3__8D< C2___8D , false);
154
155 BOOST_CHECK_EQUAL( C2__7I < C2__7I , false);
156 BOOST_CHECK_EQUAL( C2__7I < C2___8D , false);
157
158 BOOST_CHECK_EQUAL( C2___8D< C2___8D , false);
159}
160
161template <class T>
162void interval_equal_4_bicremental_continuous_types()
163{
164 typedef typename icl::interval<T>::type IntervalT;
165 T v3 = make<T>(3);
166 T v7 = make<T>(7);
167 BOOST_CHECK_EQUAL(IntervalT(), IntervalT(v7,v3));
168
169 //I: (I)nside = closed bound
170 //O: (O)utside = open bound
171 IntervalT I3_7I = icl::interval<T>::closed(v3,v7);
172 IntervalT I3_7D = icl::interval<T>::right_open(v3,v7);
173 IntervalT C3_7I = icl::interval<T>::left_open(v3,v7);
174 IntervalT C3_7D = icl::interval<T>::open(v3,v7);
175
176 BOOST_CHECK_EQUAL( I3_7I , I3_7I );
177 BOOST_CHECK_EQUAL( I3_7I == I3_7D, false );
178 BOOST_CHECK_EQUAL( I3_7I == C3_7D, false );
179 BOOST_CHECK_EQUAL( I3_7I == C3_7D, false );
180 BOOST_CHECK_EQUAL( I3_7I != I3_7D, true );
181 BOOST_CHECK_EQUAL( I3_7I != C3_7D, true );
182 BOOST_CHECK_EQUAL( I3_7I != C3_7D, true );
183
184 BOOST_CHECK_EQUAL( I3_7D , I3_7D );
185 BOOST_CHECK_EQUAL( I3_7D == C3_7I, false );
186 BOOST_CHECK_EQUAL( I3_7D == C3_7D, false );
187 BOOST_CHECK_EQUAL( I3_7D != C3_7I, true );
188 BOOST_CHECK_EQUAL( I3_7D != C3_7D, true );
189
190 BOOST_CHECK_EQUAL( C3_7I , C3_7I );
191 BOOST_CHECK_EQUAL( C3_7I == C3_7D, false );
192 BOOST_CHECK_EQUAL( C3_7I != C3_7D, true );
193
194 BOOST_CHECK_EQUAL( C3_7D, C3_7D );
195}
196
197template <class T>
198void interval_touches_4_bicremental_types()
199{
200 typedef typename icl::interval<T>::type IntervalT;
201 T v3 = make<T>(3);
202 T v7 = make<T>(7);
203 T v9 = make<T>(9);
204
205 IntervalT I3_7D = icl::interval<T>::right_open(v3,v7);
206 IntervalT I7_9I = icl::interval<T>::closed(v7,v9);
207 BOOST_CHECK_EQUAL( icl::touches(I3_7D, I7_9I), true );
208
209 IntervalT I3_7I = icl::interval<T>::closed(v3,v7);
210 IntervalT C7_9I = icl::interval<T>::left_open(v7,v9);
211 BOOST_CHECK_EQUAL( icl::touches(I3_7I, C7_9I), true );
212
213 BOOST_CHECK_EQUAL( icl::touches(I3_7D, C7_9I), false );
214 BOOST_CHECK_EQUAL( icl::touches(I3_7I, I7_9I), false );
215}
216
217template <class T>
218void interval_touches_4_integral_types()
219{
220 typedef typename icl::interval<T>::type IntervalT;
221 T v3 = make<T>(3);
222 T v6 = make<T>(6);
223 T v7 = make<T>(7);
224 T v9 = make<T>(9);
225
226 IntervalT I3_6I = icl::interval<T>::closed(v3,v6);
227 IntervalT I7_9I = icl::interval<T>::closed(v7,v9);
228 BOOST_CHECK_EQUAL( icl::touches(I3_6I, I7_9I), true );
229
230 IntervalT I3_7D = icl::interval<T>::right_open(v3,v7);
231 IntervalT C6_9I = icl::interval<T>::left_open(v6,v9);
232 BOOST_CHECK_EQUAL( icl::touches(I3_7D, C6_9I), true );
233}
234
235template <class T>
236void interval_infix_intersect_4_bicremental_types()
237{
238 typedef typename icl::interval<T>::type IntervalT;
239
240 IntervalT section;
241 IntervalT I3_7D = I_D(3,7);
242
243 IntervalT I0_3D = I_D(0,3);
244 section = I3_7D & I0_3D;
245 BOOST_CHECK_EQUAL( icl::disjoint(I0_3D, I3_7D), true );
246 BOOST_CHECK_EQUAL( icl::is_empty(section), true );
247 BOOST_CHECK_EQUAL( section, IntervalT() );
248
249 IntervalT I0_5D = I_D(0,5);
250 section = I3_7D & I0_5D;
251 BOOST_CHECK_EQUAL( section, I_D(3,5) );
252
253 IntervalT I0_9D = I_D(0,9);
254 section = I3_7D & I0_9D;
255 BOOST_CHECK_EQUAL( section, I3_7D );
256
257 IntervalT I4_5I = I_I(4,5);
258 section = I3_7D & I4_5I;
259 BOOST_CHECK_EQUAL( section, I4_5I );
260
261 IntervalT C4_6D = C_D(4,6);
262 section = I3_7D & C4_6D;
263 BOOST_CHECK_EQUAL( section, C4_6D );
264
265 IntervalT C4_9I = C_I(4,9);
266 section = I3_7D & C4_9I;
267 BOOST_CHECK_EQUAL( section, C_D(4,7) );
268
269 IntervalT I7_9I = I_I(7,9);
270 section = I3_7D & I7_9I;
271 BOOST_CHECK_EQUAL( icl::exclusive_less(I3_7D, I7_9I), true );
272 BOOST_CHECK_EQUAL( icl::disjoint(I3_7D, I7_9I), true );
273 BOOST_CHECK_EQUAL( icl::is_empty(section), true );
274}
275
276template <class T>
277void interval_subtract_4_bicremental_types()
278{
279 typedef typename icl::interval<T>::type IntervalT;
280
281 IntervalT diff_1, diff_2;
282 IntervalT I0_3D = I_D(0,3);
283 IntervalT I2_6D = I_D(2,6);
284 IntervalT I4_7D = I_D(4,7);
285 IntervalT I6_7D = I_D(6,7);
286 IntervalT I2_4D = I_D(2,4);
287
288 diff_1 = right_subtract(I2_6D, I4_7D);
289 BOOST_CHECK_EQUAL( diff_1, I2_4D );
290
291 diff_1 = right_subtract(I0_3D, I4_7D);
292 BOOST_CHECK_EQUAL( diff_1, I0_3D );
293
294 // ---------------------------------
295 diff_1 = left_subtract(I4_7D, I2_6D);
296 BOOST_CHECK_EQUAL( diff_1, I6_7D );
297
298 diff_1 = left_subtract(I4_7D, I0_3D);
299 BOOST_CHECK_EQUAL( diff_1, I4_7D );
300}
301
302
303#endif // LIBS_ICL_TEST_TEST_ICL_interval_shared_hpp_JOFA_100306__
304

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