Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r66029 - sandbox/itl/libs/itl/doc
From: afojgo_at_[hidden]
Date: 2010-10-16 17:22:03


Author: jofaber
Date: 2010-10-16 17:22:02 EDT (Sat, 16 Oct 2010)
New Revision: 66029
URL: http://svn.boost.org/trac/boost/changeset/66029

Log:
Updated documentation: Modified function references, equivalences, orderings, size.
Text files modified:
   sandbox/itl/libs/itl/doc/functions_addition.qbk | 8 ++--
   sandbox/itl/libs/itl/doc/functions_cons_copy_dest.qbk | 26 ++++++------
   sandbox/itl/libs/itl/doc/functions_containedness.qbk | 76 +++++++++++++++++++++------------------
   sandbox/itl/libs/itl/doc/functions_equivs_orderings.qbk | 18 ++++----
   sandbox/itl/libs/itl/doc/functions_erasure.qbk | 12 +++---
   sandbox/itl/libs/itl/doc/functions_insertion.qbk | 8 ++--
   sandbox/itl/libs/itl/doc/functions_intersection.qbk | 8 ++--
   sandbox/itl/libs/itl/doc/functions_iterator_related.qbk | 2
   sandbox/itl/libs/itl/doc/functions_size.qbk | 22 ++++++-----
   sandbox/itl/libs/itl/doc/functions_subtraction.qbk | 10 ++--
   sandbox/itl/libs/itl/doc/functions_symmetric_difference.qbk | 8 ++--
   sandbox/itl/libs/itl/doc/interface.qbk | 4 +-
   12 files changed, 104 insertions(+), 98 deletions(-)

Modified: sandbox/itl/libs/itl/doc/functions_addition.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_addition.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_addition.qbk 2010-10-16 17:22:02 EDT (Sat, 16 Oct 2010)
@@ -81,8 +81,8 @@
 
 [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__][] ]
+[[__icl_set__] [__Olgn__] [] [] [] ]
+[[__icl_map__] [] [] [__Olgn__][] ]
 [[__itv_set__\n__sep_itv_set__][__Olgn__] [__a_Olgn__][] [] ]
 [[__spl_itv_set__] [__Olgn__] [__On__] [] [] ]
 [[__itv_map__\n__spl_itv_map__][] [] [__Olgn__][__On__] ]
@@ -187,8 +187,8 @@
 
 [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__] ]
+[[__icl_set__] [__Olgn__] [] [__Om__] [] ]
+[[__icl_map__] [] [__Olgn__] [] [__Om__] ]
 ]
 
 Time complexity characteristics of inplace addition for interval containers

