inline typename enable_if<is_element_set<Type>, bool>::type
intersects(const Type& object, const Type& operand)
{
if(iterative_size(object) < iterative_size(operand))
return Set::intersects(object, operand);
else
return Set::intersects(operand, object);
}
void interval_set_distinct_4_bicremental_continuous_types()
{
typedef IntervalSet<T> IntervalSetT;
typedef typename IntervalSetT::interval_type IntervalT;
typedef typename IntervalSet<T>::size_type size_T;
typedef typename IntervalSet<T>::difference_type diff_T;
T v1 = make<T>(1);
T v3 = make<T>(3);
T v5 = make<T>(5);
size_T s3 = make<size_T>(3);
diff_T d0 = make<diff_T>(0);
diff_T d2 = make<diff_T>(2);
IntervalSet<T> is_1_3_5;
is_1_3_5.add(v1).add(v3).add(v5);
BOOST_CHECK_EQUAL( cardinality(is_1_3_5), s3 );
BOOST_CHECK_EQUAL( is_1_3_5.size(), s3 );
BOOST_CHECK_EQUAL( icl::length(is_1_3_5), d0 );
BOOST_CHECK_EQUAL( interval_count(is_1_3_5), 3 );
BOOST_CHECK_EQUAL( is_1_3_5.iterative_size(), 3 );
BOOST_CHECK_EQUAL( iterative_size(is_1_3_5), 3 );
IntervalSet<T> is_123_5;
is_123_5 = is_1_3_5;
is_123_5 += IntervalT::open(v1,v3);
BOOST_CHECK_EQUAL( cardinality(is_123_5), icl::infinity<size_T>::value() );
BOOST_CHECK_EQUAL( is_123_5.size(), icl::infinity<size_T>::value() );
BOOST_CHECK_EQUAL( icl::length(is_123_5), d2 );
}
void interval_set_ctor_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
typedef typename IntervalSetT::interval_type IntervalT;
T v4 = make<T>(4);
IntervalT I4_4I(v4);
IntervalSet<T> _I4_4I;
BOOST_CHECK_EQUAL( _I4_4I.empty(), true );
IntervalSet<T> _I4_4I_1;
IntervalSet<T> _I4_4I_2;
IntervalSet<T> _I4_4I_3;
_I4_4I += v4;
_I4_4I_1 += I4_4I;
BOOST_CHECK_EQUAL( _I4_4I, _I4_4I_1 );
_I4_4I_2.add(v4);
BOOST_CHECK_EQUAL( _I4_4I, _I4_4I_2 );
_I4_4I_3.add(I4_4I);
BOOST_CHECK_EQUAL( _I4_4I, _I4_4I_3 );
_I4_4I_1.add(v4).add(I4_4I);
BOOST_CHECK_EQUAL( _I4_4I, _I4_4I_1 );
_I4_4I_1.insert(v4).insert(I4_4I);
BOOST_CHECK_EQUAL( _I4_4I, _I4_4I_1 );
(_I4_4I_1 += v4) += I4_4I;
BOOST_CHECK_EQUAL( _I4_4I, _I4_4I_1 );
BOOST_CHECK_EQUAL( cardinality(_I4_4I), unit_element<typename IntervalSet<T>::size_type>::value() );
BOOST_CHECK_EQUAL( _I4_4I.size(), unit_element<typename IntervalSet<T>::size_type>::value() );
BOOST_CHECK_EQUAL( interval_count(_I4_4I), 1 );
BOOST_CHECK_EQUAL( _I4_4I.iterative_size(), 1 );
BOOST_CHECK_EQUAL( iterative_size(_I4_4I), 1 );
BOOST_CHECK_EQUAL( hull(_I4_4I).lower(), v4 );
BOOST_CHECK_EQUAL( hull(_I4_4I).upper(), v4 );
IntervalSet<T> _I4_4I_copy(_I4_4I);
IntervalSet<T> _I4_4I_assigned;
_I4_4I_assigned = _I4_4I;
BOOST_CHECK_EQUAL( _I4_4I, _I4_4I_copy );
BOOST_CHECK_EQUAL( _I4_4I, _I4_4I_assigned );
_I4_4I_assigned.clear();
BOOST_CHECK_EQUAL( true, _I4_4I_assigned.empty() );
_I4_4I_assigned.swap(_I4_4I_copy);
BOOST_CHECK_EQUAL( true, _I4_4I_copy.empty() );
BOOST_CHECK_EQUAL( _I4_4I, _I4_4I_assigned );
}
void interval_set_isolate_4_bicremental_continuous_types()
{
typedef IntervalSet<T> IntervalSetT;
typedef typename IntervalSetT::interval_type IntervalT;
typedef typename IntervalSet<T>::size_type size_T;
typedef typename IntervalSet<T>::difference_type diff_T;
T v0 = make<T>(0);
T v2 = make<T>(2);
T v4 = make<T>(4);
IntervalT I0_4I = IntervalT::closed(v0,v4);
IntervalT C0_2D = IntervalT::open(v0,v2);
IntervalT C2_4D = IntervalT::open(v2,v4);
// {[0 4]}
// - { (0,2) (2,4) }
// = {[0] [2] [4]}
IntervalSet<T> iso_set = IntervalSet<T>(I0_4I);
IntervalSet<T> gap_set;
gap_set.add(C0_2D).add(C2_4D);
BOOST_CHECK_EQUAL( true, true );
iso_set -= gap_set;
BOOST_CHECK_EQUAL( cardinality(iso_set), static_cast<size_T>(3) );
BOOST_CHECK_EQUAL( iso_set.iterative_size(), static_cast<std::size_t>(3) );
BOOST_CHECK_EQUAL( iterative_size(iso_set), static_cast<std::size_t>(3) );
IntervalSet<T> iso_set2;
iso_set2.add(I0_4I);
iso_set2.subtract(C0_2D).subtract(C2_4D);
IntervalSet<T> iso_set3(I0_4I);
(iso_set3 -= C0_2D) -= C2_4D;
IntervalSet<T> iso_set4;
iso_set4.insert(I0_4I);
iso_set4.erase(C0_2D).erase(C2_4D);
BOOST_CHECK_EQUAL( iso_set, iso_set2 );
BOOST_CHECK_EQUAL( iso_set, iso_set3 );
BOOST_CHECK_EQUAL( iso_set, iso_set4 );
}
void interval_set_distinct_4_bicremental_types()
{
typedef IntervalSet<T> IntervalSetT;
typedef typename IntervalSetT::interval_type IntervalT;
typedef typename IntervalSet<T>::size_type size_T;
typedef typename IntervalSet<T>::difference_type diff_T;
T v1 = make<T>(1);
T v3 = make<T>(3);
T v5 = make<T>(5);
size_T s3 = make<size_T>(3);
IntervalSet<T> is_1_3_5;
is_1_3_5.add(v1).add(v3).add(v5);
BOOST_CHECK_EQUAL( cardinality(is_1_3_5), s3 );
BOOST_CHECK_EQUAL( is_1_3_5.size(), s3 );
BOOST_CHECK_EQUAL( interval_count(is_1_3_5), 3 );
BOOST_CHECK_EQUAL( iterative_size(is_1_3_5), 3 );
BOOST_CHECK_EQUAL( is_1_3_5.iterative_size(), 3 );
}
void interval_set_fundamentals_4_ordered_types()
{
typedef IntervalSet<T> IntervalSetT;
typedef typename IntervalSetT::interval_type IntervalT;
typedef typename IntervalSet<T>::size_type size_T;
typedef typename IntervalSet<T>::difference_type diff_T;
// ordered types is the largest set of instance types.
// Because we can not generate values via incrementation for e.g. string,
// we are able to test operations only for the most basic values
// identity_element (0, empty, T() ...) and unit_element.
T v0 = boost::icl::identity_element<T>::value();
T v1 = unit_element<T>::value();
IntervalT I0_0I(v0);
IntervalT I1_1I(v1);
IntervalT I0_1I(v0, v1, interval_bounds::closed());
//-------------------------------------------------------------------------
//empty set
//-------------------------------------------------------------------------
BOOST_CHECK_EQUAL(IntervalSet<T>().empty(), true);
BOOST_CHECK_EQUAL(icl::is_empty(IntervalSet<T>()), true);
BOOST_CHECK_EQUAL(cardinality(IntervalSet<T>()), boost::icl::identity_element<size_T>::value());
BOOST_CHECK_EQUAL(IntervalSet<T>().size(), boost::icl::identity_element<size_T>::value());
BOOST_CHECK_EQUAL(interval_count(IntervalSet<T>()), 0);
BOOST_CHECK_EQUAL(IntervalSet<T>().iterative_size(), 0);
BOOST_CHECK_EQUAL(iterative_size(IntervalSet<T>()), 0);
BOOST_CHECK_EQUAL(IntervalSet<T>(), IntervalSet<T>());
IntervalT mt_interval = boost::icl::identity_element<IntervalT>::value();
BOOST_CHECK_EQUAL(mt_interval, IntervalT());
IntervalSet<T> mt_set = boost::icl::identity_element<IntervalSet<T> >::value();
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
//adding emptieness to emptieness yields emptieness ;)
mt_set.add(mt_interval).add(mt_interval);
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
mt_set.insert(mt_interval).insert(mt_interval);
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
(mt_set += mt_interval) += mt_interval;
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
BOOST_CHECK_EQUAL(hull(mt_set), boost::icl::identity_element<IntervalT >::value());
//subtracting emptieness
mt_set.subtract(mt_interval).subtract(mt_interval);
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
mt_set.erase(mt_interval).erase(mt_interval);
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
(mt_set -= mt_interval) -= mt_interval;
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
//subtracting elements form emptieness
mt_set.subtract(v0).subtract(v1);
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
mt_set.erase(v0).erase(v1);
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
(mt_set -= v1) -= v0;
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
//subtracting intervals form emptieness
mt_set.subtract(I0_1I).subtract(I1_1I);
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
mt_set.erase(I0_1I).erase(I1_1I);
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
(mt_set -= I1_1I) -= I0_1I;
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
//insecting emptieness
//mt_set.insect(mt_interval).insect(mt_interval);
//BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
(mt_set &= mt_interval) &= mt_interval;
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
//insecting emptieness with elements
(mt_set &= v1) &= v0;
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
//insecting emptieness with intervals
(mt_set &= I1_1I) &= I0_1I;
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
//-------------------------------------------------------------------------
//unary set
//-------------------------------------------------------------------------
IntervalSet<T> single_I0_0I_from_element(v0);
IntervalSet<T> single_I0_0I_from_interval(I0_0I);
IntervalSet<T> single_I0_0I(single_I0_0I_from_interval);
BOOST_CHECK_EQUAL(single_I0_0I_from_element, single_I0_0I_from_interval);
BOOST_CHECK_EQUAL(single_I0_0I_from_element, single_I0_0I);
BOOST_CHECK_EQUAL(icl::hull(single_I0_0I).lower(), I0_0I.lower());
BOOST_CHECK_EQUAL(icl::hull(single_I0_0I).upper(), I0_0I.upper());
IntervalSet<T> single_I1_1I_from_element(v1);
IntervalSet<T> single_I1_1I_from_interval(I1_1I);
IntervalSet<T> single_I1_1I(single_I1_1I_from_interval);
BOOST_CHECK_EQUAL(single_I1_1I_from_element, single_I1_1I_from_interval);
BOOST_CHECK_EQUAL(single_I1_1I_from_element, single_I1_1I);
IntervalSet<T> single_I0_1I_from_interval(I0_1I);
IntervalSet<T> single_I0_1I(single_I0_1I_from_interval);
BOOST_CHECK_EQUAL(single_I0_1I_from_interval, single_I0_1I);
BOOST_CHECK_EQUAL(hull(single_I0_1I), I0_1I);
BOOST_CHECK_EQUAL(hull(single_I0_1I).lower(), I0_1I.lower());
BOOST_CHECK_EQUAL(hull(single_I0_1I).upper(), I0_1I.upper());
//contains predicate
BOOST_CHECK_EQUAL(icl::contains(single_I0_0I, v0), true);
BOOST_CHECK_EQUAL(icl::contains(single_I0_0I, I0_0I), true);
BOOST_CHECK_EQUAL(icl::contains(single_I1_1I, v1), true);
BOOST_CHECK_EQUAL(icl::contains(single_I1_1I, I1_1I), true);
BOOST_CHECK_EQUAL(icl::contains(single_I0_1I, v0), true);
BOOST_CHECK_EQUAL(icl::contains(single_I0_1I, I0_1I), true);
BOOST_CHECK_EQUAL(icl::contains(single_I0_1I, v1), true);
BOOST_CHECK_EQUAL(icl::contains(single_I0_1I, I1_1I), true);
BOOST_CHECK_EQUAL(icl::contains(single_I0_1I, single_I0_0I), true);
BOOST_CHECK_EQUAL(icl::contains(single_I0_1I, single_I1_1I), true);
BOOST_CHECK_EQUAL(icl::contains(single_I0_1I, single_I0_1I), true);
BOOST_CHECK_EQUAL(cardinality(single_I0_0I), unit_element<size_T>::value());
BOOST_CHECK_EQUAL(single_I0_0I.size(), unit_element<size_T>::value());
BOOST_CHECK_EQUAL(interval_count(single_I0_0I), 1);
BOOST_CHECK_EQUAL(single_I0_0I.iterative_size(), 1);
BOOST_CHECK_EQUAL(iterative_size(single_I0_0I), 1);
}