Subject: [Boost-commit] svn:boost r66205 - in sandbox/itl: boost/itl/concept boost/itl/type_traits libs/itl/doc libs/itl/example/dynamic_interval_ libs/itl/example/interval_container_ libs/itl/example/static_interval_
From: afojgo_at_[hidden]
Date: 2010-10-26 15:27:18
Author: jofaber
Date: 2010-10-26 15:27:09 EDT (Tue, 26 Oct 2010)
New Revision: 66205
URL: http://svn.boost.org/trac/boost/changeset/66205
Log:
Updated documentation: Added sections for additional interval functions.
Added:
sandbox/itl/libs/itl/doc/functions_interval_construct.qbk (contents, props changed)
sandbox/itl/libs/itl/doc/functions_interval_misc.qbk (contents, props changed)
sandbox/itl/libs/itl/doc/functions_interval_orderings.qbk (contents, props changed)
Text files modified:
sandbox/itl/boost/itl/concept/interval.hpp | 6 ++--
sandbox/itl/boost/itl/type_traits/is_discrete.hpp | 11 ++++++++++
sandbox/itl/libs/itl/doc/examples.qbk | 17 ++++++++++++++
sandbox/itl/libs/itl/doc/functions.qbk | 4 +++
sandbox/itl/libs/itl/doc/functions_equivs_orderings.qbk | 27 +++++++++++++++++++++++++
sandbox/itl/libs/itl/doc/icl.qbk | 19 +++++++++++++++-
sandbox/itl/libs/itl/doc/implementation.qbk | 6 ++--
sandbox/itl/libs/itl/doc/interface.qbk | 43 +++++++++++++++++++++++++++++++++++++--
sandbox/itl/libs/itl/doc/introduction.qbk | 24 ++++++++++++++-------
sandbox/itl/libs/itl/example/dynamic_interval_/dynamic_interval.cpp | 10 ++++----
sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp | 8 +++---
sandbox/itl/libs/itl/example/static_interval_/static_interval.cpp | 8 +++---
12 files changed, 150 insertions(+), 33 deletions(-)
Modified: sandbox/itl/boost/itl/concept/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/interval.hpp (original)
+++ sandbox/itl/boost/itl/concept/interval.hpp 2010-10-26 15:27:09 EDT (Tue, 26 Oct 2010)
@@ -13,7 +13,7 @@
#include <boost/mpl/and.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/not.hpp>
-#include <boost/detail/is_incrementable.hpp>
+//CL #include <boost/detail/is_incrementable.hpp>
#include <boost/itl/detail/design_config.hpp>
#include <boost/itl/type_traits/unit_element.hpp>
#include <boost/itl/type_traits/identity_element.hpp>
@@ -378,7 +378,7 @@
{
return typename
Type::bounded_domain_type(upper(object),
- object.bounds().right());
+ object.bounds().right());
}
template<class Type>
@@ -454,7 +454,7 @@
}
//==============================================================================
-//= Orederings, containedness (non empty)
+//= Orderings, containedness (non empty)
//==============================================================================
namespace non_empty
{
Modified: sandbox/itl/boost/itl/type_traits/is_discrete.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_discrete.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_discrete.hpp 2010-10-26 15:27:09 EDT (Tue, 26 Oct 2010)
@@ -12,7 +12,18 @@
#include <boost/config.hpp> // For macro BOOST_STATIC_CONSTANT
#include <boost/mpl/and.hpp>
#include <boost/mpl/not.hpp>
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4913) // user defined binary operator ',' exists but no overload could convert all operands, default built-in binary operator ',' used
+#endif
+
#include <boost/detail/is_incrementable.hpp>
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_floating_point.hpp>
Modified: sandbox/itl/libs/itl/doc/examples.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/examples.qbk (original)
+++ sandbox/itl/libs/itl/doc/examples.qbk 2010-10-26 15:27:09 EDT (Tue, 26 Oct 2010)
@@ -18,8 +18,12 @@
Demonstrating
['*aggregate on overlap*].]]
[[basic] [[link boost_icl.examples.interval Interval]]
- [__itv__] [Intervals for integral and continuous instance types.
+ [__dc_itv__, __ct_itv__ ] [Intervals for discrete and continuous instance types.
Closed and open interval borders.]]
+ [[basic] [[link boost_icl.examples.dynamic_interval Dynamic intervals]]
+ [__dc_itv__, __ct_itv__, __itv__ ] [Intervals with dynamic interval bounds as library default.]]
+ [[basic] [[link boost_icl.examples.static_interval Static intervals]]
+ [__ro_itv__, __itv__ ] [Intervals with static interval bounds and changing the library default.]]
[[basic] [[link boost_icl.examples.interval_container Interval container]]
[__itv_set__,\n__sep_itv_set__,\n__spl_itv_set__,\n__spl_itv_map__,\n__itv_map__]
[Basic characteristics of interval containers.]]
@@ -135,6 +139,17 @@
[example_interval]
[endsect]
+[section Dynamic interval]
+[import ../example/dynamic_interval_/dynamic_interval.cpp]
+[example_dynamic_interval]
+[endsect]
+
+[section Static interval]
+[import ../example/static_interval_/static_interval.cpp]
+[example_static_interval]
+[endsect]
+
+
[section Interval container]
Example [*interval container] demonstrates the characteristic behaviors
Modified: sandbox/itl/libs/itl/doc/functions.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions.qbk 2010-10-26 15:27:09 EDT (Tue, 26 Oct 2010)
@@ -259,6 +259,10 @@
[include functions_element_iteration.qbk]
[include functions_streaming.qbk]
+[include functions_interval_construct.qbk]
+[include functions_interval_orderings.qbk]
+[include functions_interval_misc.qbk]
+
[endsect][/ Function Reference]
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-26 15:27:09 EDT (Tue, 26 Oct 2010)
@@ -32,6 +32,14 @@
[endsect][/ Synopsis Equivalences and Orderings]
+[section Less on Intervals]
+
+[
+[[ ] [Types][]]
+[[`x < y`] [__i] [`x` begins before `y` or, for equal beginnings `x` ends before `y`]]
+]
+
+[endsect][/ Less on Intervals]
[section Lexicographical Ordering][/ Equivalences and Orderings]
@@ -40,6 +48,25 @@
equality and compare operators implement lexicographical
equality and lexicographical comparison, that depends on
the equality of template parameter `Compare`.
+This includes the less ordering on intervals, that can be
+perceived as the sequence of elements between their lower and upper
+bound. This generalized lexicogrphical comparison in intervals
+can also be specified this way:
+
+`x < y := x` begins before `y` or, for equal beginnings `x` ends before `y`
+
+[
+[]
+[[`x < y`] [`:=`] [`x` begins before `y` or, for equal beginnings `x` ends before `y`.
+
+ The other operators can be deduced in the usual way]]
+[[`x > y`] [`:=`] [`y < x`] ]
+[[`x <= y`] [`:=`] [`!(y < x)`] ]
+[[`x >= y`] [`:=`] [`!(x < y)`] ]
+[[`x == y`] [`:=`] [`!(x < y) && !(y < x)` induced equivalence] ]
+[[`x != y`] [`:=`] [`!(x == y)`] ]
+]
+
Equality and compare operators are defined for all *icl*
objects but there are no overloads between different types.
Added: sandbox/itl/libs/itl/doc/functions_interval_construct.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_interval_construct.qbk 2010-10-26 15:27:09 EDT (Tue, 26 Oct 2010)
@@ -0,0 +1,124 @@
+[/
+ 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
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[/ //= Interval Construction ===================================================================]
+[section Interval Construction]
+
+[table
+[[T] [__ch_dsc_itv__] [__ch_cnt_itv__] [__ch_ro_itv__] [__ch_lo_itv__] [__ch_cl_itv__] [__ch_op_itv__] ]
+[[Interval bounds] [dynamic] [dynamic] [static] [static] [static] [static] ]
+[[Form] [ ] [ ] [asymmetric] [asymmetric] [symmetric] [symmetric] ]
+[[['*Construct*]] [ ] [ ] [ ] [ ] [ ] [ ] ]
+[[`T singleton(const P&)`] [__d] [__c] [__d] [__d] [__d] [__d] ]
+[[`T construct(const P&, const P&)`] [__d] [__c] [__dc] [__dc] [__d] [__d] ]
+[[``
+T construct(const P&, const P&,
+ interval_bounds )
+``] [__d] [__c] [ ] [ ] [ ] [ ] ]
+[[`T hull(const P&, const P&)`] [__d] [__c] [__dc] [__dc] [__d] [__d] ]
+[[`T span(const P&, const P&)`] [__d] [__c] [__dc] [__dc] [__d] [__d] ]
+[[`static T right_open(const P&, const P&)`] [__d] [__c] [ ] [ ] [ ] [ ] ]
+[[`static T left_open(const P&, const P&)`] [__d] [__c] [ ] [ ] [ ] [ ] ]
+[[`static T closed(const P&, const P&)`] [__d] [__c] [ ] [ ] [ ] [ ] ]
+[[`static T open(const P&, const P&)`] [__d] [__c] [ ] [ ] [ ] [ ] ]
+]
+
+The table above shows the availability of functions, that allow the construction
+of intervals. All interval constructin functins are of ['*constant time and space complexity*].
+
+[table
+[[['*Construct*]] [Description] ]
+[[`T singleton(const P& value)`] [Constructs an interval that contains exactly one element `value`.
+ For all interval types of the icl sigletons can be constructed
+ for /discrete/ domain types. For continuous domain types, only
+ __ct_itv__ is capable to construct a singleton. ] ]
+[[`T construct(const P& lower, const P& upper)`] [Contructs an interval with lower bound `lower` and upper bound `upper` ] ]
+[[``
+T construct(const P& lower, const P& upper,
+ interval_bounds bounds
+ = interval_bounds::right_open())
+``]
+ [For dynamically bounded intervals this function constructs an
+ interval with interval bounds specified by the third parameter. ] ]
+[[`T hull(const P& x1, const P& x2)`] [`hull(x1,x2)` constructs the smallest interval that contains both `x1` and `x2`.
+ `x2` may be smaller than `x1`. ] ]
+[[`T span(const P& x1, const P& x2)`] [`span(x1,x2)` constructs the interval `construct(min(x1,x2), max(x1,x2))`.
+ Note the differences between `span`, `hull` and `construct`:
+``
+span<right_open_interval<int> >(2,1) == [1,2) // does NOT contain 2
+hull<right_open_interval<int> >(2,1) == [1,3) // contains 2
+construct<right_open_interval<int> >(2,1) == [) // is empty
+``
+ ] ]
+[[``
+static T right_open(const P&, const P&)
+static T left_open(const P&, const P&)
+static T closed(const P&, const P&)
+static T open(const P&, const P&)
+`` ] [For dynamically bounded intervals there are for static functions to
+ construct intervals with the four interval bound types:
+``
+discrete_interval<int> itv1 = discrete_interval<int>::closed(0,42);
+continuous_interval<double> itv2 = continuous_interval<double>::right_open(0.0, 1.0);
+``
+ ] ]
+[[['*Using the interval default*]] [ ]]
+[[`interval<P>::type`] [There is a library default, for all interval containers of the *icl*.
+ The intension of the library default is to minimize the need for parameter
+ specification, when working with *icl* class templates.
+ We can get the library default interval type as `interval<P>::type`.
+ The library default uses ['*dynamically bounded intervals*]. You
+ can switch to ['*statically bounded intervals*] by
+ `#define BOOST_ICL_USE_STATIC_BOUNDED_INTERVALS` prior to itl includes. ]]
+[[``
+static T right_open(const P&, const P&)
+static T left_open(const P&, const P&)
+static T closed(const P&, const P&)
+static T open(const P&, const P&)
+`` ] [For template struct `interval` that always uses the library default
+ the static functions for the four interval bound types are also available.
+``
+interval<int>::type itv1 = interval<int>::closed(0,42);
+interval<double>::type itv2 = interval<double>::right_open(0.0, 1.0);
+``
+ This works with the statically bounded intervals as well,
+ with the restriction that for continuous domain types the
+ matching function has to be used:
+``
+#define BOOST_ICL_USE_STATIC_BOUNDED_INTERVALS
+. . .
+// library default is the statically bounded right_open_interval
+interval<int>::type itv1 = interval<int>::closed(0,42); //==[0,43) //ok, bounds are shifted
+interval<double>::type itv2 = interval<double>::right_open(0.0, 1.0); //ok. right_open matches
+interval<double>::type itv3 = interval<double>::closed(0.0, 1.0); //will NOT compile
+``
+ See also examples
+ [link boost_icl.examples.dynamic_interval Dynamic intervals] and
+ [link boost_icl.examples.static_interval Static intervals]
+ ]]
+]
+
+['*See also . . .*]
+[table
+[]
+[[[link boost_icl.examples.dynamic_interval ['*Example: Dynamically bounded intervals and the library default*]] ]]
+[[[link boost_icl.examples.static_interval ['*Example: Statically bounded intervals, changing the library default*]] ]]
+]
+
+['*Back to section . . .*]
+[table
+[]
+[[[link additional_interval_functions ['*Additional interval functions*]] ]]
+[[[link function_synopsis_table ['*Function Synopsis*]] ]]
+[[[link boost_icl.interface ['*Interface*]] ]]
+]
+
+[endsect][/ Interval Construction]
+
+
Added: sandbox/itl/libs/itl/doc/functions_interval_misc.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_interval_misc.qbk 2010-10-26 15:27:09 EDT (Tue, 26 Oct 2010)
@@ -0,0 +1,48 @@
+[/
+ 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
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[/ //= Miscellaneous Interval Functions ===================================================================]
+[section Miscellaneous Interval Functions]
+
+
+[table
+[[T] [__ch_dsc_itv__] [__ch_cnt_itv__] [__ch_ro_itv__] [__ch_lo_itv__] [__ch_cl_itv__] [__ch_op_itv__] ]
+[[Interval bounds] [dynamic] [dynamic] [static] [static] [static] [static] ]
+[[Form] [ ] [ ] [asymmetric] [asymmetric] [symmetric] [symmetric] ]
+
+[[['*Miscellaneous*]] [ ] [ ] [ ] [ ] [ ] [ ] ]
+[[`bool touches(const T&, const T&)`] [1] [1] [1] [1] [1] [1] ]
+[[`T inner_complement(const T&, const T&)`] [1] [1] [1] [1] [1] [1] ]
+[[`difference_type distance(const T&, const T&)`] [1] [1] [1] [1] [1] [1] ]
+
+]
+
+
+[table
+
+[[['*Miscellaneous Interval Functions*]] [Description] ]
+[[`bool touches(const T&, const T&)`] [`touches(x,y)` Between the disjoint intervals `x` and `y` are no elements. ] ]
+[[`T inner_complement(const T&, const T&)`] [`z = inner_complement(x,y)` `z` is the interval between `x` and `y`] ]
+[[`difference_type distance(const T&, const T&)`] [`d = distance(x,y)` If the domain type of the interval has a difference_type,
+ `d` is the distance between `x` and `y`.] ]
+
+]
+
+
+['*Back to section . . .*]
+[table
+[]
+[[[link additional_interval_functions ['*Additional interval functions*]] ]]
+[[[link function_synopsis_table ['*Function Synopsis*]] ]]
+[[[link boost_icl.interface ['*Interface*]] ]]
+]
+
+[endsect][/ Miscellaneous Interval Functions]
+
+
Added: sandbox/itl/libs/itl/doc/functions_interval_orderings.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/functions_interval_orderings.qbk 2010-10-26 15:27:09 EDT (Tue, 26 Oct 2010)
@@ -0,0 +1,90 @@
+[/
+ 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
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[/ //= Additional Interval Orderings ===================================================================]
+[section Additional Interval Orderings]
+
+In addition to the standard orderings `operator <` and rleated `> <= >=` that you will find in the
+[link function_synopsis_table ['*librarie's function synopsis*]], intervals
+implement some additional orderings that can be useful.
+
+[table
+[[T] [__ch_dsc_itv__] [__ch_cnt_itv__] [__ch_ro_itv__] [__ch_lo_itv__] [__ch_cl_itv__] [__ch_op_itv__] ]
+[[Interval bounds] [dynamic] [dynamic] [static] [static] [static] [static] ]
+[[Form] [ ] [ ] [asymmetric] [asymmetric] [symmetric] [symmetric] ]
+[[['*Orderings*]] [ ] [ ] [ ] [ ] [ ] [ ] ]
+[[`bool exclusive_less(const T&, const T&)`] [1] [1] [1] [1] [1] [1] ]
+[[``
+bool lower_less(const T&, const T&)
+bool lower_equal(const T&, const T&)
+bool lower_less_equal(const T&, const T&)
+``] [1] [1] [1] [1] [1] [1] ]
+[[``
+bool upper_less(const T&, const T&)
+bool upper_equal(const T&, const T&)
+bool upper_less_equal(const T&, const T&)
+``]
+ [1] [1] [1] [1] [1] [1] ]
+]
+
+A central role for the *icl* plays the
+`exclusive_less` ordering, which is used
+in all interval containers.
+The other orderings can be useful to simplify
+comparison of intervals specifically for
+dynamically bounded ones.
+
+[table
+[[['*Orderings*]] [Description] ]
+[[`bool exclusive_less(const T&, const T&)`] [`exclusive_less(x1, x2)` is true if every element of interval `x1` is less than
+ every element of interval `x2` w.r.t. the the intervals `Compare` ordering ] ]
+[[``
+bool lower_less(const T&, const T&)
+bool lower_equal(const T&, const T&)
+bool lower_less_equal(const T&, const T&)
+``] [Compares the beginnings of intervals.
+``
+lower_less(x,y) == true; // x begins before y
+lower_equal(x,y) == true; // x and y begin at the same element
+lower_less_equal(x,y) == lower_less(x,y) || lower_equal(x,y);
+``
+ ] ]
+[[``
+bool upper_less(const T&, const T&)
+bool upper_equal(const T&, const T&)
+bool upper_less_equal(const T&, const T&)
+``]
+ [Compares the endings of intervals.
+``
+upper_less(x,y) == true; // x ends before y
+upper_equal(x,y) == true; // x and y end at the same element
+upper_less_equal(x,y) == upper_less(x,y) || upper_equal(x,y);
+``
+ ] ]
+]
+
+
+['*See also . . .*]
+[table
+[]
+[[ __biLEquivsOrderings__ ]]
+]
+
+
+['*Back to section . . .*]
+[table
+[]
+[[[link additional_interval_functions ['*Additional interval functions*]] ]]
+[[[link function_synopsis_table ['*Function Synopsis*]] ]]
+[[[link boost_icl.interface ['*Interface*]] ]]
+]
+
+[endsect][/ Additional Interval Orderings]
+
+
Modified: sandbox/itl/libs/itl/doc/icl.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/icl.qbk (original)
+++ sandbox/itl/libs/itl/doc/icl.qbk 2010-10-26 15:27:09 EDT (Tue, 26 Oct 2010)
@@ -19,8 +19,8 @@
[/ Macros will be used for links so we have a central place to change them ]
-[def __itv__ `interval`]
-[def __Itv__ `Interval`]
+[def __itv__ [classref boost::icl::interval interval]]
+[def __Itv__ [classref boost::icl::interval Interval]]
[def __itv_tr__ [classref boost::icl::interval_traits interval_traits]]
[def __Itv_tr__ [classref boost::icl::interval_traits Interval_traits]]
@@ -119,6 +119,9 @@
[def __p [link interval_mapping_type *p*]]
[def __m [link itl_map_type *m*]]
[def __M [link interval_map_types *M*]]
+[def __d [link discrete_types *d*]]
+[def __c [link continuous_types *c*]]
+
[def __ei [link element_type *e*] [link interval_type *i*]]
[def __bp [link element_mapping_type *b*] [link interval_mapping_type *p*]]
[def __eS [link element_type *e*] [link interval_set_types *S*]]
@@ -128,6 +131,7 @@
[def __ebm [link element_type *e*] [link element_mapping_type *b*] [link itl_map_type *m*]]
[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 __dc [link discrete_types *d*] [link continuous_types *c*]]
[def __S1 [link ph_def_S1 *S1*]]
[def __S2 [link ph_def_S2 *S2*]]
@@ -166,6 +170,10 @@
[def __biLElementIteration__ [link boost_icl.function_reference.element_iteration ['*Element iteration*]]]
[def __biLStreaming__ [link boost_icl.function_reference.streaming__conversion ['*Streaming, conversion*]]]
+[def __biLIntervalConstruct__ [link boost_icl.function_reference.interval_construction ['*Construction*]]]
+[def __biLIntervalOrderings__ [link boost_icl.function_reference.additional_interval_orderings ['*Orderings*]]]
+[def __biLIntervalMiscellaneous__ [link boost_icl.function_reference.miscellaneous_interval_functions ['*Miscellaneous*]]]
+
[/ column headers]
[def __ch_itvs__ intervals]
@@ -186,6 +194,13 @@
[def __ch_ele_set__ element\nset]
[def __ch_ele_map__ element\nmap]
+[def __ch_dsc_itv__ discrete\n_interval]
+[def __ch_cnt_itv__ continuous\n_interval]
+[def __ch_ro_itv__ right_open\n_interval]
+[def __ch_lo_itv__ left_open\n_interval]
+[def __ch_cl_itv__ closed\n_interval]
+[def __ch_op_itv__ open\n_interval]
+
[def __bi_conceptual__ ['*fundamental*]]
[def __conceptual__ fundamental]
[def __Conceptual__ Fundamental]
Modified: sandbox/itl/libs/itl/doc/implementation.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/implementation.qbk (original)
+++ sandbox/itl/libs/itl/doc/implementation.qbk 2010-10-26 15:27:09 EDT (Tue, 26 Oct 2010)
@@ -46,9 +46,9 @@
the ['*number of elements*] of a container. Because for an interval container
``
interval_set<int> mono;
-mono += interval<int>(1,5); // {[1 ... 5]}
-mono.size() == 5; // true, 5 elements
-mono.interval_count() == 1; // true, only one interval
+mono += interval<int>::closed(1,5); // {[1 ... 5]}
+mono.size() == 5; // true, 5 elements
+mono.interval_count() == 1; // true, only one interval
``
it's size and the number of contained intervals is usually different.
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-26 15:27:09 EDT (Tue, 26 Oct 2010)
@@ -536,18 +536,20 @@
[[A ] [] [implementation generated by compilers]]
[[[#element_type] [*e]] [T::element_type] [the element type of __itv_sets__ or __icl_sets__]]
[[[#interval_type] [*i]] [T::segment_type] [the segment type of of __itv_sets__]]
-[[[#itl_set_type] [*s]] [__icl_set__] [icl's set type]]
+[[[#itl_set_type] [*s]] [element sets] [__std_set__ or other models of the icl's set concept]]
[[[#interval_set_types] [*S]] [interval_sets] [one of the interval set types]]
[[[#element_mapping_type] [*b]] [T::element_type] [type of __itv_map_s__ or __icl_map_s__ element value pairs]]
[[[#interval_mapping_type][*p]] [T::segment_type] [type of __itv_map_s__ interval value pairs]]
-[[[#itl_map_type] [*m]] [__icl_map__] [icl's map type]]
+[[[#itl_map_type] [*m]] [element maps] [__icl_map__ icl's map type]]
[[[#interval_map_types] [*M]] [interval_maps] [one of the interval map types]]
+[[[#discrete_types] [*d]] [discrete types] [types with a least steppable discrete unit: Integral types, date/time types etc.]]
+[[[#continuous_types] [*c]] [continuous types] [types with (theoretically) infinitely many elements beween two values.]]
]
[/ memberref boost::icl::set::iterative_size `iterative_size`]
[table Synopsis Functions and Overloads
-[[T] [__ch_itvs__][__ch_itv_sets__][__ch_itv_maps__][__ch_ele_sets__][__ch_ele_maps__]]
+[[T] [__ch_itvs__][__ch_itv_sets__][__ch_itv_maps__][__ch_ele_sets__][__ch_ele_maps__]]
[/ interval itvset itvmap icl:set icl:map ]
[[__biLConsCopyDest__ [#function_synopsis_table]] [ ] [ ] [ ] [ ] [ ] ]
[[`T::T()`] [1] [1] [1] [1] [1] ]
@@ -671,6 +673,41 @@
[1] [1] [1] [1] [1] ]
]
+Many but not all functions of *icl* intervals are listed in the table above.
+Some specific functions are summarized in the next table. For the group of
+the constructing functions, placeholders __d denote discrete domain types and
+__c denote continuous domain types `T::domain_type` for an interval_type `T` and an
+argument types `P`.
+
+[table Additional interval functions
+[[T] [__ch_dsc_itv__] [__ch_cnt_itv__] [__ch_ro_itv__] [__ch_lo_itv__] [__ch_cl_itv__] [__ch_op_itv__] ]
+[[Interval bounds] [dynamic] [dynamic] [static] [static] [static] [static] ]
+[[Form] [ ] [ ] [asymmetric] [asymmetric] [symmetric] [symmetric] ]
+[[__biLIntervalConstruct__ [#additional_interval_functions]]
+ [ ] [ ] [ ] [ ] [ ] [ ] ]
+[[`T singleton(const P&)`] [__d] [__c] [__d] [__d] [__d] [__d] ]
+[[`T construct(const P&, const P&)`] [__d] [__c] [__dc] [__dc] [__d] [__d] ]
+[[`T construct(const P&, const P&, interval_bounds)`] [__d] [__c] [ ] [ ] [ ] [ ] ]
+[[`T hull(const P&, const P&)`] [__d] [__c] [__dc] [__dc] [__d] [__d] ]
+[[`T span(const P&, const P&)`] [__d] [__c] [__dc] [__dc] [__d] [__d] ]
+[[`static T right_open(const P&, const P&)`] [__d] [__c] [ ] [ ] [ ] [ ] ]
+[[`static T left_open(const P&, const P&)`] [__d] [__c] [ ] [ ] [ ] [ ] ]
+[[`static T closed(const P&, const P&)`] [__d] [__c] [ ] [ ] [ ] [ ] ]
+[[`static T open(const P&, const P&)`] [__d] [__c] [ ] [ ] [ ] [ ] ]
+[[__biLIntervalOrderings__] [ ] [ ] [ ] [ ] [ ] [ ] ]
+[[`bool exclusive_less(const T&, const T&)`] [1] [1] [1] [1] [1] [1] ]
+[[`bool lower_less(const T&, const T&)`\n
+ `bool lower_equal(const T&, const T&)`\n
+ `bool lower_less_equal(const T&, const T&)`] [1] [1] [1] [1] [1] [1] ]
+[[`bool upper_less(const T&, const T&)`\n
+ `bool upper_equal(const T&, const T&)`\n
+ `bool upper_less_equal(const T&, const T&)`] [1] [1] [1] [1] [1] [1] ]
+[[__biLIntervalMiscellaneous__] [ ] [ ] [ ] [ ] [ ] [ ] ]
+[[`bool touches(const T&, const T&)`] [1] [1] [1] [1] [1] [1] ]
+[[`T inner_complement(const T&, const T&)`] [1] [1] [1] [1] [1] [1] ]
+[[`difference_type distance(const T&, const T&)`] [1] [1] [1] [1] [1] [1] ]
+]
+
[h4 Element iterators for interval containers]
Iterators on [*interval conainers] that are refered to in section /Iteration/
Modified: sandbox/itl/libs/itl/doc/introduction.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/introduction.qbk (original)
+++ sandbox/itl/libs/itl/doc/introduction.qbk 2010-10-26 15:27:09 EDT (Tue, 26 Oct 2010)
@@ -8,20 +8,28 @@
[section Introduction]
-[note [* The Interval Template Library is accepted into Boost]
+[/ note [* The Interval Container Library is accepted into Boost]
-The /Interval Template Library/ underwent
+The [*Interval Container Library] (formerly /Interval Template Library/) underwent
a formal review on the boost developer's list
from February 18, 2010 to March 08, 2010 and has been accepted
-into the boost library collection.
+by declaration of review manager Hartmut Kaiser
+into the boost library collection on April 18, 2010.
+
+The library has been refactored for the suggestions and requests
+that came up during the review. The current version is now
+ready for inclusion into the next boost release.
The name ['*Interval Template Library (ITL)*]
-will be changed to ['*Interval Container Library (ICL)*].
+has been changed to ['*Interval Container Library (ICL)*].
+
+If you find bugs in the library or typos or other shortcomings in
+the documentation please send reports to the boost developers list
+boost_at_[hidden]
+the boost users list or
+boost-users_at_[hidden]
+to `[afojgo<AT>gmail dot com]`.
-The library is currently refactored for the suggestions and requests
-that came up during the review. These modifications will be
-completed in autumn 2010 and the library will probably
-available with the boost release 1.46.
]
["A bug crawls across the boost docs on my laptop screen.
Modified: sandbox/itl/libs/itl/example/dynamic_interval_/dynamic_interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/dynamic_interval_/dynamic_interval.cpp (original)
+++ sandbox/itl/libs/itl/example/dynamic_interval_/dynamic_interval.cpp 2010-10-26 15:27:09 EDT (Tue, 26 Oct 2010)
@@ -19,7 +19,7 @@
\include dynamic_interval_/dynamic_interval.cpp
*/
-//[example_interval
+//[example_dynamic_interval
#include <iostream>
#include <string>
#include <math.h>
@@ -44,13 +44,13 @@
// Dynamically bounded intervals are the library default for
// interval parameters in interval containers.
BOOST_STATIC_ASSERT((
- is_same< typename interval_set<int>::interval_type
+ is_same< interval_set<int>::interval_type
, discrete_interval<int> >::value
));
BOOST_STATIC_ASSERT((
- is_same< typename interval_set<float>::interval_type
+ is_same< interval_set<float>::interval_type
, continuous_interval<float> >::value
));
@@ -59,12 +59,12 @@
// dependent on the domain_type T. The library default for intervals
// is also available via the template 'interval':
BOOST_STATIC_ASSERT((
- is_same< typename interval<int>::type
+ is_same< interval<int>::type
, discrete_interval<int> >::value
));
BOOST_STATIC_ASSERT((
- is_same< typename interval<float>::type
+ is_same< interval<float>::type
, continuous_interval<float> >::value
));
Modified: sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp (original)
+++ sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp 2010-10-26 15:27:09 EDT (Tue, 26 Oct 2010)
@@ -34,10 +34,10 @@
void interval_container_basics()
{
- right_open_interval<Time> night_and_day = right_open_interval<Time>(Time(monday, 20,00), Time(tuesday, 20,00));
- right_open_interval<Time> day_and_night = right_open_interval<Time>(Time(tuesday, 7,00), Time(wednesday, 7,00));
- right_open_interval<Time> next_morning = right_open_interval<Time>(Time(wednesday, 7,00), Time(wednesday,10,00));
- right_open_interval<Time> next_evening = right_open_interval<Time>(Time(wednesday,18,00), Time(wednesday,21,00));
+ interval<Time>::type night_and_day(Time(monday, 20,00), Time(tuesday, 20,00));
+ interval<Time>::type day_and_night(Time(tuesday, 7,00), Time(wednesday, 7,00));
+ interval<Time>::type next_morning(Time(wednesday, 7,00), Time(wednesday,10,00));
+ interval<Time>::type next_evening(Time(wednesday,18,00), Time(wednesday,21,00));
// An interval set of type interval_set joins intervals that that overlap or touch each other.
interval_set<Time> joinedTimes;
Modified: sandbox/itl/libs/itl/example/static_interval_/static_interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/static_interval_/static_interval.cpp (original)
+++ sandbox/itl/libs/itl/example/static_interval_/static_interval.cpp 2010-10-26 15:27:09 EDT (Tue, 26 Oct 2010)
@@ -20,7 +20,7 @@
\include static_interval_/static_interval.cpp
*/
-//[example_interval
+//[example_static_interval
#include <iostream>
#include <string>
#include <math.h>
@@ -53,12 +53,12 @@
// Statically bounded intervals are the user defined library default for
// interval parameters in interval containers now.
BOOST_STATIC_ASSERT((
- is_same< typename interval_set<int>::interval_type
+ is_same< interval_set<int>::interval_type
, right_open_interval<int> >::value
));
BOOST_STATIC_ASSERT((
- is_same< typename interval_set<float>::interval_type
+ is_same< interval_set<float>::interval_type
, right_open_interval<float> >::value
));
@@ -67,7 +67,7 @@
// The user defined library default for intervals is also available via
// the template 'interval':
BOOST_STATIC_ASSERT((
- is_same< typename interval<int>::type
+ is_same< interval<int>::type
, right_open_interval<int> >::value
));