Modified: sandbox/itl/libs/itl/doc/functions_cons_copy_dest.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_cons_copy_dest.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_cons_copy_dest.qbk 2010-10-16 17:22:02 EDT (Sat, 16 Oct 2010)
@@ -39,7 +39,7 @@
 [[['*Construct, copy, destruct*]] [Description] ]
 [[`T::T()`] [Object of type T is default constructed.] ]
 [[`T::T(const T& src)`] [Object of type T is copy constructed from object `src`. ] ]
-[[`T& T::operator=(const T&)` src][Assigns the contents of src to `*this` object. Returns a reference to the assigned object.] ]
+[[`T& T::operator=(const T& src)`][Assigns the contents of src to `*this` object. Returns a reference to the assigned object.] ]
 [[`void T::swap(T& src)`] [Swaps the content containers `*this` and `src` in constant time. ] ]
 ]
 
@@ -56,31 +56,31 @@
 m | m m M | M M M
 ``
 
-For an object `y` of type `T` and an argument `x` of type `P` let
+For an object `dst` of type `T` and an argument `src` of type `P` let
 ``
-n = iterative_size(y);
-m = iterative_size(x);
+n = iterative_size(dst);
+m = iterative_size(src);
 ``
 in the following tables.
 
 [table Time Complexity for overloaded constructors on element containers
-[[`T(const P& x)`][__ch_dom_t__][__ch_dom_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
-[[__icl_set__] [__Olgn__] [] [__Om__] [] ]
-[[__icl_map__] [] [__Olgn__] [] [__Om__] ]
+[[`T(const P& src)`][__ch_dom_t__][__ch_dom_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
+[[__icl_set__] [__Olgn__] [] [__Om__] [] ]
+[[__icl_map__] [] [__Olgn__] [] [__Om__] ]
 ]
 
 Time complexity characteristics of inplace insertion for interval containers
 is given by this table.
 
 [table Time Complexity for overloaded constructors on interval containers
-[[`T(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] [__O1__] [__O1__][] [] [__Om__] [] ]
-[[interval_maps] [] [] [__O1__][__O1__][] [__Om__] ]
+[[`T(const P& src)`] [__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
+[[interval_sets] [__O1__] [__O1__][] [] [__Om__] [] ]
+[[interval_maps] [] [] [__O1__][__O1__][] [__Om__] ]
 ]
 
 ``
 // overload tables for assignment
-T& operator = (const P& x)
+T& operator = (const P& src)
 
 interval containers:
 T \ P | S M
@@ -89,9 +89,9 @@
 M | M
 ``
 
-The assignment `T& operator = (const P& x)` is overloaded within interval containers.
+The assignment `T& operator = (const P& src)` is overloaded within interval containers.
 For all type combinations we have ['*linear time complexity*]
-in the maximum of the `iterative_size` of `y` and `x`.
+in the maximum of the `iterative_size` of `dst` and `src`.
 
 
 ['*Back to section . . .*]

Modified: sandbox/itl/libs/itl/doc/functions_containedness.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_containedness.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_containedness.qbk 2010-10-16 17:22:02 EDT (Sat, 16 Oct 2010)
@@ -1,5 +1,5 @@
 [/
- Copyright (c) 2008-2009 Joachim Faulhaber
+ Copyright (c) 2008-2010 Joachim Faulhaber
 
     Distributed under the Boost Software License, Version 1.0.
     (See accompanying file LICENSE_1_0.txt or copy at
@@ -12,10 +12,10 @@
 
 [table
 [[['*Containedness*]] [__ch_itvs__][__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] ]
+[[`bool T::empty()const`] [ ] [1] [1] [1] [1] ]
+[[`bool is_empty(const T&)`] [1] [1] [1] [1] [1] ]
+[[`bool contains(const T&, const P&)`\n
+ `bool within(const P&, const T&)`] [__ei] [__eiS][__eiS __bpM][__es] [__bm] ]
 ]
 
 This group of functions refers to ['*contain*]edness which should
@@ -25,37 +25,39 @@
 
 [table
 [[['*Containedness*]] [ /O(...)/ ][Description ] ]
-[[`void T::clear()`] [__On__][All content is removed from the container.] ]
-[[`bool T::empty()const`] [__O1__][Returns `true`, if the container is empty, `false` otherwise.] ]
-[[`bool T::contains(const P& sub)const`] [[link complexities_contains ['see below]]]
- [Returns `true`, if `*this` container contains object `sub`.] ]
-[[`bool T::contained_in(const P& super)const`][__Omlgn__][Returns `true`, if `*this` is contained in object `super`.] ]
-[[ ] [where] [ /n/` = this->iterative_size()`] ]
-[[ ] [ ] [ /m/` = super.iterative_size()`] ]
+[[`bool T::empty()const`\n
+ `bool is_empty(const T&)`] [__O1__][Returns `true`, if the container is empty, `false` otherwise.] ]
+[[`bool contains(const T&, const P&)`\n
+ `bool within(const P&, const T&)`] [[link complexities_contains ['see below]]]
+ [Returns `true`, if `super` container contains object `sub`.] ]
+[[ ] [where] [ /n/` = iterative_size(sub)`] ]
+[[ ] [ ] [ /m/` = iterative_size(super)`] ]
 ]
 
 ``
 // overload tables for
-bool T::contains(const P& src)
+bool contains(const T& super, const P& sub)
+bool within(const P& sub, const T& super)
 
-element containers: interval containers:
-contains| e b s m contains| e i b p S M
---------+-------- --------+------------
- s | 1 1 S | 1 1 1
- m | 1 1 1 1 M | 1 1 1 1 1 1
+element containers: interval containers:
+T\P| e b s m T\P| e i b p S M
+--------+--- --------+-------
+ s | 1 1 S | 1 1 1
+ m | 1 1 1 1 M | 1 1 1 1 1 1
 ``
 
-The overloads of `bool T::contains(const P& src)` cover various kinds
+The overloads of `bool contains(const T& super, const P& sup)`
+cover various kinds
 of containedness. We can group them into a part (1) that checks
 if an element, a segment or a container /of same kinds/ is contained in
 an element or interval container
 
 ``
 // (1) containedness of elements, segments or containers of same kind
-contains| e b s m contains| e i b p S M
---------+-------- --------+------------
- s | 1 1 S | 1 1 1
- m | 1 1 M | 1 1 1
+T\P| e b s m T\P| e i b p S M
+---+-------- ---+------------
+ s | 1 1 S | 1 1 1
+ m | 1 1 M | 1 1 1
 ``
 
 and another part (2) that checks the containedness of
@@ -63,10 +65,10 @@
 
 ``
 // (2) containedness of key objects.
-contains| e b s m contains| e i b p S M
---------+-------- --------+------------
- s | 1 1 S | 1 1 1
- m | 1 1 M | 1 1 1
+T\P| e b s m T\P| e i b p S M
+---+-------- ---+------------
+ s | 1 1 S | 1 1 1
+ m | 1 1 M | 1 1 1
 ``
 
 For type *m* = __icl_map__,
@@ -79,32 +81,34 @@
 ['*interval set*], can be ['*key objects*].
 
 [#complexities_contains] Complexity characteristics for function
-`bool T::contains(const P& sub)const`
+`bool contains(const T& super, const P& sub)const`
 are given by the next tables where
 ``
-n = this->iterative_size();
-m = sub.iterative_size(); //if P is a container type
+n = iterative_size(super);
+m = iterative_size(sub); //if P is a container type
 ``
 
 [table Time Complexity for function contains on element containers
-[[`bool T::contains(const P& sub)const`][__ch_dom_t__][__ch_dom_mp_t__][__ch_itl_set__][__ch_itl_map__]]
+[[`bool contains(const T& super, const P& sub)`\n
+ `bool within(const P& sub, const T& super)`][__ch_dom_t__][__ch_dom_mp_t__][__ch_itl_set__][__ch_itl_map__]]
 [[__icl_set__] [__Olgn__] [] [__Omlgn__] [] ]
 [[__icl_map__] [__Olgn__] [__Olgn__] [__Omlgn__] [__Omlgn__] ]
 ]
 
 
-[table Time Complexity for function contains on interval containers
-[[`bool T::contains(const P& sub)const`][][__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
+[table Time Complexity for functions contains and within on interval containers
+[[`bool contains(const T& super, const P& sub)`\n
+ `bool within(const P& sub, const T& super)`][][__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__][__ch_itv_sets__][__ch_itv_maps__]]
 [[interval_sets] [__itv_set__][__Olgn__] [__Olgn__] [] [] [__Omlgn__] [] ]
 [[] [__sep_itv_set__\n__spl_itv_set__][__Olgn__] [__On__ ] [] [] [__Omlgn__] [] ]
 [[interval_maps] [__itv_map__][__Olgn__] [__Olgn__] [__Olgn__] [__Olgn__] [__Omlgn__] [__Omlgn__] ]
 [[] [__spl_itv_map__][__Olgn__] [__On__ ] [__Olgn__] [__On__] [__Omlgn__] [__Omlgn__] ]
 ]
 
-All tests of containedness of containers in containers
+All overloads of containedness of containers in containers
 ``
-bool T::contains(const P& sub_container)const
-bool T::contained_in(const P& super_container)const
+bool contains(const T& super, const P& sub)
+bool within(const P& sub, const T& super)
 ``
 are of ['*loglinear*] time: __Omlgn__.
 If both containers have same iterative_sizes so that /m = n/

Modified: sandbox/itl/libs/itl/doc/functions_equivs_orderings.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_equivs_orderings.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_equivs_orderings.qbk 2010-10-16 17:22:02 EDT (Sat, 16 Oct 2010)
@@ -1,5 +1,5 @@
 [/
- Copyright (c) 2008-2009 Joachim Faulhaber
+ Copyright (c) 2008-2010 Joachim Faulhaber
 
     Distributed under the Boost Software License, Version 1.0.
     (See accompanying file LICENSE_1_0.txt or copy at
@@ -25,8 +25,8 @@
 [[`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] ]
+[[['Distinct Equality]] [ ] [ ] [ ] [ ] [ ] ]
+[[`bool is_distinct_equal(const T&, const P&)`][ ] [ ] [__M] [ ] [1] ]
 ]
 
 
@@ -36,12 +36,12 @@
 [section Lexicographical Ordering][/ Equivalences and Orderings]
 
 All common equality and compare operators are defined for
-all objects of the *itl*. For all *itl* containers
+all objects of the *icl*. For all *icl* 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*
+Equality and compare operators are defined for all *icl*
 objects but there are no overloads between different types.
 
 Containers of different segmentation are different,
@@ -97,12 +97,12 @@
 
 [endsect]
 
-[section Protonic Equality][/ Equivalences and Orderings]
+[section Distinct Equality]
 
-['*Protonic Equality*] is an equality predicate that is available
-for __itl_maps__ and __itv_maps__. It yields true, if
+['*Distinct Equality*] is an equality predicate that is available
+for __icl_maps__ and __itv_maps__. It yields true, if
 two maps are sequential element equal except for value
-pairs whose associated values are neutral elements.
+pairs whose associated values are identity elements.
 
 [*Complexity] is linear in the `iterative_size` of the
 larger container to compare.

Modified: sandbox/itl/libs/itl/doc/functions_erasure.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_erasure.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_erasure.qbk 2010-10-16 17:22:02 EDT (Sat, 16 Oct 2010)
@@ -55,8 +55,8 @@
 
 [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__] [] ]
+[[__icl_set__] [__Olgn__] [] [] [] ]
+[[__icl_map__] [__Olgn__] [] [__Olgn__] [] ]
 [[__itv_sets__] [__Olgn__] [__a_Olgn__] [] [] ]
 [[__itv_maps__] [__Olgn__] [__On__] [__Olgn__] [__On__] ]
 ]
@@ -117,8 +117,8 @@
 
 [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__] ]
+[[__icl_set__] [__Olgn__] [] [__Omlgn__] [] ]
+[[__icl_map__] [__Olgn__] [__Olgn__] [__Omlgn__] [__Omlgn__] ]
 ]
 
 
@@ -137,8 +137,8 @@
 for an iterator pointing to it.
 So we erase
 
-* elements from __itl_sets__
-* element-value pairs from __itl_maps__
+* elements from __icl_sets__
+* element-value pairs from __icl_maps__
 * intervals from __itv_sets__ and
 * interval-value-pairs from __itv_maps__
 

Modified: sandbox/itl/libs/itl/doc/functions_insertion.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_insertion.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_insertion.qbk 2010-10-16 17:22:02 EDT (Sat, 16 Oct 2010)
@@ -64,8 +64,8 @@
 
 [table Time Complexity for member function insert on itl containers
 [[`T& T::insert(const P&)`] [__ch_dom_t__][__ch_itv_t__][__ch_dom_mp_t__][__ch_itv_mp_t__]]
-[[__itl_set__] [__Olgn__] [] [] [] ]
-[[__itl_map__] [] [] [__Olgn__][] ]
+[[__icl_set__] [__Olgn__] [] [] [] ]
+[[__icl_map__] [] [] [__Olgn__][] ]
 [[__itv_set__\n__sep_itv_set__][__Olgn__] [__a_Olgn__][] [] ]
 [[__spl_itv_set__] [__Olgn__] [__On__] [] [] ]
 [[__itv_map__\n__spl_itv_map__][] [] [__Olgn__][__On__] ]
@@ -85,8 +85,8 @@
 
 [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__] ]
+[[__icl_set__] [__Olgn__] [] [__Om__] [] ]
+[[__icl_map__] [] [__Olgn__] [] [__Om__] ]
 ]
 
 Time complexity characteristics of inplace insertion for interval containers

Modified: sandbox/itl/libs/itl/doc/functions_intersection.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_intersection.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_intersection.qbk 2010-10-16 17:22:02 EDT (Sat, 16 Oct 2010)
@@ -78,8 +78,8 @@
 
 [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__] [] ]
+[[__icl_set__] [__Olgn__] [] [] [] ]
+[[__icl_map__] [__Olgn__] [] [__Olgn__] [] ]
 [[__itv_sets__] [__Olgn__] [__On__] [] [] ]
 [[__itv_maps__] [__Olgn__] [__On__] [__On__] [__On__] ]
 ]
@@ -148,8 +148,8 @@
 
 [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__] ]
+[[__icl_set__] [__Olgn__] [] [__Omlgn__] [] ]
+[[__icl_map__] [__Olgn__] [__Olgn__] [__Omlgn__] [__Omlgn__] ]
 ]
 
 [table Time Complexity for inplace intersection on interval containers

Modified: sandbox/itl/libs/itl/doc/functions_iterator_related.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_iterator_related.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_iterator_related.qbk 2010-10-16 17:22:02 EDT (Sat, 16 Oct 2010)
@@ -44,7 +44,7 @@
 ]
     [Returns a range `[first, past)` of iterators to all elements of the container
      that compare neither less than nor greater than `key_type key`.
- For element containers __itl_set__ and __itl_map__, `equal_range`
+ For element containers __icl_set__ and __icl_map__, `equal_range`
      contains at most one iterator pointing the element equal to `key`,
      if it exists.
      

Modified: sandbox/itl/libs/itl/doc/functions_size.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_size.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_size.qbk 2010-10-16 17:22:02 EDT (Sat, 16 Oct 2010)
@@ -12,11 +12,12 @@
 
 [table
 [[['*Size*]] [__ch_itvs__][__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__] [ ] [ ] ]
+[[`size_type T::size()const`\n
+ `size_type size(const T&)`] [__O1__] [__On__] [__On__] [__O1__] [__O1__] ]
+[[`size_type cardinality(const T&)`] [__O1__] [__On__] [__On__] [__O1__] [__O1__] ]
+[[`difference_type length(const T&)`] [__O1__] [__On__] [__On__] [ ] [ ] ]
+[[`size_type iterative_size(const T&)`] [ ] [__O1__] [__O1__] [__O1__] [__O1__] ]
+[[`size_type interval_count(const T&)`] [ ] [__O1__] [__O1__] [ ] [ ] ]
 ]
 
 For *itl* containers the single `size` function known from std containers
@@ -32,13 +33,14 @@
 
 [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 lengths of
+[[`size_type interval_count(const T&)`] [__S __M] [The number of intervals of an interval container.] ]
+[[`size_type iterative_size(const T&)`] [__S __M __s __m] [The number of objects in an itl container that can be iterated over.] ]
+[[`difference_type length(const T&)`] [__i __S __M] [The length of an interval or the sum of lengths 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.
+[[`size_type cardinality(const T&)`][__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,
+[[`size_type T::size()const`\n
+ `size_type size(const T&)`] [__i __S __M __s __m] [The number of elements of an interval or a container,
                                                            which is also it's `cardinality`.] ]
 ]
 

Modified: sandbox/itl/libs/itl/doc/functions_subtraction.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_subtraction.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_subtraction.qbk 2010-10-16 17:22:02 EDT (Sat, 16 Oct 2010)
@@ -67,8 +67,8 @@
 
 [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__] [] ]
+[[__icl_set__] [__Olgn__] [] [] [] ]
+[[__icl_map__] [__Olgn__] [] [__Olgn__] [] ]
 [[__itv_sets__] [__Olgn__] [__a_Olgn__] [] [] ]
 [[__itv_maps__] [__Olgn__] [__On__] [__Olgn__] [__On__] ]
 ]
@@ -104,7 +104,7 @@
 m | m m M | M M M
 ``
 
-[*and] you can erase parts of __itl_maps__ or __itv_maps__
+[*and] you can erase parts of __icl_maps__ or __itv_maps__
 using
 /key values/, /intervals/ or /element or interval sets/
 using these overloads:
@@ -129,8 +129,8 @@
 
 [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__] ]
+[[__icl_set__] [__Olgn__] [] [__Omlgn__] [] ]
+[[__icl_map__] [__Olgn__] [__Olgn__] [__Omlgn__] [__Omlgn__] ]
 ]
 
 

Modified: sandbox/itl/libs/itl/doc/functions_symmetric_difference.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_symmetric_difference.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_symmetric_difference.qbk 2010-10-16 17:22:02 EDT (Sat, 16 Oct 2010)
@@ -68,8 +68,8 @@
 
 [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__][] ]
+[[__icl_set__] [__Olgn__] [] [] [] ]
+[[__icl_map__] [] [] [__Olgn__][] ]
 [[__itv_set__\n__sep_itv_set__][__Olgn__] [__On__] [] [] ]
 [[__spl_itv_set__] [__Olgn__] [__On__] [] [] ]
 [[__itv_map__\n__spl_itv_map__][] [] [__Olgn__][__On__] ]
@@ -106,8 +106,8 @@
 
 [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__] ]
+[[__icl_set__] [__Olgn__] [] [__Omlgn__] [] ]
+[[__icl_map__] [__Olgn__] [__Olgn__] [__Omlgn__] [__Omlgn__] ]
 ]
 
 [table Time Complexity for inplace symmetric difference on interval containers

Modified: sandbox/itl/libs/itl/doc/interface.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/interface.qbk (original)
+++ sandbox/itl/libs/itl/doc/interface.qbk 2010-10-16 17:22:02 EDT (Sat, 16 Oct 2010)
@@ -458,8 +458,8 @@
 [[`size_type size(const T&)`] [1] [1] [1] [1] [1] ]
 [[`size_type cardinality(const T&)`] [1] [1] [1] [1] [1] ]
 [[`difference_type length(const T&)`] [1] [1] [1] [ ] [ ] ]
-[[`size_t iterative_size(const T&)`] [ ] [1] [1] [1] [1] ]
-[[`size_t interval_count(const T&)`] [ ] [1] [1] [ ] [ ] ]
+[[`size_type iterative_size(const T&)`] [ ] [1] [1] [1] [1] ]
+[[`size_type interval_count(const T&)`] [ ] [1] [1] [ ] [ ] ]
                                                                                             
 [[__biLSelection__ ] [ ] [ ] [ ] [ ] [ ] ]
 [[`J T::find(const domain_type&)`] [ ] [1] [1] [2] [2] ]


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk