Date view Thread view Subject view Author view

Subject: [Boost-commit] svn:boost r55599 - in sandbox/itl: boost/itl boost/itl/type_traits libs/itl/build/win32 libs/itl/doc libs/itl/example/party_ libs/itl/example/user_groups_ libs/itl/test/test_casual_
From: afojgo_at_[hidden]
Date: 2009-08-15 05:28:56

Author: jofaber
Date: 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
New Revision: 55599
URL: http://svn.boost.org/trac/boost/changeset/55599

Log:
Added documentation. Detailed function documentation added. Stable {msvc-9.0}
Added:
   sandbox/itl/libs/itl/doc/functions.qbk (contents, props changed)
   sandbox/itl/libs/itl/doc/functions_addition.qbk (contents, props changed)
   sandbox/itl/libs/itl/doc/functions_cons_copy_dest.qbk (contents, props changed)
   sandbox/itl/libs/itl/doc/functions_containedness.qbk (contents, props changed)
   sandbox/itl/libs/itl/doc/functions_ctor_dtor.qbk (contents, props changed)
   sandbox/itl/libs/itl/doc/functions_equivs_orderings.qbk (contents, props changed)
   sandbox/itl/libs/itl/doc/functions_erasure.qbk (contents, props changed)
   sandbox/itl/libs/itl/doc/functions_insertion.qbk (contents, props changed)
   sandbox/itl/libs/itl/doc/functions_intersection.qbk (contents, props changed)
   sandbox/itl/libs/itl/doc/functions_iterator_related.qbk (contents, props changed)
   sandbox/itl/libs/itl/doc/functions_range.qbk (contents, props changed)
   sandbox/itl/libs/itl/doc/functions_selection.qbk (contents, props changed)
   sandbox/itl/libs/itl/doc/functions_size.qbk (contents, props changed)
   sandbox/itl/libs/itl/doc/functions_streaming.qbk (contents, props changed)
   sandbox/itl/libs/itl/doc/functions_subtraction.qbk (contents, props changed)
   sandbox/itl/libs/itl/doc/functions_symmetric_difference.qbk (contents, props changed)
Text files modified:
   sandbox/itl/boost/itl/functions.hpp | 28 ++
   sandbox/itl/boost/itl/interval_base_map.hpp | 13 +
   sandbox/itl/boost/itl/interval_base_set.hpp | 12 +
   sandbox/itl/boost/itl/map.hpp | 30 +-
   sandbox/itl/boost/itl/type_traits/is_combinable.hpp | 2
   sandbox/itl/libs/itl/build/win32/vc9_all.sln | 6
   sandbox/itl/libs/itl/doc/Jamfile.v2 | 2
   sandbox/itl/libs/itl/doc/implementation.qbk | 2
   sandbox/itl/libs/itl/doc/interface.qbk | 99 +++++---
   sandbox/itl/libs/itl/doc/itl.qbk | 41 +++
   sandbox/itl/libs/itl/example/party_/party.cpp | 2
   sandbox/itl/libs/itl/example/user_groups_/user_groups.cpp | 2
   sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp | 472 ---------------------------------------
   13 files changed, 183 insertions(+), 528 deletions(-)

Modified: sandbox/itl/boost/itl/functions.hpp
==============================================================================
--- sandbox/itl/boost/itl/functions.hpp (original)
+++ sandbox/itl/boost/itl/functions.hpp 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -97,7 +97,10 @@
         return object.add(operand);
 }
 
-
+/** \par \b Requires: \c object and \c operand are addable.
+ \b Effects: \c operand is added to \c object.
+ \par \b Efficieny: There is one additional copy of
+ \c ObjectT \c object compared to inplace \c operator \c += */
 template<class ObjectT, class OperandT>
 typename boost::enable_if<is_binary_intra_combinable<ObjectT, OperandT>, ObjectT>::type
 operator + (ObjectT object, const OperandT& operand)
@@ -105,6 +108,10 @@
     return object += operand;
 }
 
+/** \par \b Requires: \c object and \c operand are addable.
+ \b Effects: \c operand is added to \c object.
+ \par \b Efficieny: There is one additional copy of
+ \c ObjectT \c object compared to inplace \c operator \c += */
 template<class ObjectT, class OperandT>
 typename boost::enable_if<is_binary_intra_combinable<ObjectT, OperandT>, ObjectT>::type
 operator + (const OperandT& operand, ObjectT object)
@@ -113,6 +120,10 @@
 }
 
 
+/** \par \b Requires: \c object and \c operand are addable.
+ \b Effects: \c operand is added to \c object.
+ \par \b Efficieny: There is one additional copy of
+ \c ObjectT \c object compared to inplace \c operator \c += */
 template<class ObjectT>
 ObjectT operator + (typename ObjectT::overloadable_type object, const ObjectT& operand)
 {
@@ -154,7 +165,10 @@
         return object += operand;
 }
 
-
+/** \par \b Requires: \c object and \c operand are addable.
+ \b Effects: \c operand is added to \c object.
+ \par \b Efficieny: There is one additional copy of
+ \c ObjectT \c object compared to inplace \c operator \c |= */
 template<class ObjectT, class OperandT>
 typename boost::enable_if<is_binary_intra_combinable<ObjectT, OperandT>, ObjectT>::type
 operator | (ObjectT object, const OperandT& operand)
@@ -162,6 +176,10 @@
     return object += operand;
 }
 
+/** \par \b Requires: \c object and \c operand are addable.
+ \b Effects: \c operand is added to \c object.
+ \par \b Efficieny: There is one additional copy of
+ \c ObjectT \c object compared to inplace \c operator \c |= */
 template<class ObjectT, class OperandT>
 typename boost::enable_if<is_binary_intra_combinable<ObjectT, OperandT>, ObjectT>::type
 operator | (const OperandT& operand, ObjectT object)
@@ -169,7 +187,10 @@
     return object += operand;
 }
 
-
+/** \par \b Requires: \c object and \c operand are addable.
+ \b Effects: \c operand is added to \c object.
+ \par \b Efficieny: There is one additional copy of
+ \c ObjectT \c object compared to inplace \c operator \c |= */
 template<class ObjectT>
 ObjectT operator | (typename ObjectT::overloadable_type object, const ObjectT& operand)
 {
@@ -207,7 +228,6 @@
 is \b amortized \b logarithmic.
 */
 template<class ObjectT, class OperandT>
-inline
 typename boost::enable_if<is_concept_equivalent<is_interval_map, ObjectT, OperandT>,
                           ObjectT>::type&
 operator -=(ObjectT& object, const OperandT& operand)

Modified: sandbox/itl/boost/itl/interval_base_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_map.hpp 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -433,13 +433,18 @@
     /** Erase all value pairs from \c *this map that are elements of map \eraser */
     SubType& erase(const interval_base_map& eraser);
 
+ /** Erase all value pairs within the range of the interval that iterator
+ \c position points to. */
+ void erase(iterator position){ _map.erase(position); }
+
+ /** Erase all value pairs for a range of iterators <tt>[first,past)</tt>. */
+ void erase(iterator first, iterator past){ _map.erase(first, past); }
 
     /** Remove all elements where property <tt>p</tt> holds, keep all others */
     template<class Predicate>
     interval_base_map& erase_if(const Predicate& pred)
     { _map.erase_if(pred); return *this; }
 
-
     //==========================================================================
     //= Intersection
     //==========================================================================
@@ -566,6 +571,12 @@
     const_iterator upper_bound(const key_type& interval)const
     { return _map.upper_bound(interval); }
 
+ std::pair<iterator,iterator> equal_range(const key_type& interval)
+ { return _map.equal_range(interval); }
+
+ std::pair<const_iterator,const_iterator> equal_range(const key_type& interval)const
+ { return _map.equal_range(interval); }
+
     iterator begin() { return _map.begin(); }
     iterator end() { return _map.end(); }
     const_iterator begin()const { return _map.begin(); }

Modified: sandbox/itl/boost/itl/interval_base_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_set.hpp 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -283,6 +283,13 @@
     SubType& erase(const segment_type& inter_val)
     { return subtract(inter_val); }
 
+ /** Erase the interval that iterator \c position points to. */
+ void erase(iterator position){ _set.erase(position); }
+
+ /** Erase all intervals in the range <tt>[first,past)</tt> of iterators. */
+ void erase(iterator first, iterator past){ _set.erase(first, past); }
+
+
     //==========================================================================
     //= Intersection
     //==========================================================================
@@ -361,6 +368,11 @@
     const_iterator upper_bound(const value_type& interval)const
     { return _set.upper_bound(interval); }
 
+ std::pair<iterator,iterator> equal_range(const key_type& interval)
+ { return _set.equal_range(interval); }
+
+ std::pair<const_iterator,const_iterator> equal_range(const key_type& interval)const
+ { return _set.equal_range(interval); }
 
     //==========================================================================
     //= Morphisms

Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -555,11 +555,11 @@
           ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
 map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
     insert(map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& insertee)
+ const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& addend)
 {
     typedef map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> map_type;
 
- const_FORALL(typename map_type, elem_, insertee)
+ const_FORALL(typename map_type, elem_, addend)
         object.insert(*elem_);
 
     return object;
@@ -569,11 +569,11 @@
           ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
 map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
     erase(map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& erasee)
+ const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& erasure)
 {
     typedef map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> map_type;
 
- const_FORALL(typename map_type, elem_, erasee)
+ const_FORALL(typename map_type, elem_, erasure)
         object.erase(*elem_);
 
     return object;
@@ -661,10 +661,8 @@
 template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
 itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
 operator + (const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::element_type& operand,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object )
+ itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object )
 {
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- ObjectT result(object);
     return result += operand;
 }
 
@@ -674,17 +672,20 @@
 inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
 operator += ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
              const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
-{ Set::add(object, operand); return object; }
+{
+ return Set::add(object, operand);
+}
 
 
 template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
 inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator + ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
+operator + ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object,
              const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
 {
     return object += operand;
 }
 
+
 //--------------------------------------------------------------------------
 
 template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
@@ -705,7 +706,7 @@
 template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
 itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
 operator | (const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::element_type& operand,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object )
+ itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object )
 {
     typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
     ObjectT result(object);
@@ -718,7 +719,9 @@
 inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
 operator |= ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
              const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
-{ Set::add(object, operand); return object; }
+{
+ return Set::add(object, operand);
+}
 
 
 template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
@@ -729,6 +732,7 @@
     return object |= operand;
 }
 
