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); }