/usr/include/boost/icl/concept/
/usr/include/boost/icl/concept
NameSizeModeActions
comparable.hpp16260644editdlrm
container.hpp27660644editdlrm
element_associator.hpp176370644editdlrm
element_map.hpp174950644editdlrm
element_set.hpp46910644editdlrm
element_set_value.hpp10560644editdlrm
interval.hpp531900644editdlrm
interval_associator.hpp433520644editdlrm
interval_associator_base.hpp63370644editdlrm
interval_bounds.hpp56310644editdlrm
interval_map.hpp252000644editdlrm
interval_set.hpp129230644editdlrm
interval_set_value.hpp12540644editdlrm
joinable.hpp12640644editdlrm
map_value.hpp18340644editdlrm
set_value.hpp13290644editdlrm
Edit: /usr/include/boost/icl/concept/interval.hpp (53190B)
/*-----------------------------------------------------------------------------+ Copyright (c) 2010-2010: Joachim Faulhaber +------------------------------------------------------------------------------+ Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENCE.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +-----------------------------------------------------------------------------*/ #ifndef BOOST_ICL_CONCEPT_INTERVAL_HPP_JOFA_100323 #define BOOST_ICL_CONCEPT_INTERVAL_HPP_JOFA_100323 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost{namespace icl { //============================================================================== //= Ordering //============================================================================== template inline typename enable_if, bool>::type domain_less(const typename interval_traits::domain_type& left, const typename interval_traits::domain_type& right) { return typename interval_traits::domain_compare()(left, right); } template inline typename enable_if, bool>::type domain_less_equal(const typename interval_traits::domain_type& left, const typename interval_traits::domain_type& right) { return !(typename interval_traits::domain_compare()(right, left)); } template inline typename enable_if, bool>::type domain_equal(const typename interval_traits::domain_type& left, const typename interval_traits::domain_type& right) { typedef typename interval_traits::domain_compare domain_compare; return !(domain_compare()(left, right)) && !(domain_compare()(right, left)); } template inline typename enable_if< is_interval , typename interval_traits::domain_type>::type domain_next(const typename interval_traits::domain_type value) { typedef typename interval_traits::domain_type domain_type; typedef typename interval_traits::domain_compare domain_compare; return icl::successor::apply(value); } template inline typename enable_if< is_interval , typename interval_traits::domain_type>::type domain_prior(const typename interval_traits::domain_type value) { typedef typename interval_traits::domain_type domain_type; typedef typename interval_traits::domain_compare domain_compare; return icl::predecessor::apply(value); } //============================================================================== //= Construct singleton //============================================================================== template typename enable_if < mpl::and_< is_static_right_open , is_discrete::domain_type> > , Type >::type singleton(const typename interval_traits::domain_type& value) { //ASSERT: This always creates an interval with exactly one element return interval_traits::construct(value, domain_next(value)); } template typename enable_if < mpl::and_< is_static_left_open , is_discrete::domain_type> > , Type >::type singleton(const typename interval_traits::domain_type& value) { //ASSERT: This always creates an interval with exactly one element typedef typename interval_traits::domain_type domain_type; typedef typename interval_traits::domain_compare domain_compare; BOOST_ASSERT((numeric_minimum::value> ::is_less_than(value) )); return interval_traits::construct(domain_prior(value), value); } template typename enable_if, Type>::type singleton(const typename interval_traits::domain_type& value) { //ASSERT: This always creates an interval with exactly one element typedef typename interval_traits::domain_type domain_type; typedef typename interval_traits::domain_compare domain_compare; BOOST_ASSERT((numeric_minimum::value> ::is_less_than(value))); return interval_traits::construct( domain_prior(value) , domain_next(value)); } template typename enable_if, Type>::type singleton(const typename interval_traits::domain_type& value) { //ASSERT: This always creates an interval with exactly one element return interval_traits::construct(value, value); } template typename enable_if, Type>::type singleton(const typename interval_traits::domain_type& value) { return dynamic_interval_traits::construct(value, value, interval_bounds::closed()); } namespace detail { //============================================================================== //= Construct unit_trail == generalized singleton // The smallest interval on an incrementable (and decrementable) type that can // be constructed using ++ and -- and such that it contains a given value. // If 'Type' is discrete, 'unit_trail' and 'singleton' are identical. So we // can view 'unit_trail' as a generalized singleton for static intervals of // continuous types. //============================================================================== template typename enable_if < mpl::and_< is_static_right_open , boost::detail::is_incrementable::domain_type> > , Type >::type unit_trail(const typename interval_traits::domain_type& value) { return interval_traits::construct(value, domain_next(value)); } template typename enable_if < mpl::and_< is_static_left_open , boost::detail::is_incrementable::domain_type> > , Type >::type unit_trail(const typename interval_traits::domain_type& value) { typedef typename interval_traits::domain_type domain_type; typedef typename interval_traits::domain_compare domain_compare; BOOST_ASSERT((numeric_minimum::value> ::is_less_than(value) )); return interval_traits::construct(domain_prior(value), value); } template typename enable_if < mpl::and_< is_static_open , is_discrete::domain_type> > , Type >::type unit_trail(const typename interval_traits::domain_type& value) { typedef typename interval_traits::domain_type domain_type; typedef typename interval_traits::domain_compare domain_compare; BOOST_ASSERT((numeric_minimum::value> ::is_less_than(value))); return interval_traits::construct( domain_prior(value) , domain_next(value)); } template typename enable_if < mpl::and_< is_static_closed , is_discrete::domain_type> > , Type >::type unit_trail(const typename interval_traits::domain_type& value) { return interval_traits::construct(value, value); } //NOTE: statically bounded closed or open intervals of continuous domain types // are NOT supported by ICL. They can not be used with interval containers // consistently. template typename enable_if, Type>::type unit_trail(const typename interval_traits::domain_type& value) { return dynamic_interval_traits::construct(value, value, interval_bounds::closed()); } } //namespace detail //============================================================================== //= Construct multon //============================================================================== template typename enable_if, Type>::type construct(const typename interval_traits::domain_type& low, const typename interval_traits::domain_type& up ) { return interval_traits::construct(low, up); } template typename enable_if, Type>::type construct(const typename interval_traits::domain_type& low, const typename interval_traits::domain_type& up, interval_bounds bounds = interval_bounds::right_open()) { return dynamic_interval_traits::construct(low, up, bounds); } //- construct form bounded values ---------------------------------------------- template typename enable_if, Type>::type construct(const typename Type::bounded_domain_type& low, const typename Type::bounded_domain_type& up) { return dynamic_interval_traits::construct_bounded(low, up); } template typename enable_if, Type>::type span(const typename interval_traits::domain_type& left, const typename interval_traits::domain_type& right) { typedef typename interval_traits::domain_compare domain_compare; if(domain_compare()(left,right)) return construct(left, right); else return construct(right, left); } //============================================================================== template typename enable_if, Type>::type hull(const typename interval_traits::domain_type& left, const typename interval_traits::domain_type& right) { typedef typename interval_traits::domain_compare domain_compare; if(domain_compare()(left,right)) return construct(left, domain_next(right)); else return construct(right, domain_next(left)); } template typename enable_if, Type>::type hull(const typename interval_traits::domain_type& left, const typename interval_traits::domain_type& right) { typedef typename interval_traits::domain_type domain_type; typedef typename interval_traits::domain_compare domain_compare; if(domain_compare()(left,right)) { BOOST_ASSERT((numeric_minimum::value> ::is_less_than(left) )); return construct(domain_prior(left), right); } else { BOOST_ASSERT((numeric_minimum::value> ::is_less_than(right) )); return construct(domain_prior(right), left); } } template typename enable_if, Type>::type hull(const typename interval_traits::domain_type& left, const typename interval_traits::domain_type& right) { typedef typename interval_traits::domain_compare domain_compare; if(domain_compare()(left,right)) return construct(left, right); else return construct(right, left); } template typename enable_if, Type>::type hull(const typename interval_traits::domain_type& left, const typename interval_traits::domain_type& right) { typedef typename interval_traits::domain_type domain_type; typedef typename interval_traits::domain_compare domain_compare; if(domain_compare()(left,right)) { BOOST_ASSERT((numeric_minimum::value> ::is_less_than(left) )); return construct( domain_prior(left) , domain_next(right)); } else { BOOST_ASSERT((numeric_minimum::value> ::is_less_than(right) )); return construct( domain_prior(right) , domain_next(left)); } } template typename enable_if, Type>::type hull(const typename interval_traits::domain_type& left, const typename interval_traits::domain_type& right) { typedef typename interval_traits::domain_compare domain_compare; if(domain_compare()(left,right)) return construct(left, right, interval_bounds::closed()); else return construct(right, left, interval_bounds::closed()); } //============================================================================== //= Selection //============================================================================== template inline typename enable_if, typename interval_traits::domain_type>::type lower(const Type& object) { return interval_traits::lower(object); } template inline typename enable_if, typename interval_traits::domain_type>::type upper(const Type& object) { return interval_traits::upper(object); } //- first ---------------------------------------------------------------------- template inline typename enable_if< mpl::or_, is_static_closed > , typename interval_traits::domain_type>::type first(const Type& object) { return lower(object); } template inline typename enable_if< mpl::and_< mpl::or_, is_static_open > , is_discrete::domain_type> > , typename interval_traits::domain_type>::type first(const Type& object) { return domain_next(lower(object)); } template inline typename enable_if, typename interval_traits::domain_type>::type first(const Type& object) { return is_left_closed(object.bounds()) ? lower(object) : domain_next(lower(object)); } //- last ----------------------------------------------------------------------- template inline typename enable_if< mpl::or_, is_static_closed > , typename interval_traits::domain_type>::type last(const Type& object) { return upper(object); } template inline typename enable_if< mpl::and_< mpl::or_, is_static_open > , is_discrete::domain_type> > , typename interval_traits::domain_type>::type last(const Type& object) { typedef typename interval_traits::domain_type domain_type; typedef typename interval_traits::domain_compare domain_compare; BOOST_ASSERT((numeric_minimum::value> ::is_less_than(upper(object)) )); return domain_prior(upper(object)); } template inline typename enable_if, typename interval_traits::domain_type>::type last(const Type& object) { typedef typename interval_traits::domain_type domain_type; typedef typename interval_traits::domain_compare domain_compare; BOOST_ASSERT((numeric_minimum::value> ::is_less_than_or(upper(object), is_right_closed(object.bounds())) )); return is_right_closed(object.bounds()) ? upper(object) : domain_prior(upper(object)); } //- last_next ------------------------------------------------------------------ template inline typename enable_if< mpl::and_< mpl::or_, is_static_closed > , is_discrete::domain_type> > , typename interval_traits::domain_type>::type last_next(const Type& object) { return domain_next(upper(object)); } template inline typename enable_if< mpl::and_< mpl::or_, is_static_open > , is_discrete::domain_type> > , typename interval_traits::domain_type>::type last_next(const Type& object) { //CL typedef typename interval_traits::domain_type domain_type; return upper(object); // NOTE: last_next is implemented to avoid calling pred(object) } // For unsigned integral types this may cause underflow. template inline typename enable_if, typename interval_traits::domain_type>::type last_next(const Type& object) { return is_right_closed(object.bounds()) ? domain_next(upper(object)): upper(object) ; } //------------------------------------------------------------------------------ template typename enable_if, typename Type::bounded_domain_type>::type bounded_lower(const Type& object) { return typename Type::bounded_domain_type(lower(object), object.bounds().left()); } template typename enable_if, typename Type::bounded_domain_type>::type reverse_bounded_lower(const Type& object) { return typename Type::bounded_domain_type(lower(object), object.bounds().reverse_left()); } template typename enable_if, typename Type::bounded_domain_type>::type bounded_upper(const Type& object) { return typename Type::bounded_domain_type(upper(object), object.bounds().right()); } template typename enable_if, typename Type::bounded_domain_type>::type reverse_bounded_upper(const Type& object) { return typename Type::bounded_domain_type(upper(object), object.bounds().reverse_right()); } //- bounds --------------------------------------------------------------------- template inline typename enable_if, interval_bounds>::type bounds(const Type& object) { return object.bounds(); } template inline typename enable_if, interval_bounds>::type bounds(const Type&) { return interval_bounds(interval_bound_type::value); } //============================================================================== //= Emptieness //============================================================================== /** Is the interval empty? */ template typename boost::enable_if, bool>::type is_empty(const Type& object) { return domain_less_equal(upper(object), lower(object)); } template typename boost::enable_if, bool>::type is_empty(const Type& object) { return domain_less(upper(object), lower(object)); } template typename boost::enable_if, bool>::type is_empty(const Type& object) { return domain_less_equal(upper(object), lower(object) ) || domain_less_equal(upper(object), domain_next(lower(object))); } template typename boost::enable_if, bool>::type is_empty(const Type& object) { if(object.bounds() == interval_bounds::closed()) return domain_less(upper(object), lower(object)); else if(object.bounds() == interval_bounds::open()) return domain_less_equal(upper(object), lower(object) ) || domain_less_equal(upper(object), domain_next(lower(object))); else return domain_less_equal(upper(object), lower(object)); } template typename boost::enable_if, bool>::type is_empty(const Type& object) { return domain_less(upper(object), lower(object)) || ( domain_equal(upper(object), lower(object)) && object.bounds() != interval_bounds::closed() ); } //============================================================================== //= Equivalences and Orderings //============================================================================== //- exclusive_less ------------------------------------------------------------- /** Maximal element of left is less than the minimal element of right */ template inline typename boost::enable_if, bool>::type exclusive_less(const Type& left, const Type& right) { return icl::is_empty(left) || icl::is_empty(right) || domain_less_equal(upper(left), lower(right)); } template inline typename boost::enable_if, bool>::type exclusive_less(const Type& left, const Type& right) { return icl::is_empty(left) || icl::is_empty(right) || domain_less(last(left), first(right)); } template inline typename boost:: enable_if, bool>::type exclusive_less(const Type& left, const Type& right) { return icl::is_empty(left) || icl::is_empty(right) || domain_less(last(left), first(right)); } template inline typename boost::enable_if, bool>::type exclusive_less(const Type& left, const Type& right) { return icl::is_empty(left) || icl::is_empty(right) || domain_less(upper(left), lower(right)) || ( domain_equal(upper(left), lower(right)) && inner_bounds(left,right) != interval_bounds::open() ); } //------------------------------------------------------------------------------ template typename boost::enable_if, bool>::type lower_less(const Type& left, const Type& right) { return domain_less(lower(left), lower(right)); } template typename boost::enable_if, bool>::type lower_less(const Type& left, const Type& right) { return domain_less(first(left), first(right)); } template typename boost::enable_if, bool>::type lower_less(const Type& left, const Type& right) { if(left_bounds(left,right) == interval_bounds::right_open()) //'[(' == 10 return domain_less_equal(lower(left), lower(right)); else return domain_less(lower(left), lower(right)); } //------------------------------------------------------------------------------ template typename boost::enable_if, bool>::type upper_less(const Type& left, const Type& right) { return domain_less(upper(left), upper(right)); } template typename boost::enable_if, bool>::type upper_less(const Type& left, const Type& right) { return domain_less(last(left), last(right)); } template typename boost::enable_if, bool>::type upper_less(const Type& left, const Type& right) { if(right_bounds(left,right) == interval_bounds::left_open()) return domain_less_equal(upper(left), upper(right)); else return domain_less(upper(left), upper(right)); } //------------------------------------------------------------------------------ template typename boost::enable_if, typename Type::bounded_domain_type >::type lower_min(const Type& left, const Type& right) { return lower_less(left, right) ? bounded_lower(left) : bounded_lower(right); } //------------------------------------------------------------------------------ template typename boost::enable_if, typename Type::bounded_domain_type >::type lower_max(const Type& left, const Type& right) { return lower_less(left, right) ? bounded_lower(right) : bounded_lower(left); } //------------------------------------------------------------------------------ template typename boost::enable_if, typename Type::bounded_domain_type >::type upper_max(const Type& left, const Type& right) { return upper_less(left, right) ? bounded_upper(right) : bounded_upper(left); } //------------------------------------------------------------------------------ template typename boost::enable_if, typename Type::bounded_domain_type >::type upper_min(const Type& left, const Type& right) { return upper_less(left, right) ? bounded_upper(left) : bounded_upper(right); } //------------------------------------------------------------------------------ template typename boost::enable_if, bool>::type lower_equal(const Type& left, const Type& right) { return domain_equal(lower(left), lower(right)); } template typename boost::enable_if, bool>::type lower_equal(const Type& left, const Type& right) { return domain_equal(first(left), first(right)); } template typename boost::enable_if, bool>::type lower_equal(const Type& left, const Type& right) { return domain_equal(first(left), first(right)); } template typename boost::enable_if, bool>::type lower_equal(const Type& left, const Type& right) { return (left.bounds().left()==right.bounds().left()) && domain_equal(lower(left), lower(right)); } //------------------------------------------------------------------------------ template typename boost::enable_if, bool>::type upper_equal(const Type& left, const Type& right) { return domain_equal(upper(left), upper(right)); } template typename boost::enable_if, bool>::type upper_equal(const Type& left, const Type& right) { return domain_equal(last(left), last(right)); } template typename boost::enable_if, bool>::type upper_equal(const Type& left, const Type& right) { return domain_equal(last(left), last(right)); } template typename boost::enable_if, bool>::type upper_equal(const Type& left, const Type& right) { return (left.bounds().right()==right.bounds().right()) && domain_equal(upper(left), upper(right)); } //------------------------------------------------------------------------------ template typename boost::enable_if, bool>::type lower_less_equal(const Type& left, const Type& right) { return lower_less(left,right) || lower_equal(left,right); } template typename boost::enable_if, bool>::type upper_less_equal(const Type& left, const Type& right) { return upper_less(left,right) || upper_equal(left,right); } //============================================================================== //= Orderings, containedness (non empty) //============================================================================== namespace non_empty { template inline typename boost::enable_if, bool>::type exclusive_less(const Type& left, const Type& right) { BOOST_ASSERT(!(icl::is_empty(left) || icl::is_empty(right))); return domain_less_equal(upper(left), lower(right)); } template inline typename boost::enable_if, bool>::type exclusive_less(const Type& left, const Type& right) { BOOST_ASSERT(!(icl::is_empty(left) || icl::is_empty(right))); return domain_less(last(left), first(right)); } template inline typename boost:: enable_if, bool>::type exclusive_less(const Type& left, const Type& right) { BOOST_ASSERT(!(icl::is_empty(left) || icl::is_empty(right))); return domain_less(last(left), first(right)); } template inline typename boost::enable_if, bool>::type exclusive_less(const Type& left, const Type& right) { BOOST_ASSERT(!(icl::is_empty(left) || icl::is_empty(right))); return domain_less (upper(left), lower(right)) || ( domain_equal(upper(left), lower(right)) && inner_bounds(left,right) != interval_bounds::open() ); } template inline typename boost::enable_if, bool>::type contains(const Type& super, const Type& sub) { return lower_less_equal(super,sub) && upper_less_equal(sub,super); } } //namespace non_empty //- contains ------------------------------------------------------------------- template inline typename boost::enable_if, bool>::type contains(const Type& super, const Type& sub) { return icl::is_empty(sub) || non_empty::contains(super, sub); } template typename boost::enable_if, bool>::type contains(const Type& super, const typename interval_traits::domain_type& element) { return domain_less_equal(icl::first(super), element ) && domain_less_equal( element, icl::last(super)); } template typename boost::enable_if, bool>::type contains(const Type& super, const typename interval_traits::domain_type& element) { return domain_less (icl::lower(super), element ) && domain_less_equal( element, icl::upper(super)); } template typename boost::enable_if, bool>::type contains(const Type& super, const typename interval_traits::domain_type& element) { return domain_less_equal(icl::lower(super), element ) && domain_less ( element, icl::upper(super)); } template typename boost::enable_if, bool>::type contains(const Type& super, const typename interval_traits::domain_type& element) { return (is_left_closed(super.bounds()) ? domain_less_equal(lower(super), element) : domain_less(lower(super), element)) && (is_right_closed(super.bounds()) ? domain_less_equal(element, upper(super)) : domain_less(element, upper(super))); } //- within --------------------------------------------------------------------- template inline typename boost::enable_if, bool>::type within(const Type& sub, const Type& super) { return contains(super,sub); } //- operator == ---------------------------------------------------------------- template typename boost::enable_if, bool>::type operator == (const Type& left, const Type& right) { return (icl::is_empty(left) && icl::is_empty(right)) || (lower_equal(left,right) && upper_equal(left,right)); } template typename boost::enable_if, bool>::type operator != (const Type& left, const Type& right) { return !(left == right); } //- operator < ----------------------------------------------------------------- template typename boost::enable_if, bool>::type operator < (const Type& left, const Type& right) { if(icl::is_empty(left)) return !icl::is_empty(right); else return lower_less(left,right) || (lower_equal(left,right) && upper_less(left,right)); } template inline typename boost::enable_if, bool>::type operator > (const Type& left, const Type& right) { return right < left; } //------------------------------------------------------------------------------ template typename boost::enable_if, bool>::type touches(const Type& left, const Type& right) { return domain_equal(upper(left), lower(right)); } template typename boost::enable_if, bool>::type touches(const Type& left, const Type& right) { return domain_equal(last_next(left), first(right)); } template typename boost::enable_if, bool>::type touches(const Type& left, const Type& right) { return domain_equal(domain_next(last(left)), first(right)); } template typename boost::enable_if, bool>::type touches(const Type& left, const Type& right) { return is_complementary(inner_bounds(left,right)) && domain_equal(upper(left), lower(right)); } //============================================================================== //= Size //============================================================================== //- cardinality ---------------------------------------------------------------- template typename boost::enable_if, typename size_type_of >::type>::type cardinality(const Type& object) { typedef typename size_type_of >::type SizeT; if(icl::is_empty(object)) return icl::identity_element::value(); else if( object.bounds() == interval_bounds::closed() && domain_equal(lower(object), upper(object))) return icl::unit_element::value(); else return icl::infinity::value(); } template typename boost::enable_if, typename size_type_of >::type>::type cardinality(const Type& object) { typedef typename size_type_of >::type SizeT; return icl::is_empty(object) ? identity_element::value() : static_cast(last_next(object) - first(object)); } template typename boost::enable_if, typename size_type_of >::type>::type cardinality(const Type& object) { typedef typename size_type_of >::type SizeT; if(icl::is_empty(object)) return icl::identity_element::value(); else return icl::infinity::value(); } template typename boost::enable_if, typename size_type_of >::type>::type cardinality(const Type& object) { typedef typename size_type_of >::type SizeT; return icl::is_empty(object) ? identity_element::value() : static_cast(last_next(object) - first(object)); } template typename boost::enable_if, typename size_type_of >::type>::type cardinality(const Type& object) { typedef typename size_type_of >::type SizeT; return icl::is_empty(object) ? identity_element::value() : static_cast(last_next(object) - first(object)); } //- size ----------------------------------------------------------------------- template inline typename enable_if, typename size_type_of >::type>::type size(const Type& object) { return cardinality(object); } //- length --------------------------------------------------------------------- template inline typename boost::enable_if, typename difference_type_of >::type>::type length(const Type& object) { typedef typename difference_type_of >::type DiffT; return icl::is_empty(object) ? identity_element::value() : upper(object) - lower(object); } template inline typename boost::enable_if, typename difference_type_of >::type>::type length(const Type& object) { typedef typename difference_type_of >::type DiffT; return icl::is_empty(object) ? identity_element::value() : last_next(object) - first(object); } template typename boost::enable_if, typename difference_type_of >::type>::type length(const Type& object) { typedef typename difference_type_of >::type DiffT; return icl::is_empty(object) ? identity_element::value() : upper(object) - lower(object); } template inline typename boost::enable_if, typename difference_type_of >::type>::type length(const Type& object) { typedef typename difference_type_of >::type DiffT; return icl::is_empty(object) ? identity_element::value() : last_next(object) - first(object); } //- iterative_size ------------------------------------------------------------- template inline typename enable_if, typename size_type_of >::type>::type iterative_size(const Type&) { return 2; } //============================================================================== //= Addition //============================================================================== //- hull ----------------------------------------------------------------------- /** \c hull returns the smallest interval containing \c left and \c right. */ template typename boost::enable_if, Type>::type hull(Type left, const Type& right) { typedef typename interval_traits::domain_compare domain_compare; if(icl::is_empty(right)) return left; else if(icl::is_empty(left)) return right; return construct ( (std::min)(lower(left), lower(right), domain_compare()), (std::max)(upper(left), upper(right), domain_compare()) ); } template typename boost::enable_if, Type>::type hull(Type left, const Type& right) { if(icl::is_empty(right)) return left; else if(icl::is_empty(left)) return right; return dynamic_interval_traits::construct_bounded ( lower_min(left, right), upper_max(left, right) ); } //============================================================================== //= Subtraction //============================================================================== //- left_subtract -------------------------------------------------------------- /** subtract \c left_minuend from the \c right interval on it's left side. Return the difference: The part of \c right right of \c left_minuend. \code right_over = right - left_minuend; //on the left. ... d) : right ... c) : left_minuend [c d) : right_over \endcode */ template typename boost::enable_if, Type>::type left_subtract(Type right, const Type& left_minuend) { if(exclusive_less(left_minuend, right)) return right; return construct(upper(left_minuend), upper(right)); } template typename boost::enable_if, Type>::type left_subtract(Type right, const Type& left_minuend) { if(exclusive_less(left_minuend, right)) return right; else if(upper_less_equal(right, left_minuend)) return identity_element::value(); return construct(domain_next(upper(left_minuend)), upper(right)); } template typename boost::enable_if, Type>::type left_subtract(Type right, const Type& left_minuend) { if(exclusive_less(left_minuend, right)) return right; return construct(domain_prior(upper(left_minuend)), upper(right)); } template typename boost::enable_if, Type>::type left_subtract(Type right, const Type& left_minuend) { if(exclusive_less(left_minuend, right)) return right; return dynamic_interval_traits::construct_bounded ( reverse_bounded_upper(left_minuend), bounded_upper(right) ); } //- right_subtract ------------------------------------------------------------- /** subtract \c right_minuend from the \c left interval on it's right side. Return the difference: The part of \c left left of \c right_minuend. \code left_over = left - right_minuend; //on the right side. [a ... : left [b ... : right_minuend [a b) : left_over \endcode */ template typename boost::enable_if, Type>::type right_subtract(Type left, const Type& right_minuend) { if(exclusive_less(left, right_minuend)) return left; return construct(lower(left), lower(right_minuend)); } template typename boost::enable_if, Type>::type right_subtract(Type left, const Type& right_minuend) { if(exclusive_less(left, right_minuend)) return left; else if(lower_less_equal(right_minuend, left)) return identity_element::value(); return construct(lower(left), domain_prior(lower(right_minuend))); } template typename boost::enable_if, Type>::type right_subtract(Type left, const Type& right_minuend) { if(exclusive_less(left, right_minuend)) return left; return construct(lower(left), domain_next(lower(right_minuend))); } template typename boost::enable_if, Type>::type right_subtract(Type left, const Type& right_minuend) { if(exclusive_less(left, right_minuend)) return left; return dynamic_interval_traits::construct_bounded ( bounded_lower(left), reverse_bounded_lower(right_minuend) ); } //============================================================================== //= Intersection //============================================================================== //- operator & ----------------------------------------------------------------- /** Returns the intersection of \c left and \c right interval. */ template typename boost::enable_if, Type>::type operator & (Type left, const Type& right) { typedef typename interval_traits::domain_compare domain_compare; if(icl::is_empty(left) || icl::is_empty(right)) return identity_element::value(); else return construct ( (std::max)(icl::lower(left), icl::lower(right), domain_compare()), (std::min)(icl::upper(left), icl::upper(right), domain_compare()) ); } template typename boost::enable_if, Type>::type operator & (Type left, const Type& right) { typedef typename interval_traits::domain_compare domain_compare; if(icl::is_empty(left) || icl::is_empty(right)) return identity_element::value(); else return construct ( (std::max)(icl::lower(left), icl::lower(right), domain_compare()), (std::min)(icl::upper(left), icl::upper(right), domain_compare()) ); } template typename boost::enable_if, Type>::type operator & (Type left, const Type& right) { if(icl::is_empty(left) || icl::is_empty(right)) return identity_element::value(); else return dynamic_interval_traits::construct_bounded ( lower_max(left, right), upper_min(left, right) ); } //- intersects ----------------------------------------------------------------- template typename boost::enable_if, bool>::type intersects(const Type& left, const Type& right) { return !( icl::is_empty(left) || icl::is_empty(right) || exclusive_less(left,right) || exclusive_less(right,left)); } //- disjoint ------------------------------------------------------------------- template typename boost::enable_if, bool>::type disjoint(const Type& left, const Type& right) { return icl::is_empty(left) || icl::is_empty(right) || exclusive_less(left,right) || exclusive_less(right,left); } //============================================================================== //= Complement //============================================================================== template typename boost::enable_if, Type>::type inner_complement(const Type& left, const Type& right) { if(icl::is_empty(left) || icl::is_empty(right)) return identity_element::value(); else if(exclusive_less(left, right)) return construct(upper(left), lower(right)); else if(exclusive_less(right, left)) return construct(upper(right), lower(left)); else return identity_element::value(); } template typename boost::enable_if, Type>::type inner_complement(const Type& left, const Type& right) { if(icl::is_empty(left) || icl::is_empty(right)) return identity_element::value(); else if(exclusive_less(left, right)) return construct(domain_next(upper(left)), domain_prior(lower(right))); else if(exclusive_less(right, left)) return construct(domain_next(upper(right)), domain_prior(lower(left))); else return identity_element::value(); } template typename boost::enable_if, Type>::type inner_complement(const Type& left, const Type& right) { if(icl::is_empty(left) || icl::is_empty(right)) return identity_element::value(); else if(exclusive_less(left, right)) return construct(last(left), first(right)); else if(exclusive_less(right, left)) return construct(last(right), first(left)); else return identity_element::value(); } template typename boost::enable_if, Type>::type inner_complement(const Type& left, const Type& right) { if(icl::is_empty(left) || icl::is_empty(right)) return identity_element::value(); else if(exclusive_less(left, right)) return right_subtract(left_subtract(hull(left, right), left), right); else if(exclusive_less(right, left)) return right_subtract(left_subtract(hull(right, left), right), left); else return identity_element::value(); } template inline typename boost::enable_if, Type>::type between(const Type& left, const Type& right) { return inner_complement(left, right); } //============================================================================== //= Distance //============================================================================== template typename boost:: enable_if< mpl::and_< is_interval , has_difference::domain_type> , is_discrete::domain_type> > , typename difference_type_of >::type>::type distance(const Type& x1, const Type& x2) { typedef typename difference_type_of >::type difference_type; if(icl::is_empty(x1) || icl::is_empty(x2)) return icl::identity_element::value(); else if(domain_less(last(x1), first(x2))) return static_cast(icl::pred(first(x2) - last(x1))); else if(domain_less(last(x2), first(x1))) return static_cast(icl::pred(first(x1) - last(x2))); else return icl::identity_element::value(); } template typename boost:: enable_if< mpl::and_< is_interval , has_difference::domain_type> , is_continuous::domain_type> > , typename difference_type_of >::type>::type distance(const Type& x1, const Type& x2) { typedef typename difference_type_of >::type DiffT; if(icl::is_empty(x1) || icl::is_empty(x2)) return icl::identity_element::value(); else if(domain_less(upper(x1), lower(x2))) return lower(x2) - upper(x1); else if(domain_less(upper(x2), lower(x1))) return lower(x1) - upper(x2); else return icl::identity_element::value(); } //============================================================================== //= Streaming, representation //============================================================================== template typename boost:: enable_if< mpl::or_< is_static_left_open , is_static_open >, std::string>::type left_bracket(const Type&) { return "("; } template typename boost:: enable_if< mpl::or_< is_static_right_open , is_static_closed >, std::string>::type left_bracket(const Type&) { return "["; } template typename boost::enable_if, std::string>::type left_bracket(const Type& object) { return left_bracket(object.bounds()); } //------------------------------------------------------------------------------ template typename boost:: enable_if< mpl::or_< is_static_right_open , is_static_open >, std::string>::type right_bracket(const Type&) { return ")"; } template typename boost:: enable_if< mpl::or_< is_static_left_open , is_static_closed >, std::string>::type right_bracket(const Type&) { return "]"; } template typename boost::enable_if, std::string>::type right_bracket(const Type& object) { return right_bracket(object.bounds()); } //------------------------------------------------------------------------------ template typename boost::enable_if, std::basic_ostream >::type& operator << (std::basic_ostream &stream, Type const& object) { if(boost::icl::is_empty(object)) return stream << left_bracket(object) << right_bracket(object); else return stream << left_bracket(object) << interval_traits::lower(object) << "," << interval_traits::upper(object) << right_bracket(object) ; } }} // namespace icl boost #endif