+
 //--------------------------------------------------------------------------
 
 /** Subtract a map \c x2 from this map. If an element of \c x2 already exists
@@ -759,7 +763,9 @@
 inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
 operator -= ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
     const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::set_type& operand)
-{ Set::erase(object, operand); return object; }
+{
+ return Set::erase(object, operand);
+}
 
 
 template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>

Modified: sandbox/itl/boost/itl/type_traits/is_combinable.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_combinable.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_combinable.hpp 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -247,7 +247,7 @@
 };
 
 //------------------------------------------------------------------------------
-//- new right
+//- right combinable
 //------------------------------------------------------------------------------
 
 template<class GuideT, class CompanionT>

Modified: sandbox/itl/libs/itl/build/win32/vc9_all.sln
==============================================================================
--- sandbox/itl/libs/itl/build/win32/vc9_all.sln (original)
+++ sandbox/itl/libs/itl/build/win32/vc9_all.sln 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -131,6 +131,8 @@
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_fastest_total_interval_quantifier", "..\..\test\fastest_total_interval_quantifier_\vc9_fastest_total_interval_quantifier.vcproj", "{EE61B7EF-EC45-4165-8B4B-FD5B7D2A917F}"
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_test_combinable", "..\..\test\test_combinable_\vc9_test_combinable.vcproj", "{EE61B7EF-EC45-4165-8B49-FD5B8D3A9FA1}"
+EndProject
 Global
         GlobalSection(SolutionConfigurationPlatforms) = preSolution
                 Debug|Win32 = Debug|Win32
@@ -397,6 +399,10 @@
                 {EE61B7EF-EC45-4165-8B4B-FD5B7D2A917F}.Debug|Win32.Build.0 = Debug|Win32
                 {EE61B7EF-EC45-4165-8B4B-FD5B7D2A917F}.Release|Win32.ActiveCfg = Release|Win32
                 {EE61B7EF-EC45-4165-8B4B-FD5B7D2A917F}.Release|Win32.Build.0 = Release|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B8D3A9FA1}.Debug|Win32.ActiveCfg = Debug|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B8D3A9FA1}.Debug|Win32.Build.0 = Debug|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B8D3A9FA1}.Release|Win32.ActiveCfg = Release|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B8D3A9FA1}.Release|Win32.Build.0 = Release|Win32
         EndGlobalSection
         GlobalSection(SolutionProperties) = preSolution
                 HideSolutionNode = FALSE

Modified: sandbox/itl/libs/itl/doc/Jamfile.v2
==============================================================================
--- sandbox/itl/libs/itl/doc/Jamfile.v2 (original)
+++ sandbox/itl/libs/itl/doc/Jamfile.v2 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -48,7 +48,7 @@
         <xsl:param>boost.libraries=../../../libraries.htm
         <xsl:param>toc.max.depth=2
         <xsl:param>toc.section.depth=2
- <xsl:param>chunk.section.depth=1
+ <xsl:param>chunk.section.depth=2
                 <dependency>itldoc
 
     ;

Added: sandbox/itl/libs/itl/doc/functions.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -0,0 +1,48 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[section Function Reference]
+
+Section [link boost_itl.interface.function_synopsis Function Synopsis]
+above gave an overview of the polymorphic functions of the itl.
+This is what you will need to find the desired possibilites to combine itl objects.
+Most of the time, the functions and overloads that you intuitively expect
+should be provided, so you won't need to refer to the documentation often.
+
+If you are interested
+
+* in the ['*specific design of the function overloads*],
+* in ['*complexity charactersistics*] for certain overloads
+* or if the complier ['*refuses to resolve*] specific function application you want to use,
+
+refer to this section that describes the polymorphic function families of the itl
+in detail.
+
+For a concise representaion the same __eiS_phs__ will be used that have been
+introduced in section [link boost_itl.interface.function_synopsis Function Synopsis].
+
+[include functions_cons_copy_dest.qbk]
+[include functions_containedness.qbk]
+[include functions_equivs_orderings.qbk]
+[include functions_size.qbk]
+[include functions_range.qbk]
+[include functions_selection.qbk]
+[include functions_addition.qbk]
+[include functions_subtraction.qbk]
+[include functions_insertion.qbk]
+[include functions_erasure.qbk]
+[include functions_intersection.qbk]
+[include functions_symmetric_difference.qbk]
+[include functions_iterator_related.qbk]
+[include functions_streaming.qbk]
+
+
+[endsect][/ Function Reference]
+
+

Added: sandbox/itl/libs/itl/doc/functions_addition.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_addition.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -0,0 +1,288 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[/ //= Addition ===============================================================]
+[section Addition]
+
+[section Synopsis]
+
+[table
+[[Addition] [__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map] ]
+[[`T& T::add(const P&)`] [__ei] [__bp] [__e] [__b] ]
+[[`T& operator +=(T&, const P&)`] [__eiS] [__bpM] [__es] [__bm] ]
+[[`T operator + (T, const P&)`\n`T operator + (const P&, T)`][__eiS] [__bpM] [__es] [__bm] ]
+[[`T& operator |=( T&, const P&)`] [__eiS] [__bpM] [__es] [__bm] ]
+[[`T operator | (T, const P&)`\n`T operator | (const P&, T)`][__eiS] [__bpM] [__es] [__bm] ]
+]
+
+Functions and operators that implement ['*Addition*] on *itl* objects
+are given in the table above.
+
+[note `operator |=` and `operator |` are implemented just as `operator +=` and `operator +`.
+This is a redundancy that has been introduced deliberately, because
+a /set union/ semantics is often attached `operators |=` and `|`.
+]
+
+[endsect][/ Synopsis]
+
+[section Member functions][/ Addition]
+
+The admissable combinations of types for memberfunction
+`T& T::add(const P&)` can be summarized in the
+['*overload table*] below:
+
+``
+// overload table for
+T& T::add(const P&)
+
+add | e i b p
+----+--------
+s | s
+m | m
+S | S S
+M | M M
+``
+
+The next table contains complexity characteristics for `add`.
+
+[table Time Complexity for member function add on itl containers
+[[`T& T::add(const P&)`] [__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__]]
+[[__itl_set__] [__Olgn__] [] [] [] ]
+[[__itl_map__] [] [] [__Olgn__][] ]
+[[__itv_set__\n__sep_itv_set__][__Olgn__] [__a_Olgn__][] [] ]
+[[__spl_itv_set__] [__Olgn__] [__On__] [] [] ]
+[[__itv_map__\n__spl_itv_map__][] [] [__Olgn__][__On__] ]
+]
+
+[endsect][/ Member function Addition]
+
+[section Inplace operators]
+
+The possible overloads of inplace `T& operator += (T&, const P&)`
+are given by two tables, that show admissable combinations of types.
+Row types show instantiations of argument type `T`. Columns types
+show show instantiations of argument type `P`. If a combination
+of argument types is possible, the related table cell contains
+the result type of the operation.
+__eiS_Phs__ __eibpsSmM__ will be used to denote
+/elements, intervals,
+element value pairs, interval value pairs,
+element sets, interval sets,
+element maps/ and /interval maps/.
+The first table shows the
+overloads of `+=` for /element containers/ the second table
+refers to /interval containers/.
+
+``
+// overload tables for
+T& operator += (T&, const P&)
+
+element containers: interval containers:
++= | e b s m += | e i b p S M
+---+-------- ---+------------
+s | s s S | S S S
+m | m m M | M M M
+``
+
+For the definition of admissable overloads
+we separate /element containers/ from /interval containers/.
+Within each group all combinations of types are supported
+for an operation, that are inline with the *itl's*
+design and the sets of laws, that establish the *itl's*
+[link boost_itl.semantics semantics].
+
+
+Overloads between /element containers/ and /interval containers/
+could also be defined. But this has not been done for
+pragmatical reasons: Each additional combination of types
+for an operation enlarges the space of possible overloads.
+This makes the overload resolution by compilers more complex,
+error prone and slows down compilation speed. Error messages
+for unresolvable or ambiguous overloads are difficult
+to read and understand. Therefore overloading of namespace
+global functions in the *itl* are limited to a reasonable
+field of combinations, that are described here.
+
+[endsect][/ Inplace operators]
+
+
+[h4 Complexity]
+
+For different combinations of argument types `T` and `P`
+different implementations of the `operator +=` are
+selected. These implementations show different complexity
+characteristics.
+If `T` is a container type,
+the combination of
+domain elements (__e) or element value pairs (__b)
+is faster than a combination of intervals (__i) or
+interval value pairs (__p) which in turn is faster than
+the combinatin of element or interval containers.
+The next table shows /time complexities/ of addition for
+*itl's* element containers.
+
+Sizes `n` and `m` are in the complexity statements are sizes
+of objects `T y` and `P x`:
+``
+n = y.iterative_size();
+m = x.iterative_size(); //if P is a container type
+``
+Note, that for an interval container the number of elements `T::size` is
+different from the number of intervals that you can iterate over.
+Therefore a function `T::iterative_size()` is used that provides the
+desired kind of size.
+
+[table Time Complexity for inplace Addition on element containers
+[[`T& operator += (T& y, const P& x)`][__ch_dom_t__][__ch_dom_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
+[[__itl_set__] [__Olgn__] [] [__Om__] [] ]
+[[__itl_map__] [] [__Olgn__] [] [__Om__] ]
+]
+
+Time complexity characteristics of inplace addition for interval containers
+is given by this table.
+
+[table Time Complexity for inplace Addition on interval containers
+[[`T& operator += (T& y, const P& x)`][][__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
+[[interval_sets][__itv_set__\n__sep_itv_set__][__Olgn__] [__a_Olgn__][] [] [__Omlgnpm__] [] ]
+[[] [__spl_itv_set__] [__Olgn__] [__On__] [] [] [__Omlgnpm__] [] ]
+[[interval_maps][] [] [] [__Olgn__][__On__] [] [__Omlgnpm__] ]
+]
+
+Since the implementation of
+element and interval containers is based on the
+[link boost_itl.implementation link red-black tree implementation]
+of std::AssociativeContainers, we have a logarithmic complexity for
+addition of elements.
+Addition of intervals or interval value pairs is amortized logarithmic
+for __itv_sets__ and __sep_itv_sets__ and linear for __spl_itv_sets__
+and __itv_maps__.
+Addition is linear for element containers and
+loglinear for interval containers.
+
+
+[section Infix operators]
+
+For every inplace operator
+``
+T& operator o= (T& object, const P& operand)
+``
+the *itl* provides corresponding infix operators.
+``
+T operator o (T object, const P& operand){ return object o= operand; }
+T operator o (const P& operand, T object){ return object o= operand; }
+``
+
+From this implementation of infix `operator o`
+the compiler will hopefully use return value optimization
+[@http://en.wikipedia.org/wiki/Return_value_optimization (RVO)]
+creatiing no temporary object and performing one copy of
+the first argument `object`.
+
+[caution
+Compared to the /inplace/ `operator o=` every use of an
+/infix/ `operator o` requires ['*one extra copy*]
+of the first argument `object` that passes a container.]
+
+Use infix operators only, if
+
+* efficiency is not crucial, e.g. the containers copied are small.
+* a concise and short notation is more important than efficiency in your context.
+* you need the result of operator `o=` as a copy anyway.
+
+
+The admissable type combinations for infix `operator +`
+is defined by the overload tables below. For interval containers
+__itv_sets__ __S and __itv_maps__ __M are split up into
+
+``
+S1: interval_set M1: interval_map
+S2: separate_interval_set
+S3: split_interval_set M3: split_interval_map
+``
+
+``
+// overload tables for
+T operator + (T, const P&)
+T operator + (const P&, T)
+
+element containers: interval containers:
++ | e b s m + | e i b p S1 S2 S3 M1 M3
+---+-------- ---+---------------------------
+e | s e | S1 S2 S3
+b | m i | S1 S2 S3
+s | s s b | M1 M3
+m | m m p | M1 M3
+ S1 | S1 S1 S1 S2 S3
+ S2 | S2 S2 S2 S2 S3
+ S3 | S3 S3 S3 S3 S3
+ M1 | M1 M1 M1 M3
+ M3 | M3 M3 M3 M3
+``
+
+[h5 Segmentational Fineness]
+
+The indices `i` of `Si` and `Mi` represent a property
+called ['*segmentational fineness*] or short ['*fineness*].
+Segmentational fineness represents the fact,
+that for interval containers holding the same elements, a
+splitting interval container may contain more segments as
+a separating container which in turn may contain more
+segments than a joining one. So for an
+``
+operator >
+``
+where
+``
+x > y // means that
+x is_finer_than y
+
+// we have
+
+finer coarser
+split_interval_set interval_set
+ > separate_interval_set >
+split_interval_map interval_map
+``
+
+This relation is needed to resolve the instantiation of an
+infix `T operator + (P, Q)` for two interval container types
+`P` and `Q`. If both `P` and `Q` are candidates for the result
+type `T`, one of them must be chosen by the compiler.
+We choose the type that is segmentational finer as
+result type `T`. This way we do not loose the ['*segment informations*]
+that are stored in the ['*finer] one of the container types `P` and `Q`.
+
+So looking up a type combination for e.g.
+`T operator + (interval_map, split_interval_map)`
+which is equivalent to
+`T operator + (M1, M3)`
+we find for row type `M1` and column type `M3`,
+`M3` will be assigned as result type.
+So this type combination will result in
+choosing an
+``
+split_interval_map operator + (const interval_map&, split_interval_map)
+``
+
+[h5 Time Complexity of infix `operators o`]
+
+The time complexity of all infix operators of the *itl*
+is biased by the extra copy of the `object` argument.
+So all infix `operators o` are at least
+/linear/ in `n = object.iterative_size()`.
+Taking this into account, the complexities of all
+infix operators can be determined
+from the corresponding inplace `operators o=` they depend
+on.
+
+[endsect][/ Infix operators]
+
+[endsect][/ Addition]
+
+

Added: sandbox/itl/libs/itl/doc/functions_cons_copy_dest.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_cons_copy_dest.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -0,0 +1,25 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[/ //= Construct, copy, destruct ===================================================================]
+[section Construct, copy, destruct]
+
+[table
+[[['*Construct, copy, destruct*]] [interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map] ]
+[[`T::T()`] [1] [1] [1] [1] [1] ]
+[[`T::T(const T&)`] [A] [1] [1] [1] [1] ]
+[[`T::T(const P&)`] [ ] [__eiS] [__bpM] [ ] [ ] ]
+[[`T::T(...)`] [3] [ ] [ ] [3] [3] ]
+[[`T& T::operator=(const P&)`] [A] [__S] [__M] [1] [1] ]
+[[`void T::swap(T&)`] [ ] [1] [1] [1] [1] ]
+]
+
+[endsect][/ Construct, copy, destruct]
+
+

Added: sandbox/itl/libs/itl/doc/functions_containedness.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_containedness.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -0,0 +1,23 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[/ //= Containedness ===================================================================]
+[section Containedness]
+
+[table
+[[['*Containedness*]] [interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map] ]
+[[`void T::clear()`] [1] [1] [1] [1] [1] ]
+[[`bool T::empty()const`] [1] [1] [1] [1] [1] ]
+[[`bool T::contains(const P&)const`] [__ei] [__eiS][__eiS __bpM][__es] [__bm] ]
+[[`bool T::contained_in(const P&)const`] [__i] [__S] [__M] [1] [1] ]
+]
+
+[endsect][/ Containedness]
+
+

Added: sandbox/itl/libs/itl/doc/functions_ctor_dtor.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_ctor_dtor.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -0,0 +1,49 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[/ //= Range ===================================================================]
+[section Range]
+
+[table
+[[['*Range*]] [interval][__ch_itv_sets__][__ch_itv_maps__][condition] ]
+[[`interval<domain_type> hull(const T&)`] [ ] [__O1__] [__O1__][] ]
+[[`domain_type T::lower()const`] [__O1__] [__O1__] [__O1__][] ]
+[[`domain_type T::upper()const`] [__O1__] [__O1__] [__O1__][] ]
+[[`domain_type T::first()const`] [__O1__] [__O1__] [__O1__][`!is_continuous<domain_type>::value`]]
+[[`domain_type T::last()const`] [__O1__] [__O1__] [__O1__][`!is_continuous<domain_type>::value`]]
+]
+
+The table above shows the availability of functions
+`hull`, `lower`, `upper`, `first` and `last` on intervals
+and interval containers that are all of ['*constant time complexity*].
+Find the functions description and some simple properties below.
+
+[table
+[[['*Range*]] [Types] [Description] ]
+[[`interval<domain_type> hull(const T&)`] [__S __M] [`hull(x)` returns the smallest interval that contains all intervals of an interval container `x`.] ]
+[[`domain_type T::lower()const`] [__i __S __M][`x.lower()` returns the lower bound of an interval or interval container `x`.] ]
+[[`domain_type T::upper()const`] [__i __S __M][`x.upper()` returns the upper bound of an interval or interval container `x`.] ]
+[[`domain_type T::first()const`] [__i __S __M][`x.first()` returns the first element of an interval or interval container `x`.
+ `T::first()` ist defined for a non continuous `domain_type` only.] ]
+[[`domain_type T::last()const`] [__i __S __M][`x.last()` returns the last element of an interval or interval container `x`.
+ `T::last()` ist defined for a non continuous `domain_type` only.] ]
+]
+
+``
+// for interval_containers x:
+hull(x).lower() == x.lower()
+hull(x).upper() == x.upper()
+hull(x).first() == x.first()
+hull(x).last() == x.last()
+``
+
+
+[endsect][/ Range]
+
+

Added: sandbox/itl/libs/itl/doc/functions_equivs_orderings.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_equivs_orderings.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -0,0 +1,114 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[/ //= Equivalences and Orderings ===================================================]
+[section Equivalences and Orderings]
+
+[section Synopsis][/ Equivalences and Orderings]
+
+[table
+[[['*Equivalences and Orderings*]][interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map]]
+[[['Lexicographical Ordering]] [ ] [ ] [ ] [ ] [ ] ]
+[[`bool operator == (const T&, const T&)`] [1] [1] [1] [1] [1] ]
+[[`bool operator != (const T&, const T&)`] [1] [1] [1] [1] [1] ]
+[[`bool operator < (const T&, const T&)`] [1] [1] [1] [1] [1] ]
+[[`bool operator > (const T&, const T&)`] [1] [1] [1] [1] [1] ]
+[[`bool operator <= (const T&, const T&)`] [1] [1] [1] [1] [1] ]
+[[`bool operator >= (const T&, const T&)`] [1] [1] [1] [1] [1] ]
+[[['Sequential Element Ordering]] [ ] [ ] [ ] [ ] [ ] ]
+[[`bool is_element_equal(const T&, const P&)`] [ ] [__S] [__M] [1] [1] ]
+[[`bool is_element_less(const T&, const P&)`] [ ] [__S] [__M] [1] [1] ]
+[[`bool is_element_greater(const T&, const P&)`][ ] [__S] [__M] [1] [1] ]
+[[['Protonic Equality]] [ ] [ ] [ ] [ ] [ ] ]
+[[`bool is_protonic_equal(const T&, const P&)`][ ] [ ] [__M] [ ] [1] ]
+]
+
+
+[endsect][/ Synopsis Equivalences and Orderings]
+
+
+[section Lexicographical Ordering][/ Equivalences and Orderings]
+
+All common equality and compare operators are defined for
+all objects of the *itl*. For all *itl* containers
+equality and compare operators implement lexicographical
+equality and lexicographical comparison, that depends on
+the equality of template parameter `Compare`.
+
+Equality and compare operators are defined for all *itl*
+objects but there are no overload between different types.
+
+Containers of different segmentation are different,
+even if their elements are the same:
+``
+split_interval_set<time> w1, w2; //Pseudocode
+w1 = {[Mon .. Sun)}; //split_interval_set containing a week
+w2 = {[Mon .. Fri)[Sat .. Sun)}; //Same week split in work and week end parts.
+w1 == w2; //false: Different segmentation
+is_element_equal(w1,w2); //true: Same elements contained
+``
+
+[*Complexity] is ['*linear*] in the `iterative_size` of the shorter
+container to compare.
+
+[endsect][/ Lexicographical Ordering; Equivalences and Orderings]
+
+
+[/ ----------------------------------------------------------------------------]
+
+[section Sequential Element Ordering][/ Equivalences and Orderings]
+
+The ['*Sequential Element Ordering*] abstracts from the way in which
+elements of interval containers are clustered into intervals:
+it's ['*segmentation*].
+
+So these equality and compare operations can be applied within
+interval container types. The admissable type combinations are summarized
+in the next overload table.
+
+``
+// overload tables for
+bool is_element_equal (const T&, const P&)
+bool is_element_less (const T&, const P&)
+bool is_element_greater(const T&, const P&)
+
+element containers: interval containers:
+T\P| s m T\P| S1 S2 S3 M1 M3
+---+---- ---+---------------
+s | 1 S1 | 1 1 1
+m | 1 S2 | 1 1 1
+ S3 | 1 1 1
+ M1 | 1 1
+ M3 | 1 1
+``
+
+For element containers lexicographical equality and
+sequential element equality are identical.
+
+The *complexity* of sequential element comarison functions
+is ['*linear*] in the `iterative_size` of the larger
+container.
+
+[endsect]
+
+[section Protonic Equality][/ Equivalences and Orderings]
+
+['*Protonic Equality*] is an equality predicate that is availabe
+for __itl_maps__ and __itv_maps__. It yields true, if
+two maps are sequential element equal except for value
+pairs whose associated values are neutral elements.
+
+[*Complexity] is linear is the `iterative_size` of the
+larger container to compare.
+
+[endsect]
+
+[endsect][/ Equivalences and Orderings]
+
+

Added: sandbox/itl/libs/itl/doc/functions_erasure.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_erasure.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -0,0 +1,158 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[/ //= Erasure ===================================================================]
+[section Erasure]
+
+[section Synopsis][/ Erasure]
+
+[table
+[[['*Erasure*]] [__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map] ]
+[[`T& T::erase(const P&)`] [__ei ] [__ei __bp] [__e] [__bp] ]
+[[`T& erase(T&, const P&)`] [__eiS] [__eiS __bpM] [__es] [__bm] ]
+[[`void T::erase(iterator)`] [1] [1] [1] [1] ]
+[[`void T::erase(iterator,iterator)`] [1] [1] [1] [1] ]
+]
+
+[h5 Erasure]
+
+[/ JODO Does not apply to iterator based erasure]
+The effects of ['*erasure*] implemented by `erase` and ['*subtraction*]
+implemented by `subtract` and `operator -=` are identical for all Set-types of
+the *itl*.
+
+For Map-types, `erase` provides the *stl* semantics of erasure in
+contrast to `add` and `operator +=`, that implement a generalized subtraction,
+that performs inverse aggregations if key values collode or key intervals overlap.
+
+
+[endsect][/ Synopsis Erasure]
+
+
+[section Erasure of Objects]
+
+
+``
+// overload table for
+T& T::erase(const P&)
+
+erase | e i b p
+------+--------
+ s | s
+ m | m
+ S | S S
+ M | M M
+``
+
+The next table contains complexity characteristics for memberfunction `erase`.
+
+[table Time Complexity for member function erase on itl containers
+[[`T& T::erase(const P&)`] [__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__]]
+[[__itl_set__] [__Olgn__] [] [] [] ]
+[[__itl_map__] [__Olgn__] [] [__Olgn__] [] ]
+[[__itv_sets__] [__Olgn__] [__a_Olgn__] [] [] ]
+[[__itv_maps__] [__Olgn__] [__On__] [__Olgn__] [__On__] ]
+]
+
+
+As presented in the overload tables for inplace function `erase` below,
+more type combinations are available for /erasure/ than for
+/insertion/.
+
+``
+// overload tables for inplace function
+T& operator erase(T&, const P&)
+
+element containers: interval containers:
+erase | e b s m erase | e i b p S M
+ ---+-------- ---+------------
+ s | s s S | S S S
+ m | m m m m M | M M M M M M
+``
+
+We can split up these overloads in two groups.
+The first group can be called /reverse insertion/.
+
+``
+// (1) Reverse insertion
+erase | e b s m erase | e i b p S M
+ ---+-------- ---+------------
+ s | s s S | S S S
+ m | m m M | M M M
+``
+
+The second group can be viewed as an /erasure by key objects/
+
+``
+// (2) Erasure by key objects
+erase | e b s m erase | e i b p S M
+ ---+-------- ---+------------
+ s | s s S | S S S
+ m | m m M | M M M
+``
+
+On Maps ['*reverse insertion (1)*] is different from
+*stl's* erase semantics, because value pairs are deleted only,
+if key ['*and*] data values are found. Only
+['*erasure by key objects (2)*] works like the erase function
+on *stl's* std::maps, that passes a ['*key value*] as argument.
+
+On Sets both function groups fall together
+as ['*set difference*].
+
+
+Complexity characteristics for inplace erasure operations are
+given by the next tables where
+``
+n = y.iterative_size();
+m = x.iterative_size(); //if P is a container type
+``
+
+[table Time Complexity for inplace erasure on element containers
+[[`T& erase(T& y, const P& x)`][__ch_dom_t__][__ch_dom_mp_t__][__ch_itl_set__][__ch_itl_map__]]
+[[__itl_set__] [__Olgn__] [] [__Omlgn__] [] ]
+[[__itl_map__] [__Olgn__] [__Olgn__] [__Omlgn__] [__Omlgn__] ]
+]
+
+
+[table Time Complexity for inplace erasure on interval containers
+[[`T& erase(T& y, const P& x)`][__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
+[[interval_sets] [__Olgn__] [__a_Olgn__] [] [] [__Omlgnpm__] [] ]
+[[interval_maps] [__Olgn__] [__a_Olgn__] [__Olgn__] [__On__] [__Omlgnpm__] [__Omlgnpm__] ]
+]
+
+[endsect][/ Erasure of Objects]
+
+[section Erasure by Iterators]
+
+The next table shows the *itl* containers that erasure with iterators is
+available for. Erase on iterators erases always one `value` of `value_type`
+for an iterator pointing to it.
+So we erase
+
+* elements from __itl_sets__
+* element-value pairs from __itl_maps__
+* intervals from __itv_sets__ and
+* interval-value-pairs from __itv_maps__
+
+[table
+[[['*Erasure by iterators*]] [__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map] ]
+[[`void T::erase(iterator pos)`] [__aO1__] [__aO1__] [__aO1__] [__aO1__] ]
+[[`void T::erase(iterator first, iterator past)`] [__Ok__] [__Ok__] [__Ok__] [__Ok__] ]
+]
+
+Erasing by a single iterator need only ['*amortized constant time*].
+Erasing via a range of iterators `[fist, past)` is of ['*linear time*]
+in the number `k` of iterators in range `[fist, past)`.
+
+[endsect][/ Erasure by Iterators]
+
+[endsect][/ Erasure]
+
+

Added: sandbox/itl/libs/itl/doc/functions_insertion.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_insertion.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -0,0 +1,129 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[/ //= Insertion ===================================================================]
+[section Insertion]
+
+[section Synopsis][/ Insertion]
+
+[table
+[[['*Insertion*]][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map] ]
+[[`T& T::insert(const P&)`] [__ei] [__bp] [__e] [__b] ]
+[[`T& insert(T&, const P&)`] [__eiS] [__bpM] [__es] [__bm] ]
+[[`T& T::set(const P&)`] [ ] [__bp] [ ] [__b] ]
+]
+
+[h5 Insertion]
+
+The effects of ['*insertion*] implemented by `insert` and ['*addition*]
+implemented by `add` and `operator +=` are identical for all Set-types of
+the *itl*.
+
+For Map-types, `insert` provides the *stl* semantics of insertion in
+contrast to `add` and `operator +=`, that implement a generalized addition,
+that performs aggregations if key values collode or key intervals overlap.
+`insert` on Maps does not alter a maps content at the points, where
+the keys of the object to inserted overlap or collide with keys that
+are already in the map.
+
+
+[h5 Setting values]
+
+Overwriting values using `operator[]` like in
+``
+my_map[key] = new_value;
+``
+is not provided for __itv_maps__ because an `operator[]` is not
+implemented for them. As a substitute a function
+`T& T::set(const P&)` can be used to achieve the same effect:
+``
+my_map.set(make_pair(overwrite_this, new_value));
+``
+
+[endsect][/ Synopsis Insertion]
+
+[section Insertion]
+
+``
+// overload table for member function
+T& T::insert(const P&)
+
+insert | e i b p
+-------+--------
+ s | s
+ m | m
+ S | S
+ M | M
+``
+
+[table Time Complexity for member function insert on itl containers
+[[`T& T::add(const P&)`] [__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__]]
+[[__itl_set__] [__Olgn__] [] [] [] ]
+[[__itl_map__] [] [] [__Olgn__][] ]
+[[__itv_set__\n__sep_itv_set__][__Olgn__] [__a_Olgn__][] [] ]
+[[__spl_itv_set__] [__Olgn__] [__On__] [] [] ]
+[[__itv_map__\n__spl_itv_map__][] [] [__Olgn__][__On__] ]
+]
+
+``
+// overload tables for function
+T& insert(T&, const P&)
+
+element containers: interval containers:
+insert | e b s m insert | e i b p S M
+-------+-------- -------+------------
+ s | s s S | S S S
+ m | m m M | M M M
+``
+
+
+[table Time Complexity for inplace insertion on element containers
+[[`T& insert(T& y, const P& x)`][__ch_dom_t__][__ch_dom_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
+[[__itl_set__] [__Olgn__] [] [__Om__] [] ]
+[[__itl_map__] [] [__Olgn__] [] [__Om__] ]
+]
+
+Time complexity characteristics of inplace insertion for interval containers
+is given by this table.
+
+[table Time Complexity for inplace insertion on interval containers
+[[`T& insert(T& y, const P& x)`][][__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
+[[interval_sets][__itv_set__\n__sep_itv_set__][__Olgn__] [__a_Olgn__][] [] [__Omlgnpm__] [] ]
+[[] [__spl_itv_set__] [__Olgn__] [__On__] [] [] [__Omlgnpm__] [] ]
+[[interval_maps][] [] [] [__Olgn__][__On__] [] [__Omlgnpm__] ]
+]
+
+[endsect][/ Insertion]
+
+
+
+[section Setting values]
+
+``
+// overload table for member function
+T& T::set(const P&)
+
+set | b p
+----+----
+m | m
+M | M
+``
+
+[table Time Complexity for memberfunction `set`
+[[`T& set(T&, const P&)`] [domain_mapping_type] [interval_mapping_type] ]
+[[itl::map] [__Olgn__] [ ] ]
+[[interval_maps] [] [__a_Olgn__] ]
+]
+
+[endsect][/ Set]
+
+
+[endsect][/ Insertion]
+
+

Added: sandbox/itl/libs/itl/doc/functions_intersection.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_intersection.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -0,0 +1,205 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+[/ //= Intersection ============================================================]
+[section Intersection][/ Intersection]
+
+[section Synopsis][/ Intersection]
+
+[table
+[[Intersection] [__ch_itv_t__][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map]]
+[[`void T::add_intersection(T&, const P&)const`][ ] [__eiS][__eiS __bpM][ ] [ ] ]
+[[`T& operator &=(T&, const P&)`] [__i] [__eiS][__eiS __bpM][__es] [__bm] ]
+[[`T operator & (T, const P&)`\n`T operator & (const P&, T)`]
+ [__i] [__eiS][__eiS __bpM][__es] [__bm] ]
+]
+
+Functions and operators that implement ['*intersection*] on *itl* objects
+are given in the table above.
+
+[endsect][/ Synopsis Intersection]
+
+
+[section Member functions][/ Intersection]
+
+The admissable combinations of types for memberfunction
+`void T::add_intersection(T&, const P&)` can be summarized in the
+['*overload table*] below.
+Compared to other overload tables, placements of function arguments are
+different: Row headers denote type `T` of `*this` object.
+Columns headers denote type `P` of the second function argument.
+The table cells contain the arguments `T` of the intersections
+`result`, which is the functions first argument.
+
+``
+// overload table for
+void T::add_intersection(T& result, const P&)const
+
+add_intersection | e i b p
+-----------------+--------
+ s | s
+ m | m m
+ S | S S
+ M | M M M M
+``
+
+The next table contains complexity characteristics for member function `add_intersection`.
+
+[table Time Complexity for member function add_intersection on itl containers
+[[`void T::add_intersection(T&, const P&)const`] [__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__]]
+[[__itl_set__] [__Olgn__] [] [] [] ]
+[[__itl_map__] [__Olgn__] [] [__Olgn__] [] ]
+[[__itv_sets__] [__Olgn__] [__On__] [] [] ]
+[[__itv_maps__] [__Olgn__] [__On__] [__On__] [__On__] ]
+]
+
+[endsect][/ Member function Intersection]
+
+
+[section Inplace operators][/ Intersection]
+
+The overload tables below are giving admissable
+type combinations for the intersection `operator &=`.
+As for the overload patterns of /subtraction/
+intersectons are possible within Sets and Maps
+but also for Maps combined with /key objects/
+which are /key elements, intervals/ and /Sets of keys/.
+
+``
+// overload tables for
+T& operator &= (T&, const P&)
+
+element containers: interval containers:
+&= | e b s m &= | e i b p S M
+---+-------- ---+------------
+s | s s S | S S S
+m | m m m m M | M M M M M M
+``
+
+While intersection on maps can be viewed as
+a ['*generalisation of set intersection*]. The
+combination on Maps and Sets can be interpreted as
+a ['*generalized selection function*], because it
+allows to select parts of a maps using
+/key/ or /selection objects/.
+So we have a ['*generalized intersection*] for
+these overloads,
+
+``
+// (Generalized) intersection
+&= | e b s m &= | e i b p S M
+---+-------- ---+------------
+s | s s S | S S S
+m | m m M | M M M
+``
+
+[*and] a ['*selection by key objects*] here:
+
+``
+// Selection by key objects
+&= | e b s m &= | e i b p S M
+---+-------- ---+------------
+s | s s S | S S S
+m | m m M | M M M
+``
+
+The differences for the different functionalities
+of `operator &=` are on the Map-row of the
+tables. Both functionalities fall together
+for Sets in the function ['*set intersection*].
+
+Complexity characteristics for inplace intersection operations are
+given by the next tables where
+``
+n = y.iterative_size();
+m = x.iterative_size(); //if P is a container type
+``
+
+[table Time Complexity for inplace intersection on element containers
+[[`T& operator &= (T& y, const P& x)`][__ch_dom_t__][__ch_dom_mp_t__][__ch_itl_set__][__ch_itl_map__]]
+[[__itl_set__] [__Olgn__] [] [__Omlgn__] [] ]
+[[__itl_map__] [__Olgn__] [__Olgn__] [__Omlgn__] [__Omlgn__] ]
+]
+
+[table Time Complexity for inplace intersection on interval containers
+[[`T& operator &= (T& y, const P& x)`][__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
+[[interval_sets] [__Olgn__] [__On__] [] [] [__Omlgnpm__] [] ]
+[[interval_maps] [__Olgn__] [__On__] [__Olgn__] [__On__] [__Omlgnpm__] [__Omlgnpm__] ]
+]
+
+[endsect][/ Inplace operators Intersection]
+
+[section Infix operators][/ Intersection]
+
+For the *itl's* infix intersection the
+following overloads are available:
+
+``
+// overload tables for
+T operator & (T, const P&)
+T operator & (const P&, T)
+
+element containers: interval containers:
+& | e b s m & | e i b p S1 S2 S3 M1 M3
+---+-------- ---+---------------------------
+e | s m e | S1 S2 S3 M1 M3
+b | m i | i S1 S2 S3 M1 M3
+s | s s m b | M1 M3
+m | m m m m p | M1 M3
+ S1 | S1 S1 S1 S2 S3 M1 M3
+ S2 | S2 S2 S2 S2 S3 M1 M3
+ S3 | S3 S3 S3 S3 S3 M1 M3
+ M1 | M1 M1 M1 M1 M1 M1 M1 M1 M3
+ M3 | M3 M3 M3 M3 M3 M3 M3 M3 M3
+``
+
+To resolve ambiguities among interval containers
+the ['*finer*] container type is chosen as result type.
+
+Again, we can split up the overload tables of
+`operator &` in a part describing
+the ['*generalized intersection] on interval containers
+and a second part defining the
+['*selection by key object] functionality.
+
+``
+// (Generealized) intersection
+& | e b s m & | e i b p S1 S2 S3 M1 M3
+---+-------- ---+---------------------------
+e | s e | S1 S2 S3
+b | m i | i S1 S2 S3
+s | s s b | M1 M3
+m | m m p | M1 M3
+ S1 | S1 S1 S1 S2 S3
+ S2 | S2 S2 S2 S2 S3
+ S3 | S3 S3 S3 S3 S3
+ M1 | M1 M1 M1 M3
+ M3 | M3 M3 M3 M3
+``
+
+``
+// Selection by key objects
+& | e b s m & | e i b p S1 S2 S3 M1 M3
+---+-------- ---+---------------------------
+e | s m e | S1 S2 S3 M1 M3
+b | i | i S1 S2 S3 M1 M3
+s | s s m b |
+m | m m p |
+ S1 | S1 S1 S1 S2 S3 M1 M3
+ S2 | S2 S2 S2 S2 S3 M1 M3
+ S3 | S3 S3 S3 S3 S3 M1 M3
+ M1 | M1 M1 M1 M1 M1
+ M3 | M3 M3 M3 M3 M3
+``
+
+[endsect][/ Inplace operator Intersection]
+
+[endsect][/ Intersection]
+
+
+

Added: sandbox/itl/libs/itl/doc/functions_iterator_related.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_iterator_related.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -0,0 +1,64 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[/ //= Iterator related ===================================================================]
+[section Iterator related]
+
+
+[table
+[[['*Synopsis Complexities*]] [__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map] ]
+[[`J T::begin()`] [__O1__] [__O1__] [__O1__] [__O1__] ]
+[[`J T::end()`] [__O1__] [__O1__] [__O1__] [__O1__] ]
+[[`J T::rbegin()`] [__O1__] [__O1__] [__O1__] [__O1__] ]
+[[`J T::rend()`] [__O1__] [__O1__] [__O1__] [__O1__] ]
+[[`J T::lower_bound(const key_value&)`] [__Olgn__] [__Olgn__] [__Olgn__] [__Olgn__] ]
+[[`J T::upper_bound(const key_value&)`] [__Olgn__] [__Olgn__] [__Olgn__] [__Olgn__] ]
+[[`pair<J,J> T::equal_range(const key_value&)`] [__Olgn__] [__Olgn__] [__Olgn__] [__Olgn__] ]
+]
+
+[table
+[[['*Iterator related*]] [] ]
+[[`` iterator T::begin()
+const_iterator T::begin()const``] [Returns an iterator to the first value of the container.] ]
+[[`` iterator T::end()
+const_iterator T::end()const``] [Returns an iterator to a position `end()` after the last value of the container.]]
+[[`` reverse_iterator T::rbegin()
+const_reverse_iterator T::rbegin()const``] [Returns a reverse iterator to the last value of the container.] ]
+[[`` reverse_iterator T::rend()
+const_reverse_iterator T::rend()const``] [Returns a reverse iterator to a position `rend()` before the first value of the container.]]
+[[`` iterator T::lower_bound(const key_value& k)
+const_iterator T::lower_bound(const key_value& key)const``][Returns an iterator that points to the first element `first`, that does not compare less than `key_value key`.
+ `first` can be equal or greater than `key`, or it may overlap `key` for interval containers.]]
+[[`` iterator T::upper_bound(const key_value&)
+const_iterator T::upper_bound(const key_value&)const``] [Returns an iterator that points to the first element `past`, that compares greater than `key_value key`.]]
+[[``
+ pair<iterator,iterator> T::equal_range(const key_value& key)
+pair<const_iterator,const_iterator> T::equal_range(const key_value& key)const
+``
+]
+ [Returns a range `[first, past)` of iterators to all elements of the container
+ that compare neighter less than nor greater than `key_value key`.
+ For element containers __itl_set__ and __itl_map__, `equal_range`
+ contains at most one iterator pointing the element equal to `key`,
+ if it exitsts.
+
+ For interval containers `equal_range` contains iterators to all
+ intervals that overlap interval `key`.
+ ]]
+]
+
+[/
+Functions `begin`, `end`, `rbegin`, `rend` need ['*constant time*].
+Complexity of `lower_bound`, `upper_bound` and `equal_range` are
+['*logarithmic*] in the `iterative_size` of the container.
+]
+
+[endsect][/ Iterator related]
+
+

Added: sandbox/itl/libs/itl/doc/functions_range.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_range.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -0,0 +1,49 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[/ //= Range ===================================================================]
+[section Range]
+
+[table
+[[['*Range*]] [interval][__ch_itv_sets__][__ch_itv_maps__][condition] ]
+[[`interval<domain_type> hull(const T&)`] [ ] [__O1__] [__O1__][] ]
+[[`domain_type T::lower()const`] [__O1__] [__O1__] [__O1__][] ]
+[[`domain_type T::upper()const`] [__O1__] [__O1__] [__O1__][] ]
+[[`domain_type T::first()const`] [__O1__] [__O1__] [__O1__][`!is_continuous<domain_type>::value`]]
+[[`domain_type T::last()const`] [__O1__] [__O1__] [__O1__][`!is_continuous<domain_type>::value`]]
+]
+
+The table above shows the availability of functions
+`hull`, `lower`, `upper`, `first` and `last` on intervals
+and interval containers that are all of ['*constant time complexity*].
+Find the functions description and some simple properties below.
+
+[table
+[[['*Range*]] [Types] [Description] ]
+[[`interval<domain_type> hull(const T&)`] [__S __M] [`hull(x)` returns the smallest interval that contains all intervals of an interval container `x`.] ]
+[[`domain_type T::lower()const`] [__i __S __M][`x.lower()` returns the lower bound of an interval or interval container `x`.] ]
+[[`domain_type T::upper()const`] [__i __S __M][`x.upper()` returns the upper bound of an interval or interval container `x`.] ]
+[[`domain_type T::first()const`] [__i __S __M][`x.first()` returns the first element of an interval or interval container `x`.
+ `T::first()` ist defined for a non continuous `domain_type` only.] ]
+[[`domain_type T::last()const`] [__i __S __M][`x.last()` returns the last element of an interval or interval container `x`.
+ `T::last()` ist defined for a non continuous `domain_type` only.] ]
+]
+
+``
+// for interval_containers x:
+hull(x).lower() == x.lower()
+hull(x).upper() == x.upper()
+hull(x).first() == x.first()
+hull(x).last() == x.last()
+``
+
+
+[endsect][/ Range]
+
+

Added: sandbox/itl/libs/itl/doc/functions_selection.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_selection.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -0,0 +1,41 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[/ //= Selection ===================================================================]
+[section Selection]
+
+[table
+[[['*Selection*]] [__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map] [condition] ]
+[[`const_iterator T::find(const domain_type&)const`] [__Olgn__] [__Olgn__] [__Olgn__] [__Olgn__] [] ]
+[[`iterator T::find(const domain_type&)`] [ ] [ ] [__Olgn__] [__Olgn__] [] ]
+[[`codomain_type& operator[] (const domain_type&)`] [ ] [ ] [ ] [__Olgn__] [] ]
+[[`codomain_type operator() (const domain_type&)const`] [ ] [__Olgn__] [ ] [__Olgn__] [`is_total<T>::value`] ]
+]
+
+* All time *complexities* are ['*logarithmic*] in the containers `iteravive_size()`.
+* `operator()` is available for total maps only.
+
+
+[table
+[[['*Selection*]] [Types] [Description] ]
+[[`iterator T::find(const domain_type& x)`] [__s __m] [Searches the container for the element `x` and return an iterator to it, if `x` is found.
+ Otherwise `find` returns iterator `end()`.] ]
+[[`const_iterator T::find(const domain_type& x)const`] [__s __m] [Const version of `find` above.] ]
+[[`const_iterator T::find(const domain_type& x)const`] [__S __M] [For interval containers `find(x)` searches a key element `x` but returns an iterator to an interval
+ containing the element.] ]
+[[`codomain_type& operator[] (const domain_type& x)`] [__m ] [For the key element `x` the operator returns a reference to the mapped value.
+ A pair `std::pair(x,codomain_type())` will be inserted, of `x` is not found in the map.] ]
+[[`codomain_type operator() (const domain_type& x)const`][__M __m ] [Returns the mapped value for a key `x`. The operator is only available for ['*total*] maps. ] ]
+]
+
+
+
+[endsect][/ Selection]
+
+

Added: sandbox/itl/libs/itl/doc/functions_size.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_size.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -0,0 +1,48 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[/ //= Size ===================================================================]
+[section Size]
+
+[table
+[[['*Size*]] [interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map]]
+[[`size_type T::size()const`] [__O1__] [__On__] [__On__] [__O1__] [__O1__] ]
+[[`size_type T::cardinality()const`] [__O1__] [__On__] [__On__] [__O1__] [__O1__] ]
+[[`difference_type T::length()const`] [__O1__] [__On__] [__On__] [ ] [ ] ]
+[[`size_t T::iterative_size()const`] [ ] [__O1__] [__O1__] [__O1__] [__O1__] ]
+[[`size_t T::interval_count()const`] [ ] [__O1__] [__O1__] [ ] [ ] ]
+]
+
+For *itl* containers the single `size` function known from std containers
+branches into tree to five different members functions.
+The table above shows the types, `size` functions are implemented for,
+together with their *complexities*. Linear complexities __On__ refer to the container's
+`iterative_size`:
+``
+n = y.iterative_size()
+``
+
+The next table gives a short definition for the different size functions.
+
+[table
+[[['*Size*]] [Types] [Description] ]
+[[`size_t T::interval_count()const`] [__S __M] [The number of intervals of an interval container.] ]
+[[`size_t T::iterative_size()const`] [__S __M __s __m] [The number of objects in an itl container that can be iterated over.] ]
+[[`difference_type T::length()const`] [__i __S __M] [The length of an interval or the sum of lenghts of
+ an interval container's intervals, that's `domain_type` has a `difference_type`.] ]
+[[`size_type T::cardinality()const`][__i __S __M __s __m] [The number of elements of an interval or a container.
+ For continuous data types cardinality can be /infinite/.] ]
+[[`size_type T::size()const`] [__i __S __M __s __m] [The number of elements of an interval or a container,
+ which is also it's `cardinality`.] ]
+]
+
+
+[endsect][/ Size]
+
+

Added: sandbox/itl/libs/itl/doc/functions_streaming.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_streaming.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -0,0 +1,21 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[/ //= Streaming, conversion ===================================================================]
+[section Streaming, conversion]
+
+[table
+[[['*Streaming, conversion*]] [interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map] ]
+[[`std::basic_ostream operator << (...)`] [1] [1] [1] [1] [1] ]
+[[`std::string T::as_string()`] [1] [1] [1] [1] [1] ]
+]
+
+[endsect][/ Streaming, conversion]
+
+

Added: sandbox/itl/libs/itl/doc/functions_subtraction.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_subtraction.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -0,0 +1,147 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[/ //= Subtraction ============================================================]
+[section Subtraction]
+
+[section Synopsis]
+
+[table
+[[Subtraction] [__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map]]
+[[`T& T::subtract(const P&)`] [__ei] [__bp] [__e] [__b] ]
+[[`T& operator -=(T&, const P&)`] [__eiS][__eiS __bpM][__es] [__bm] ]
+[[`T operator - (T, const P&)`] [__eiS][__eiS __bpM][__es] [__bm] ]
+]
+
+Functions and operators that implement ['*Subtraction*] on *itl* objects
+are given in the table above.
+
+[endsect][/ Synopsis]
+
+
+
+[section Member functions][/ Subtraction]
+
+The admissable combinations of types for memberfunction
+`T& T::add(const P&)` can be summarized in the
+['*overload table*] below:
+
+``
+// overload table for
+T& T::subtract(const P&)
+
+subtract | e i b p
+---------+--------
+ s | s
+ m | m
+ S | S S
+ M | M M
+``
+
+The next table contains complexity characteristics for `subtract`.
+
+[table Time Complexity for member function subtract on itl containers
+[[`T& T::subtract(const P&)`] [__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__]]
+[[__itl_set__] [__Olgn__] [] [] [] ]
+[[__itl_map__] [__Olgn__] [] [__Olgn__] [] ]
+[[__itv_sets__] [__Olgn__] [__a_Olgn__] [] [] ]
+[[__itv_maps__] [__Olgn__] [__On__] [__Olgn__] [__On__] ]
+]
+
+[endsect][/ Member function Subtraction]
+
+
+[section Inplace operators][/ Subtraction]
+
+As presented in the overload tables for `operator -=`
+more type combinations are provided for subtraction than for
+addition.
+
+``
+// overload tables for
+T& operator -= (T&, const P&)
+
+element containers: interval containers:
+-= | e b s m -= | e i b p S M
+---+-------- ---+------------
+s | s s S | S S S
+m | m m m m M | M M M M M M
+``
+
+Subtraction provides the /reverse/ operation
+of an addition for these overloads,
+
+``
+// Reverse addition
+-= | e b s m -= | e i b p S M
+---+-------- ---+------------
+s | s s S | S S S
+m | m m M | M M M
+``
+
+[*and] you can erase parts of __itl_maps__ or __itv_maps__
+using
+/key values/, /intervals/ or /element or interval sets/
+using these overloads:
+
+``
+// Erasure by key objects
+-= | e b s m -= | e i b p S M
+---+-------- ---+------------
+s | s s S | S S S
+m | m m M | M M M
+``
+
+On Sets both function groups fall together
+as ['*set difference*].
+
+Complexity characteristics for inplace subtraction operations are
+given by the next tables where
+``
+n = y.iterative_size();
+m = x.iterative_size(); //if P is a container type
+``
+
+[table Time Complexity for inplace Subtraction on element containers
+[[`T& operator -= (T&, const P&)`][__ch_dom_t__][__ch_dom_mp_t__][__ch_itl_set__][__ch_itl_map__]]
+[[__itl_set__] [__Olgn__] [] [__Omlgn__] [] ]
+[[__itl_map__] [__Olgn__] [__Olgn__] [__Omlgn__] [__Omlgn__] ]
+]
+
+
+[table Time Complexity for inplace Subtraction on interval containers
+[[`T& operator -= (T&, const P&)`][__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
+[[interval_sets] [__Olgn__] [__a_Olgn__] [] [] [__Omlgnpm__] [] ]
+[[interval_maps] [__Olgn__] [__a_Olgn__] [__Olgn__] [__On__] [__Omlgnpm__] [__Omlgnpm__] ]
+]
+
+[endsect][/ Inplace operators Subtraction]
+
+
+[section Infix operators][/-Subtraction]
+
+The admissable overloads for the infix
+/subtraction/ `operator -`
+which is a non commutative
+operation
+is given by the next overload table.
+
+``
+// overload tables for
+T operator - (T, const P&)
+
+- | e b s m - | e i b p S M
+---+-------- ---+------------
+s | s s S | S S S
+m | m m m m M | M M M M M M
+``
+[endsect][/- Infix operator Subtraction]
+
+[endsect][/ Subtraction]
+

Added: sandbox/itl/libs/itl/doc/functions_symmetric_difference.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_symmetric_difference.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -0,0 +1,142 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[/ //= Symmetric Difference ===================================================]
+[section Symmetric Difference]
+
+[section Synopsis][/ Symmetric difference]
+
+[table
+[[Symmetric difference] [__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map] ]
+[[`T& T::flip(const P&)`] [__ei] [__bp] [__e] [__b] ]
+[[`T& operator ^=(T&, const P&)`] [__eiS] [__bpM] [__es] [__bm] ]
+[[`T operator ^ (T, const P&)`\n`T operator ^ (const P&, T)`][__eiS] [__bpM] [__es] [__bm] ]
+]
+
+Functions and operators that implement ['*symmetric difference*] on *itl* objects
+are given in the table above.
+
+[endsect][/ Synopsis Symmetric difference]
+
+[section Member functions][/ Symmetric difference]
+
+/Symmetric difference/ is implemented on interval containers
+by the memberfunction `T& T::flip(const P& operand)`.
+
+``
+y.flip(x)
+``
+
+deletes every element of `y`,
+if it is contained in `x`. Elements of
+`x` not contained in `y` are added.
+[/ paratract, surtract, symetract, topple, symmetric_subtract]
+
+The admissable combinations of types for memberfunction
+`T& T::flip(const P&)` can be summarized in the
+['*overload table*] below:
+
+``
+// overload table for
+T& T::flip(const P&)
+
+flip | e i b p
+-----+--------
+ s | s
+ m | m
+ S | S S
+ M | M M
+``
+
+The next table contains complexity characteristics for member functions `flip`.
+
+[table Time Complexity for member functions flip on itl containers
+[[`T& T::flip(const P&)`] [__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__]]
+[[__itl_set__] [__Olgn__] [] [] [] ]
+[[__itl_map__] [] [] [__Olgn__][] ]
+[[__itv_set__\n__sep_itv_set__][__Olgn__] [__On__] [] [] ]
+[[__spl_itv_set__] [__Olgn__] [__On__] [] [] ]
+[[__itv_map__\n__spl_itv_map__][] [] [__Olgn__][__On__] ]
+]
+
+[endsect][/ Member functions Symmetric difference]
+
+
+[section Inplace operators][/ Symmetric Difference]
+
+The overload tables below are giving admissable
+type combinations for `operator ^=`
+that implements ['*symmetric difference*].
+
+``
+// overload tables for
+T& operator ^= (T&, const P&)
+
+element containers: interval containers:
+^= | e b s m ^= | e i b p S M
+---+-------- ---+------------
+s | s s S | S S S
+m | m m M | M M M
+``
+
+
+Complexity characteristics for inplace operators
+that implement ['*symmetric difference*]
+are given by the next tables where
+``
+n = y.iterative_size();
+m = x.iterative_size(); //if P is a container
+``
+
+[table Time Complexity for inplace symmetric difference on element containers
+[[`T& operator &= (T& y, const P& x)`][__ch_dom_t__][__ch_dom_mp_t__][__ch_itl_set__][__ch_itl_map__]]
+[[__itl_set__] [__Olgn__] [] [__Omlgn__] [] ]
+[[__itl_map__] [__Olgn__] [__Olgn__] [__Omlgn__] [__Omlgn__] ]
+]
+
+[table Time Complexity for inplace symmetric difference on interval containers
+[[`T& operator &= (T&, const P&)`][__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
+[[interval_sets] [__Olgn__] [__On__] [] [] [__Omlgnpm__] [] ]
+[[interval_maps] [__Olgn__] [__On__] [__Olgn__] [__On__] [__Omlgnpm__] [__Omlgnpm__] ]
+]
+
+[endsect][/ Inplace operators Symmetric Difference]
+
+[section Infix operators][/ Symmetric Difference]
+
+For the infix version of symmetric difference the
+following overloads are available:
+
+``
+// overload tables for
+T operator ^ (T, const P&)
+T operator ^ (const P&, T)
+
+element containers: interval containers:
+^ | e b s m ^ | e i b p S1 S2 S3 M1 M3
+---+-------- ---+---------------------------
+e | s e | S1 S2 S3
+b | m i | S1 S2 S3
+s | s s b | M1 M3
+m | m m p | M1 M3
+ S1 | S1 S1 S1 S2 S3
+ S2 | S2 S2 S2 S2 S3
+ S3 | S3 S3 S3 S3 S3
+ M1 | M1 M1 M1 M3
+ M3 | M3 M3 M3 M3
+``
+
+To resolve ambiguities among interval containers
+the ['*finer*] container type is chosen as result type.
+
+[endsect][/ Infix operators Symmetric Difference]
+
+[endsect][/ Symmetric Difference]
+
+

Modified: sandbox/itl/libs/itl/doc/implementation.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/implementation.qbk (original)
+++ sandbox/itl/libs/itl/doc/implementation.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -164,7 +164,7 @@
 [table Time Complexity of Intersection:
 [[] [`P`] [][interval\nset][separate\ninterval\nset][split\ninterval\nset][interval\nmap][split\ninterval\nmap]]
 [/ 1operation 2granul. 3case 4itvset 5se_itvset 6sp_itvset 7itv_map 8sp_itvmap]
-[[`T& operator -=(T& object, const P& operand)`] [`T::element_type`] [] [__Olgn__] [__Olgn__] [__Olgn__] [__Olgn__] [__Olgn__] ]
+[[`T& operator &=(T& object, const P& operand)`] [`T::element_type`] [] [__Olgn__] [__Olgn__] [__Olgn__] [__Olgn__] [__Olgn__] ]
 [[] [`T::segment_type`] [best case] [__Olgn__] [__Olgn__] [__Olgn__] [__Olgn__] [__Olgn__] ]
 [[] [] [worst case] [__On__] [__On__] [__On__] [__On__] [__On__] ]
 [[] [`interval_sets`] [] [__Omlgnpm__] [__Omlgnpm__] [__Omlgnpm__] [__Omlgnpm__] [__Omlgnpm__] ]

Modified: sandbox/itl/libs/itl/doc/interface.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/interface.qbk (original)
+++ sandbox/itl/libs/itl/doc/interface.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -358,7 +358,7 @@
 sets and maps are provided.
 
 [table Itl Associated types
-[[Purpose][Aspect][Type][interval][interval\nsets][interval\nmaps][itl::set][itl::map][std::set][std::map]]
+[[Purpose][Aspect][Type][interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map][std::set][std::map]]
 [/[ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
 [/ interval itvset itvmap itl:set itl:map std:set std:map]
 [[['*Data*]] [__conceptual__][`domain_type`] [`D`] [`D`] [`D`] [`D`] [`D`] [ ] [ ]]
@@ -367,13 +367,13 @@
 [[ ] [ ][`segment_type`][`i<D,cp>`][`i<D,cp>`][`(i<D,cp>,C)`][ ] [ ] [ ] [ ]]
 [[ ] [['size] ][`size_type`] [`sz<D>`][`sz<D>`][`sz<D>`] [size_t] [size_t] [ ] [ ]]
 [[ ] [ ][`difference_type`] [`df<D>`][`df<D>`][`df<D>`] [size_t] [size_t] [ ] [ ]]
-[[ ] [ ][][interval][interval\nsets][interval\nmaps][itl::set][itl::map][std::set][std::map]]
+[[ ] [ ][][interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map][std::set][std::map]]
 [[['*Data*]] [__iterative__ ][`key_type`] [`D`][`i<D,cp>`][`i<D,cp>`] [`D`] [`D`] [`D`] [`D`]]
 [[ ] [ ][`data_type`] [`D`][`i<D,cp>`] [`C`] [`D`] [`C`] [`D`] [`D`]]
 [[ ] [ ][`value_type`] [`D`][`i<D,cp>`][`(i<D,cp>,C)`][`D`][`(D,C)`][`D`] [`(D,C)`]]
 [[ ] [ ][`interval_type`] [`i<D,cp>`][`i<D,cp>`][`i<D,cp>`] [ ] [ ] [ ] [ ]]
 [[ ] [['allocation]][`allocator_type`] [ ][`a<i<D,cp>>`][`a<(i<D,cp>, C)>`][`a<D>`][`a<(D,C)>`][`Ad`][`Av`]]
-[[ ] [ ][][interval][interval\nsets][interval\nmaps][itl::set][itl::map][std::set][std::map]]
+[[ ] [ ][][interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map][std::set][std::map]]
 [[['*Ordering*]] [__conceptual__][`domain_compare`] [`cp<D>`][`cp<D>`][`cp<D>`][`cp<D>`][`cp<D>`] [ ] [ ]]
 [[ ] [__iterative__ ][`key_compare`] [`cp<D>`] [`Xl`] [`Xl`] [`cp<D>`] [`cp<D>`] [`Cp`] [`Cp`]]
 [[ ] [ ][`interval_compare`] [ ] [`Xl`] [`Xl`] [ ] [ ] [ ] [ ]]
@@ -386,7 +386,7 @@
 
 [endsect][/ Associated Types]
 
-[section Function Matrix]
+[section Function Synopsis]
 
 In this section a single ['*matrix*] is given, that shows all ['*functions*]
 with shared names and identical or analogous semantics and their
@@ -398,7 +398,7 @@
 The ['*placeholder's*] purpose is to express the polymorphic
 usage of the functions. The ['*first column*] of the function matrix
 contains the signatures of the functions. Within these
-signatures `T` denotes a container type and `I,J` and `P`
+signatures `T` denotes a container type and `J` and `P`
 polymorphic argument and result types.
 
 Within the body of the matrix, sets of *boldface* placeholders denote
@@ -414,7 +414,7 @@
 [[Placeholder] [Argument types] [Description]]
 [[`T` ] [] [a container type]]
 [[`P` ] [] [polymorphical container argument type]]
-[[`I,J` ] [] [polymorphical iterator type]]
+[[`J` ] [] [polymorphical iterator type]]
 [[`V` ] [] [various types `V`, that do dot fall in the categories above]]
 [[1,2,... ] [] [number of implementations for this function]]
 [[A ] [] [implementation generated by compilers]]
@@ -431,78 +431,103 @@
 [/ memberref boost::itl::set::iterative_size `iterative_size`]
 
 [table Itl Interfaces
-[[T] [interval][interval\nsets][interval\nmaps][itl::set][itl::map][std::set][std::map]]
+[[T] [interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map][std::set][std::map]]
 [/ interval itvset itvmap itl:set itl:map std:set std:map]
-[[['*Construct, copy, destruct*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
+[[__biLConsCopyDest__] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
 [[`T::T()`] [1] [1] [1] [1] [1] [1] [1]]
 [[`T::T(const T&)`] [A] [1] [1] [1] [1] [1] [1]]
 [[`T::T(const P&)`] [ ] [__eiS] [__bpM] [ ] [ ] [ ] [ ]]
 [[`T::T(...)`] [3] [ ] [ ] [3] [3] [3] [3]]
 [[`T& T::operator=(const P&)`] [A] [__S] [__M] [1] [1] [1] [1]]
 [[`void T::swap(T&)`] [ ] [1] [1] [1] [1] [1] [1]]
-[[['*Emptieness, containment*]] [interval][interval\nsets][interval\nmaps][itl::set][itl::map][std::set][std::map]]
+
+[[__biLContainedness__] [interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map][std::set][std::map]]
 [[`void T::clear()`] [1] [1] [1] [1] [1] [1] [1]]
 [[`bool T::empty()const`] [1] [1] [1] [1] [1] [1] [1]]
 [[`bool T::contains(const P&)const`] [__ei] [__eiS][__eiS __bpM][__es] [__bm] [ ] [ ]]
 [[`bool T::contained_in(const P&)const`] [__i] [__S] [__M] [1] [1] [ ] [ ]]
-[[['*Equivalences and Orderings*]][interval][interval\nsets][interval\nmaps][itl::set][itl::map][std::set][std::map]]
+
+[[__biLEquivsOrderings__][interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map][std::set][std::map]]
 [[`bool operator == (const T&, const T&)`] [1] [1] [1] [1] [1] [1] [1]]
 [[`bool operator != (const T&, const T&)`] [1] [1] [1] [1] [1] [1] [1]]
-[[`bool is_element_equal(const P&, const P&)`] [ ] [__S] [__M] [1] [1] [ ] [ ]]
-[[`bool is_protonic_equal(const P&, const P&)`][ ] [ ] [__M] [ ] [1] [ ] [ ]]
 [[`bool operator < (const T&, const T&)`] [1] [1] [1] [1] [1] [1] [1]]
 [[`bool operator > (const T&, const T&)`] [1] [1] [1] [1] [1] [1] [1]]
 [[`bool operator <= (const T&, const T&)`] [1] [1] [1] [1] [1] [1] [1]]
 [[`bool operator >= (const T&, const T&)`] [1] [1] [1] [1] [1] [1] [1]]
-[[['*Size*]] [interval][interval\nsets][interval\nmaps][itl::set][itl::map][std::set][std::map]]
+[[`bool is_element_equal(const T&, const P&)`] [ ] [__S] [__M] [1] [1] [ ] [ ]]
+[[`bool is_element_less(const T&, const P&)`] [ ] [__S] [__M] [1] [1] [ ] [ ]]
+[[`bool is_element_greater(const T&, const P&)`][ ] [__S] [__M] [1] [1] [ ] [ ]]
+[[`bool is_protonic_equal(const T&, const P&)`][ ] [ ] [__M] [ ] [1] [ ] [ ]]
+
+[[__biLSize__] [interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map][std::set][std::map]]
 [[`size_type T::size()const`] [1] [1] [1] [1] [1] [1] [1]]
 [[`size_type T::cardinality()const`] [1] [1] [1] [1] [1] [ ] [ ]]
 [[`difference_type T::length()const`] [1] [1] [1] [ ] [ ] [ ] [ ]]
-[[`size_t T::iterative_size()const`] [1] [1] [1] [1] [1] [ ] [ ]]
-[[`size_t T::interval_count()const`] [1] [1] [1] [ ] [ ] [ ] [ ]]
-[[['*Range*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
+[[`size_t T::iterative_size()const`] [ ] [1] [1] [1] [1] [ ] [ ]]
+[[`size_t T::interval_count()const`] [ ] [1] [1] [ ] [ ] [ ] [ ]]
+
+[[__biLRange__] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
+[[`interval<domain_type> hull(const T&)`] [ ] [1] [1] [ ] [ ] [ ] [ ]]
 [[`domain_type T::lower()const`] [1] [1] [1] [ ] [ ] [ ] [ ]]
 [[`domain_type T::upper()const`] [1] [1] [1] [ ] [ ] [ ] [ ]]
 [[`domain_type T::first()const`] [1] [1] [1] [ ] [ ] [ ] [ ]]
 [[`domain_type T::last()const`] [1] [1] [1] [ ] [ ] [ ] [ ]]
-[[['*Selection*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
+
+[[__biLSelection__] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
 [[`J T::find(const domain_type&)`] [ ] [1] [1] [2] [2] [2] [2]]
 [[`codomain_type& operator[] (const domain_type&)`][ ] [ ] [] [ ] [1] [ ] [1]]
 [[`codomain_type operator() (const domain_type&)const`][ ][ ] [1] [ ] [1] [ ] [ ]]
-[[['*Addition*]] [interval][interval\nsets][interval\nmaps][itl::set][itl::map][std::set][std::map]]
+
+[[__biLAddition__] [interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map][std::set][std::map]]
 [[`T& T::add(const P&)`] [ ] [__ei] [__bp] [__e] [__b] [ ] [ ]]
-[[`T& operator +=( T&, const P&)`] [ ] [__eiS] [__bpM] [__es] [__bm] [ ] [ ]]
-[[`T operator + (const T&, const P&)`] [ ] [__eiS] [__bpM] [__es] [__bm] [ ] [ ]]
+[[`T& operator +=(T&, const P&)`] [ ] [__eiS] [__bpM] [__es] [__bm] [ ] [ ]]
+[[`T operator + (T, const P&)`\n`T operator + (const P&, T)`]
+ [ ] [__eiS] [__bpM] [__es] [__bm] [ ] [ ]]
 [[`T& operator |=( T&, const P&)`] [ ] [__eiS] [__bpM] [__es] [__bm] [ ] [ ]]
-[[`T operator | (const T&, const P&)`] [ ] [__eiS] [__bpM] [__es] [__bm] [ ] [ ]]
-[[['*Subtraction*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
+[[`T operator | (T, const P&)`\n`T operator | (const P&, T)`]
+ [ ] [__eiS] [__bpM] [__es] [__bm] [ ] [ ]]
+[[__biLSubtraction__] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
 [[`T& T::subtract(const P&)`] [ ] [__ei] [__bp] [__e] [__b] [ ] [ ]]
 [[`T& operator -=( T&, const P&)`] [ ] [__eiS][__eiS __bpM][__es] [__bm] [ ] [ ]]
-[[`T operator - (const T&, const P&)`] [ ] [__eiS][__eiS __bpM][__es] [__bm] [ ] [ ]]
-[[['*Insertion, erasure*]] [interval][interval\nsets][interval\nmaps][itl::set][itl::map][std::set][std::map]]
-[[`V T::insert(const P&)`] [ ] [__ei] [__bp] [__e] [__b] [__e] [__b]]
-[[`T& T::set(const P&)`] [ ] [ ] [__bp] [ ] [1] [ ] [ ]]
-[[`T& T::erase(const P&)`] [ ] [__eiS][__eiS __bpM][__e] [__b] [__e] [__b]]
-[/ [`V T::erase(const I&,...)`] [ ] [ ] [ ] [2] [2] [2] [2] ]
-[[['*Intersection, symmetric difference*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
+[[`T operator - (T, const P&)`] [ ] [__eiS][__eiS __bpM][__es] [__bm] [ ] [ ]]
+
+[[__biLInsertion__] [interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map][std::set][std::map]]
+[[`V T::insert(const P&)`] [ ] [__ei] [__bp] [__e] [__b] [__e] [__b]]
+[[`T& insert(T&, const P&)`] [ ] [__eiS] [__bpM] [__es] [__bm] [ ] [ ] ]
+[[`T& T::set(const P&)`] [ ] [ ] [__bp] [ ] [1] [ ] [ ] ]
+
+[[__biLErasure__] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
+[[`T& T::erase(const P&)`] [ ] [__ei ] [__ei __bp] [__e] [__bp] [__e] [__e]]
+[[`T& erase(T&, const P&)`] [ ] [__eiS][__eiS __bpM][__es] [__bm] [ ] [ ] ]
+[[`void T::erase(iterator)`] [ ] [1] [1] [1] [1] [1] [1] ]
+[[`void T::erase(iterator,iterator)`] [ ] [1] [1] [1] [1] [1] [1] ]
+
+[[__biLIntersection__] [interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map][std::set][std::map]]
 [[`void T::add_intersection(T&, const P&)const`][ ] [__eiS][__eiS __bpM][ ] [ ] [ ] [ ]]
 [[`T& operator &=(T&, const P&)`] [__i] [__eiS][__eiS __bpM][__es] [__bm] [ ] [ ]]
-[[`T operator & (const T&, const P&)`] [__i] [__eiS][__eiS __bpM][__es] [__bm] [ ] [ ]]
+[[`T operator & (T, const P&)`\n`T operator & (const P&, T)`]
+ [__i] [__eiS][__eiS __bpM][__es] [__bm] [ ] [ ]]
+
+[[__biLSymmetricDifference__] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
 [[`T& T::flip(const P&)`] [ ] [__ei] [__bp] [__e] [__b] [ ] [ ]]
 [[`T& operator ^=(T&, const P&)`] [ ] [__eiS] [__bpM] [__es] [__bm] [ ] [ ]]
-[[`T operator ^ (const T&, const P&)`] [ ] [__eiS] [__bpM] [__es] [__bm] [ ] [ ]]
-[[['*Iterator related*]] [interval][interval\nsets][interval\nmaps][itl::set][itl::map][std::set][std::map]]
+[[`T operator ^ (T, const P&)`\n`T operator ^ (const P&, T)`]
+ [ ] [__eiS] [__bpM] [__es] [__bm] [ ] [ ]]
+[[__biLIteratorRelated__] [interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map][std::set][std::map]]
 [[`J T::begin()`] [ ] [2] [2] [2] [2] [2] [2]]
 [[`J T::end()`] [ ] [2] [2] [2] [2] [2] [2]]
 [[`J T::rbegin()`] [ ] [2] [2] [2] [2] [2] [2]]
 [[`J T::rend()`] [ ] [2] [2] [2] [2] [2] [2]]
-[[`J T::lower_bound(const I&)`] [ ] [2] [2] [2] [2] [2] [2]]
-[[`J T::upper_bound(const I&)`] [ ] [2] [2] [2] [2] [2] [2]]
-[[['*Streaming, representation*]] [interval][interval\nsets][interval\nmaps][itl::set][itl::map][std::set][std::map]]
+[[`J T::lower_bound(const key_value&)`] [ ] [2] [2] [2] [2] [2] [2]]
+[[`J T::upper_bound(const key_value&)`] [ ] [2] [2] [2] [2] [2] [2]]
+[[`pair<J,J> T::equal_range(const key_value&)`][ ] [2] [2] [2] [2] [2] [2]]
+
+[[__biLStreaming__] [interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map][std::set][std::map]]
 [[`std::basic_ostream operator << (...)`] [1] [1] [1] [1] [1] [1] [1]]
 [[`std::string T::as_string()`] [1] [1] [1] [1] [1] [ ] [ ]]
 ]
 
-[endsect]
+[endsect][/ Function Synopsis]
+
+[endsect][/ Interface]
 
-[endsect]
\ No newline at end of file

Modified: sandbox/itl/libs/itl/doc/itl.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/itl.qbk (original)
+++ sandbox/itl/libs/itl/doc/itl.qbk 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -90,7 +90,7 @@
 [def __pabsorber__ [classref boost::itl::partial_absorber partial_absorber]]
 [def __penricher__ [classref boost::itl::partial_enricher partial_enricher]]
 [def __penrichers__ [classref boost::itl::partial_enricher partial_enrichers]]
-[def __tabsorber__ [classref boost::itl::total_absorber total_absorber]]
+[def __tabsorber__ [classref boost::itl::total_absorber total_absorber]]
 [def __tenricher__ [classref boost::itl::total_absorber total_enricher]]
 
 [def __itv_bse_set__ [classref boost::itl::interval_base_set interval_base_set]]
@@ -111,6 +111,39 @@
 [def __eiS [link element_type *e*] [link interval_type *i*] [link interval_set_types *S*]]
 [def __bpM [link element_mapping_type *b*] [link interval_mapping_type *p*] [link interval_map_types *M*]]
 
+[def __eiS_phs__ [link element_type placeholders]]
+[def __eiS_Phs__ [link element_type Placeholders]]
+
+[def __eibpsSmM__ [link element_type *e*] [link interval_type *i*]
+ [link element_mapping_type *b*] [link interval_mapping_type *p*]
+ [link itl_set_type *s*] [link interval_set_types *S*]
+ [link itl_map_type *m*] [link interval_map_types *M*]]
+
+[def __biLConsCopyDest__ [link boost_itl.function_reference.construct__copy__destruct ['*Construct, copy, destruct*]]]
+[def __biLContainedness__ [link boost_itl.function_reference.containment ['*Containedness*]]]
+[def __biLEquivsOrderings__ [link boost_itl.function_reference.equivalences_and_orderings ['*Equivalences and Orderings*]]]
+[def __biLSize__ [link boost_itl.function_reference.size ['*Size*]]]
+[def __biLRange__ [link boost_itl.function_reference.range ['*Range*]]]
+[def __biLSelection__ [link boost_itl.function_reference.selection ['*Selection*]]]
+[def __biLAddition__ [link boost_itl.function_reference.addition ['*Addition*]]]
+[def __biLSubtraction__ [link boost_itl.function_reference.subtraction ['*Subtraction*]]]
+[def __biLInsertion__ [link boost_itl.function_reference.insertion ['*Insertion*]]]
+[def __biLErasure__ [link boost_itl.function_reference.erasure ['*Erasure*]]]
+[def __biLIntersection__ [link boost_itl.function_reference.intersection ['*Intersection*]]]
+[def __biLSymmetricDifference__ [link boost_itl.function_reference.symmetric_difference ['*Symmetric difference*]]]
+[def __biLIteratorRelated__ [link boost_itl.function_reference.iterator_related ['*Iterator related*]]]
+[def __biLStreaming__ [link boost_itl.function_reference.streaming__conversion ['*Streaming, conversion*]]]
+
+[/ column headers]
+[def __ch_dom_t__ domain\ntype]
+[def __ch_itv_t__ interval\ntype]
+[def __ch_dom_mp_t__ domain\nmapping\ntype]
+[def __ch_itv_mp_t__ interval\nmapping\ntype]
+[def __ch_itv_sets__ interval\nsets]
+[def __ch_itv_maps__ interval\nmaps]
+[def __ch_itl_set__ interval\nsets]
+[def __ch_itl_map__ interval\nmaps]
+
 [def __bi_conceptual__ ['*conceptual*]]
 [def __conceptual__ conceptual]
 [def __Conceptual__ Conceptual]
@@ -119,8 +152,13 @@
 [def __iterative__ iterative]
 [def __Iterative__ Iterative]
 
+[def __O1__ ['O(1)]]
+[def __aO1__ ['amortized O(1)]]
 [def __On__ ['O(n)]]
+[def __Om__ ['O(m)]]
+[def __Ok__ ['O(k)]]
 [def __Olgn__ ['O(log n)]]
+[def __a_Olgn__ ['amortized\nO(log n)]]
 [def __Onlgn__ ['O(n log n)]]
 [def __Omlgn__ ['O(m log n)]]
 [def __Omlgnpm__ ['O(m log(n+m))]]
@@ -144,6 +182,7 @@
 [include concepts.qbk]
 [include semantics.qbk]
 [include interface.qbk]
+[include functions.qbk]
 [include implementation.qbk]
 [include acknowledgments.qbk]
 [xinclude itldoc.xml]

Modified: sandbox/itl/libs/itl/example/party_/party.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/party_/party.cpp (original)
+++ sandbox/itl/libs/itl/example/party_/party.cpp 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -59,7 +59,7 @@
 // implement operator += that performs a set union on overlap of intervals.
 typedef boost::itl::set<string> GuestSetT;
 
-// Time is the domain type the the split_interval_map. It's key values are therefore
+// Time is the domain type the split_interval_map. It's key values are therefore
 // time intervals: interval<Time>. The content is the set of names: GuestSetT.
 
 

Modified: sandbox/itl/libs/itl/example/user_groups_/user_groups.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/user_groups_/user_groups.cpp (original)
+++ sandbox/itl/libs/itl/example/user_groups_/user_groups.cpp 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -50,7 +50,7 @@
 // intervals.
 typedef boost::itl::set<string> MemberSetT;
 
-// boost::gregorian::date is the domain type the the interval map.
+// boost::gregorian::date is the domain type the interval map.
 // It's key values are therefore time intervals: interval<date>. The content
 // is the set of names: MemberSetT.
 typedef interval_map<date, MemberSetT> MembershipT;

Modified: sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp (original)
+++ sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp 2009-08-15 05:28:53 EDT (Sat, 15 Aug 2009)
@@ -15,6 +15,8 @@
 #include "../test_type_lists.hpp"
 #include "../test_value_maker.hpp"
 
+#include <boost/type_traits/is_same.hpp>
+
 #include <boost/itl/interval_set.hpp>
 #include <boost/itl/separate_interval_set.hpp>
 #include <boost/itl/split_interval_set.hpp>
@@ -28,182 +30,6 @@
 using namespace boost::itl;
 
 
-template<template<class, class>class IsCombinable,
- class LeftT, class RightT>
-void check_combinable(bool expected, const char* type_combi, const char* combi_text)
-{
- std::string type_combination = type_combi;
- std::string is_combi_text = combi_text;
- bool is_combinable = IsCombinable<LeftT,RightT>::value;
- std::string combination_result = is_combinable
- ? (is_combinable == expected ? type_combination : "expected: NOT "+is_combi_text+"<"+type_combination+">")
- : (is_combinable == expected ? type_combination : "expected: IS "+is_combi_text+"<"+type_combination+">");
-
- //BOOST_CHECK_EQUAL(expected, is_combinable);
- BOOST_CHECK_EQUAL(type_combination, combination_result);
-}
-
-template<template<class, class>class IsCombinable>
-void check_combine_pattern(const char* text,
- bool jS_e, bool jS_i, bool jS_b, bool jS_p, bool jS_jS, bool jS_zS, bool jS_sS, bool jS_jM, bool jS_sM,
- bool zS_e, bool zS_i, bool zS_b, bool zS_p, bool zS_jS, bool zS_zS, bool zS_sS, bool zS_jM, bool zS_sM,
- bool sS_e, bool sS_i, bool sS_b, bool sS_p, bool sS_jS, bool sS_zS, bool sS_sS, bool sS_jM, bool sS_sM,
- bool jM_e, bool jM_i, bool jM_b, bool jM_p, bool jM_jS, bool jM_zS, bool jM_sS, bool jM_jM, bool jM_sM,
- bool sM_e, bool sM_i, bool sM_b, bool sM_p, bool sM_jS, bool sM_zS, bool sM_sS, bool sM_jM, bool sM_sM,
- bool check_base_class = true
- )
-{
- typedef interval_set<int> jS;
- typedef separate_interval_set<int> zS;
- typedef split_interval_set<int> sS;
- typedef interval_map<int,double> jM;
- typedef split_interval_map<int,double> sM;
-
- typedef interval_base_set<jS,int> jT;
- typedef interval_base_set<zS,int> zT;
- typedef interval_base_set<sS,int> sT;
- typedef interval_base_map<jM,int,double> jN;
- typedef interval_base_map<sM,int,double> sN;
-
- typedef interval_set<int>::element_type S_e;
- typedef interval_set<int>::segment_type S_i;
-
- typedef interval_map<int,double>::element_type M_b;
- typedef interval_map<int,double>::segment_type M_p;
-
- //--------------------------------------------------------------------------
- check_combinable<IsCombinable, jS, S_e>(jS_e , "jS_e ", text);
- check_combinable<IsCombinable, jS, S_i>(jS_i , "jS_i ", text);
- check_combinable<IsCombinable, jS, M_b>(jS_b , "jS_b ", text);
- check_combinable<IsCombinable, jS, M_p>(jS_p , "jS_p ", text);
- check_combinable<IsCombinable, jS, jS >(jS_jS, "jS_jS", text);
- check_combinable<IsCombinable, jS, zS >(jS_zS, "jS_zS", text);
- check_combinable<IsCombinable, jS, sS >(jS_sS, "jS_sS", text);
- check_combinable<IsCombinable, jS, jM >(jS_jM, "jS_jM", text);
- check_combinable<IsCombinable, jS, sM >(jS_sM, "jS_sM", text);
- //--------------------------------------------------------------------------
- check_combinable<IsCombinable, zS, S_e>(zS_e , "zS_e ", text);
- check_combinable<IsCombinable, zS, S_i>(zS_i , "zS_i ", text);
- check_combinable<IsCombinable, zS, M_b>(zS_b , "zS_b ", text);
- check_combinable<IsCombinable, zS, M_p>(zS_p , "zS_p ", text);
- check_combinable<IsCombinable, zS, jS >(zS_jS, "zS_jS", text);
- check_combinable<IsCombinable, zS, zS >(zS_zS, "zS_zS", text);
- check_combinable<IsCombinable, zS, sS >(zS_sS, "zS_sS", text);
- check_combinable<IsCombinable, zS, jM >(zS_jM, "zS_jM", text);
- check_combinable<IsCombinable, zS, sM >(zS_sM, "zS_sM", text);
- //--------------------------------------------------------------------------
- check_combinable<IsCombinable, sS, S_e>(sS_e , "sS_e ", text);
- check_combinable<IsCombinable, sS, S_i>(sS_i , "sS_i ", text);
- check_combinable<IsCombinable, sS, M_b>(sS_b , "sS_b ", text);
- check_combinable<IsCombinable, sS, M_p>(sS_p , "sS_p ", text);
- check_combinable<IsCombinable, sS, jS >(sS_jS, "sS_jS", text);
- check_combinable<IsCombinable, sS, zS >(sS_zS, "sS_zS", text);
- check_combinable<IsCombinable, sS, sS >(sS_sS, "sS_sS", text);
- check_combinable<IsCombinable, sS, jM >(sS_jM, "sS_jM", text);
- check_combinable<IsCombinable, sS, sM >(sS_sM, "sS_sM", text);
- //--------------------------------------------------------------------------
- check_combinable<IsCombinable, jM, S_e>(jM_e , "jM_e ", text);
- check_combinable<IsCombinable, jM, S_i>(jM_i , "jM_i ", text);
- check_combinable<IsCombinable, jM, M_b>(jM_b , "jM_b ", text);
- check_combinable<IsCombinable, jM, M_p>(jM_p , "jM_p ", text);
- check_combinable<IsCombinable, jM, jS >(jM_jS, "jM_jS", text);
- check_combinable<IsCombinable, jM, zS >(jM_zS, "jM_zS", text);
- check_combinable<IsCombinable, jM, sS >(jM_sS, "jM_sS", text);
- check_combinable<IsCombinable, jM, jM >(jM_jM, "jM_jM", text);
- check_combinable<IsCombinable, jM, sM >(jM_sM, "jM_sM", text);
- //--------------------------------------------------------------------------
- check_combinable<IsCombinable, sM, S_e>(sM_e , "sM_e ", text);
- check_combinable<IsCombinable, sM, S_i>(sM_i , "sM_i ", text);
- check_combinable<IsCombinable, sM, M_b>(sM_b , "sM_b ", text);
- check_combinable<IsCombinable, sM, M_p>(sM_p , "sM_p ", text);
- check_combinable<IsCombinable, sM, jS >(sM_jS, "sM_jS", text);
- check_combinable<IsCombinable, sM, zS >(sM_zS, "sM_zS", text);
- check_combinable<IsCombinable, sM, sS >(sM_sS, "sM_sS", text);
- check_combinable<IsCombinable, sM, jM >(sM_jM, "sM_jM", text);
- check_combinable<IsCombinable, sM, sM >(sM_sM, "sM_sM", text);
- //--------------------------------------------------------------------------
-
- if(check_base_class)
- {
- //--------------------------------------------------------------------------
- check_combinable<IsCombinable, jT, S_e>(jS_e , "jT_e ", text);
- check_combinable<IsCombinable, jT, S_i>(jS_i , "jT_i ", text);
- check_combinable<IsCombinable, jT, M_b>(jS_b , "jT_b ", text);
- check_combinable<IsCombinable, jT, M_p>(jS_p , "jT_p ", text);
- check_combinable<IsCombinable, jT, jS >(jS_jS, "jT_jS", text);
- check_combinable<IsCombinable, jT, zS >(jS_zS, "jT_zS", text);
- check_combinable<IsCombinable, jT, sS >(jS_sS, "jT_sS", text);
- check_combinable<IsCombinable, jT, jM >(jS_jM, "jT_jM", text);
- check_combinable<IsCombinable, jT, sM >(jS_sM, "jT_sM", text);
- check_combinable<IsCombinable, jT, jT >(jS_jS, "jT_jT", text);
- check_combinable<IsCombinable, jT, zT >(jS_zS, "jT_zT", text);
- check_combinable<IsCombinable, jT, sT >(jS_sS, "jT_sT", text);
- check_combinable<IsCombinable, jT, jN >(jS_jM, "jT_jN", text);
- check_combinable<IsCombinable, jT, sN >(jS_sM, "jT_sN", text);
- //--------------------------------------------------------------------------
- check_combinable<IsCombinable, zT, S_e>(zS_e , "zT_e ", text);
- check_combinable<IsCombinable, zT, S_i>(zS_i , "zT_i ", text);
- check_combinable<IsCombinable, zT, M_b>(zS_b , "zT_b ", text);
- check_combinable<IsCombinable, zT, M_p>(zS_p , "zT_p ", text);
- check_combinable<IsCombinable, zT, jS >(zS_jS, "zT_jS", text);
- check_combinable<IsCombinable, zT, zS >(zS_zS, "zT_zS", text);
- check_combinable<IsCombinable, zT, sS >(zS_sS, "zT_sS", text);
- check_combinable<IsCombinable, zT, jM >(zS_jM, "zT_jM", text);
- check_combinable<IsCombinable, zT, sM >(zS_sM, "zT_sM", text);
- check_combinable<IsCombinable, zT, jT >(zS_jS, "zT_jT", text);
- check_combinable<IsCombinable, zT, zT >(zS_zS, "zT_zT", text);
- check_combinable<IsCombinable, zT, sT >(zS_sS, "zT_sT", text);
- check_combinable<IsCombinable, zT, jN >(zS_jM, "zT_jN", text);
- check_combinable<IsCombinable, zT, sN >(zS_sM, "zT_sN", text);
- //--------------------------------------------------------------------------
- check_combinable<IsCombinable, sT, S_e>(sS_e , "sT_e ", text);
- check_combinable<IsCombinable, sT, S_i>(sS_i , "sT_i ", text);
- check_combinable<IsCombinable, sT, M_b>(sS_b , "sT_b ", text);
- check_combinable<IsCombinable, sT, M_p>(sS_p , "sT_p ", text);
- check_combinable<IsCombinable, sT, jS >(sS_jS, "sT_jS", text);
- check_combinable<IsCombinable, sT, zS >(sS_zS, "sT_zS", text);
- check_combinable<IsCombinable, sT, sS >(sS_sS, "sT_sS", text);
- check_combinable<IsCombinable, sT, jM >(sS_jM, "sT_jM", text);
- check_combinable<IsCombinable, sT, sM >(sS_sM, "sT_sM", text);
- check_combinable<IsCombinable, sT, jT >(sS_jS, "sT_jT", text);
- check_combinable<IsCombinable, sT, zT >(sS_zS, "sT_zT", text);
- check_combinable<IsCombinable, sT, sT >(sS_sS, "sT_sT", text);
- check_combinable<IsCombinable, sT, jN >(sS_jM, "sT_jN", text);
- check_combinable<IsCombinable, sT, sN >(sS_sM, "sT_sN", text);
- //--------------------------------------------------------------------------
- check_combinable<IsCombinable, jN, S_e>(jM_e , "jN_e ", text);
- check_combinable<IsCombinable, jN, S_i>(jM_i , "jN_i ", text);
- check_combinable<IsCombinable, jN, M_b>(jM_b , "jN_b ", text);
- check_combinable<IsCombinable, jN, M_p>(jM_p , "jN_p ", text);
- check_combinable<IsCombinable, jN, jS >(jM_jS, "jN_jS", text);
- check_combinable<IsCombinable, jN, zS >(jM_zS, "jN_zS", text);
- check_combinable<IsCombinable, jN, sS >(jM_sS, "jN_sS", text);
- check_combinable<IsCombinable, jN, jM >(jM_jM, "jN_jM", text);//
- check_combinable<IsCombinable, jN, sM >(jM_sM, "jN_sM", text);//
- check_combinable<IsCombinable, jN, jT >(jM_jS, "jN_jT", text);
- check_combinable<IsCombinable, jN, zT >(jM_zS, "jN_zT", text);
- check_combinable<IsCombinable, jN, sT >(jM_sS, "jN_sT", text);
- check_combinable<IsCombinable, jN, jN >(jM_jM, "jN_jN", text);//
- check_combinable<IsCombinable, jN, sN >(jM_sM, "jN_sN", text);//
- //--------------------------------------------------------------------------
- check_combinable<IsCombinable, sN, S_e>(sM_e , "sN_e ", text);
- check_combinable<IsCombinable, sN, S_i>(sM_i , "sN_i ", text);
- check_combinable<IsCombinable, sN, M_b>(sM_b , "sN_b ", text);
- check_combinable<IsCombinable, sN, M_p>(sM_p , "sN_p ", text);
- check_combinable<IsCombinable, sN, jS >(sM_jS, "sN_jS", text);
- check_combinable<IsCombinable, sN, zS >(sM_zS, "sN_zS", text);
- check_combinable<IsCombinable, sN, sS >(sM_sS, "sN_sS", text);
- check_combinable<IsCombinable, sN, jM >(sM_jM, "sN_jM", text);
- check_combinable<IsCombinable, sN, sM >(sM_sM, "sN_sM", text);
- check_combinable<IsCombinable, sN, jT >(sM_jS, "sN_jT", text);
- check_combinable<IsCombinable, sN, zT >(sM_zS, "sN_zT", text);
- check_combinable<IsCombinable, sN, sT >(sM_sS, "sN_sT", text);
- check_combinable<IsCombinable, sN, jN >(sM_jM, "sN_jN", text);
- check_combinable<IsCombinable, sN, sN >(sM_sM, "sN_sN", text);
- }
-}
-
-
 BOOST_AUTO_TEST_CASE(casual_test)
 {
     typedef int T;
@@ -212,297 +38,7 @@
     typedef split_interval_map<int,int> SplitIntervalMapT;
     typedef interval_set<int> IntervalSetT;
     typedef split_interval_set<int> SplitIntervalSetT;
-
- //--------------------------------------------------------------------------
- // derivative
- //--------------------------------------------------------------------------
- // 1.1
- check_combine_pattern<is_intra_derivative>(
- "is_intra_derivative",
- // e i b p jS zS sS jM sM
- 1, 1, 0, 0, 0, 0, 0, 0, 0, // jS
- 1, 1, 0, 0, 0, 0, 0, 0, 0, // zS
- 1, 1, 0, 0, 0, 0, 0, 0, 0, // sS
- 0, 0, 1, 1, 0, 0, 0, 0, 0, // jM
- 0, 0, 1, 1, 0, 0, 0, 0, 0 // sM
- );
-
- //--------------------------------------------------------------------------
- // 1.2
- check_combine_pattern<is_cross_derivative>(
- "is_cross_derivative",
- // e i b p jS zS sS jM sM
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // jS
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // zS
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // sS
- 1, 1, 0, 0, 0, 0, 0, 0, 0, // jM
- 1, 1, 0, 0, 0, 0, 0, 0, 0 // sM
- );
-
- //--------------------------------------------------------------------------
- // 1.3
- check_combine_pattern<is_inter_derivative>(
- "is_inter_derivative",
- // e i b p jS zS sS jM sM
- 1, 1, 0, 0, 0, 0, 0, 0, 0, // jS
- 1, 1, 0, 0, 0, 0, 0, 0, 0, // zS
- 1, 1, 0, 0, 0, 0, 0, 0, 0, // sS
- 1, 1, 1, 1, 0, 0, 0, 0, 0, // jM
- 1, 1, 1, 1, 0, 0, 0, 0, 0 // sM
- );
-
- //--------------------------------------------------------------------------
- // inter interval_container
- //--------------------------------------------------------------------------
- // 2.1
- check_combine_pattern<is_intra_combinable>(
- "is_intra_combinable",
- // e i b p jS zS sS jM sM
- 0, 0, 0, 0, 1, 1, 1, 0, 0, // jS
- 0, 0, 0, 0, 1, 1, 1, 0, 0, // zS
- 0, 0, 0, 0, 1, 1, 1, 0, 0, // sS
- 0, 0, 0, 0, 0, 0, 0, 1, 1, // jM
- 0, 0, 0, 0, 0, 0, 0, 1, 1 // sM
- );
-
- //--------------------------------------------------------------------------
- // 2.2
- check_combine_pattern<is_cross_combinable>(
- "is_cross_combinable",
- // e i b p jS zS sS jM sM
- 0, 0, 0, 0, 0, 0, 0, 1, 1, // jS
- 0, 0, 0, 0, 0, 0, 0, 1, 1, // zS
- 0, 0, 0, 0, 0, 0, 0, 1, 1, // sS
- 0, 0, 0, 0, 1, 1, 1, 0, 0, // jM
- 0, 0, 0, 0, 1, 1, 1, 0, 0 // sM
- );
-
- //--------------------------------------------------------------------------
- // 2.3
- check_combine_pattern<is_inter_combinable>(
- "is_inter_combinable",
- // e i b p jS zS sS jM sM
- 0, 0, 0, 0, 1, 1, 1, 1, 1, // jS
- 0, 0, 0, 0, 1, 1, 1, 1, 1, // zS
- 0, 0, 0, 0, 1, 1, 1, 1, 1, // sS
- 0, 0, 0, 0, 1, 1, 1, 1, 1, // jM
- 0, 0, 0, 0, 1, 1, 1, 1, 1 // sM
- );
-
- //--------------------------------------------------------------------------
- // right
- //--------------------------------------------------------------------------
- // 3.1
- check_combine_pattern<is_interval_set_right_combinable>(
- "is_interval_set_right_combinable",
- // e i b p jS zS sS jM sM
- 1, 1, 0, 0, 1, 1, 1, 0, 0, // jS
- 1, 1, 0, 0, 1, 1, 1, 0, 0, // zS
- 1, 1, 0, 0, 1, 1, 1, 0, 0, // sS
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // jM
- 0, 0, 0, 0, 0, 0, 0, 0, 0 // sM
- );
-
- //--------------------------------------------------------------------------
- // 3.2
- check_combine_pattern<is_interval_map_right_intra_combinable>(
- "is_interval_map_right_intra_combinable",
- // e i b p jS zS sS jM sM
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // jS
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // zS
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // sS
- 0, 0, 1, 1, 0, 0, 0, 1, 1, // jM
- 0, 0, 1, 1, 0, 0, 0, 1, 1 // sM
- );
-
- //--------------------------------------------------------------------------
- // 3.3
- check_combine_pattern<is_interval_map_right_cross_combinable>(
- "is_interval_map_right_cross_combinable",
- // e i b p jS zS sS jM sM
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // jS
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // zS
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // sS
- 1, 1, 0, 0, 1, 1, 1, 0, 0, // jM
- 1, 1, 0, 0, 1, 1, 1, 0, 0 // sM
- );
-
- //--------------------------------------------------------------------------
- // 3.4
- check_combine_pattern<is_interval_map_right_inter_combinable>(
- "is_interval_map_right_inter_combinable",
- // e i b p jS zS sS jM sM
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // jS
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // zS
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // sS
- 1, 1, 1, 1, 1, 1, 1, 1, 1, // jM
- 1, 1, 1, 1, 1, 1, 1, 1, 1 // sM
- );
-
- //--------------------------------------------------------------------------
- // 3.5
- check_combine_pattern<is_right_intra_combinable>(
- "is_right_intra_combinable",
- // e i b p jS zS sS jM sM
- 1, 1, 0, 0, 1, 1, 1, 0, 0, // jS
- 1, 1, 0, 0, 1, 1, 1, 0, 0, // zS
- 1, 1, 0, 0, 1, 1, 1, 0, 0, // sS
- 0, 0, 1, 1, 0, 0, 0, 1, 1, // jM
- 0, 0, 1, 1, 0, 0, 0, 1, 1 // sM
- );
-
- //--------------------------------------------------------------------------
- // 3.6
- check_combine_pattern<is_right_inter_combinable>(
- "is_right_inter_combinable",
- // e i b p jS zS sS jM sM
- 1, 1, 0, 0, 1, 1, 1, 0, 0, // jS
- 1, 1, 0, 0, 1, 1, 1, 0, 0, // zS
- 1, 1, 0, 0, 1, 1, 1, 0, 0, // sS
- 1, 1, 1, 1, 1, 1, 1, 1, 1, // jM
- 1, 1, 1, 1, 1, 1, 1, 1, 1 // sM
- );
-
- //--------------------------------------------------------------------------
- // 3.7
- check_combine_pattern<combines_right_to_interval_set>(
- "combines_right_to_interval_set",
- // e i b p jS zS sS jM sM
- 0, 0, 0, 0, 1, 1, 1, 0, 0, // jS
- 0, 0, 0, 0, 1, 1, 1, 0, 0, // zS
- 0, 0, 0, 0, 1, 1, 1, 0, 0, // sS
- 0, 0, 0, 0, 1, 1, 1, 0, 0, // jM
- 0, 0, 0, 0, 1, 1, 1, 0, 0 // sM
- );
-
- //--------------------------------------------------------------------------
- // 3.8
- check_combine_pattern<combines_right_to_interval_map>(
- "combines_right_to_interval_map",
- // e i b p jS zS sS jM sM
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // jS
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // zS
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // sS
- 0, 0, 0, 0, 0, 0, 0, 1, 1, // jM
- 0, 0, 0, 0, 0, 0, 0, 1, 1 // sM
- );
-
- //--------------------------------------------------------------------------
- // 3.9
- check_combine_pattern<combines_right_to_interval_container>(
- "combines_right_to_interval_container",
- // e i b p jS zS sS jM sM
- 0, 0, 0, 0, 1, 1, 1, 0, 0, // jS
- 0, 0, 0, 0, 1, 1, 1, 0, 0, // zS
- 0, 0, 0, 0, 1, 1, 1, 0, 0, // sS
- 0, 0, 0, 0, 1, 1, 1, 1, 1, // jM
- 0, 0, 0, 0, 1, 1, 1, 1, 1 // sM
- );
-
- //--------------------------------------------------------------------------
- // 4.1
- check_combine_pattern<is_interval_set_companion>(
- "is_interval_set_companion",
- // e i b p jS zS sS jM sM
- 1, 1, 0, 0, 1, 1, 1, 0, 0, // jS
- 1, 1, 0, 0, 1, 1, 1, 0, 0, // zS
- 1, 1, 0, 0, 1, 1, 1, 0, 0, // sS
- 1, 1, 0, 0, 1, 1, 1, 0, 0, // jM
- 1, 1, 0, 0, 1, 1, 1, 0, 0 // sM
- );
-
- //--------------------------------------------------------------------------
- // 4.2 = 3.2 is_interval_map_right_intra_combinable
- check_combine_pattern<is_interval_map_companion>(
- "is_interval_map_companion",
- // e i b p jS zS sS jM sM
- 0, 1, 0, 0, 0, 0, 0, 0, 0, // jS
- 0, 1, 0, 0, 0, 0, 0, 0, 0, // zS
- 0, 1, 0, 0, 0, 0, 0, 0, 0, // sS
- 0, 0, 1, 1, 0, 0, 0, 1, 1, // jM
- 0, 0, 1, 1, 0, 0, 0, 1, 1 // sM
- );
-
- //--------------------------------------------------------------------------
- // 5.1
- check_combine_pattern<is_coarser_interval_set_companion>(
- "is_coarser_interval_set_companion",
- // e i b p jS zS sS jM sM
- 1, 1, 0, 0, 0, 0, 0, 0, 0, // jS
- 1, 1, 0, 0, 1, 0, 0, 0, 0, // zS
- 1, 1, 0, 0, 1, 1, 0, 0, 0, // sS
- 1, 1, 0, 0, 0, 0, 0, 0, 0, // jM
- 1, 1, 0, 0, 1, 1, 0, 0, 0, // sM
- false
- );
-
- //--------------------------------------------------------------------------
- // 5.2
- check_combine_pattern<is_coarser_interval_map_companion>(
- "is_coarser_interval_map_companion",
- // e i b p jS zS sS jM sM
- 0, 1, 0, 0, 0, 0, 0, 0, 0, // jS
- 0, 1, 0, 0, 0, 0, 0, 0, 0, // zS
- 0, 1, 0, 0, 0, 0, 0, 0, 0, // sS
- 0, 0, 1, 1, 0, 0, 0, 0, 0, // jM
- 0, 0, 1, 1, 0, 0, 0, 1, 0, // sM
- false
- );
-
- //--------------------------------------------------------------------------
- // 6.1
- check_combine_pattern<is_binary_interval_set_combinable>(
- "is_binary_interval_set_combinable",
- // e i b p jS zS sS jM sM
- 1, 1, 0, 0, 0, 0, 0, 0, 0, // jS
- 1, 1, 0, 0, 1, 0, 0, 0, 0, // zS
- 1, 1, 0, 0, 1, 1, 0, 0, 0, // sS
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // jM
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // sM
- false
- );
-
- //--------------------------------------------------------------------------
- // 6.2
- check_combine_pattern<is_binary_interval_map_combinable>(
- "is_binary_interval_map_combinable",
- // e i b p jS zS sS jM sM
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // jS
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // zS
- 0, 0, 0, 0, 0, 0, 0, 0, 0, // sS
- 0, 0, 1, 1, 0, 0, 0, 0, 0, // jM
- 0, 0, 1, 1, 0, 0, 0, 1, 0, // sM
- false
- );
-
- //--------------------------------------------------------------------------
- // 6.3
- check_combine_pattern<is_binary_intra_combinable>(
- "is_binary_intra_combinable",
- // e i b p jS zS sS jM sM
- 1, 1, 0, 0, 0, 0, 0, 0, 0, // jS
- 1, 1, 0, 0, 1, 0, 0, 0, 0, // zS
- 1, 1, 0, 0, 1, 1, 0, 0, 0, // sS
- 0, 0, 1, 1, 0, 0, 0, 0, 0, // jM
- 0, 0, 1, 1, 0, 0, 0, 1, 0, // sM
- false
- );
-
- //--------------------------------------------------------------------------
- // 6.4
- check_combine_pattern<is_binary_intra_combinable>(
- "is_binary_intra_combinable",
- // e i b p jS zS sS jM sM
- 1, 1, 0, 0, 0, 0, 0, 0, 0, // jS
- 1, 1, 0, 0, 1, 0, 0, 0, 0, // zS
- 1, 1, 0, 0, 1, 1, 0, 0, 0, // sS
- 0, 0, 1, 1, 0, 0, 0, 0, 0, // jM
- 0, 0, 1, 1, 0, 0, 0, 1, 0, // sM
- false
- );
-
- //--------------------------------------------------------------------------
- //--------------------------------------------------------------------------
-
 
+ const bool test = is_same<SplitIntervalSetT::key_type, SplitIntervalSetT::interval_type>::value;
+ BOOST_CHECK_EQUAL(test, true);
 }

Date view Thread view Subject view Author view