Subject: [Boost-commit] svn:boost r50569 - in sandbox/itl: boost/itl libs/itl/doc libs/itl/test/test_itl_interval
From: afojgo_at_[hidden]
Date: 2009-01-13 15:43:47
Author: jofaber
Date: 2009-01-13 15:43:44 EST (Tue, 13 Jan 2009)
New Revision: 50569
URL: http://svn.boost.org/trac/boost/changeset/50569
Log:
Refactored. Completed left_surplus and right_surplus. Stable {msvc-9.0, partly congcc-4.3-a7}
Text files modified:
sandbox/itl/boost/itl/interval.hpp | 189 ++++++++++++++++++---------------------
sandbox/itl/boost/itl/interval_set_algo.hpp | 2
sandbox/itl/boost/itl/interval_sets.hpp | 2
sandbox/itl/boost/itl/map.hpp | 2
sandbox/itl/boost/itl/set.hpp | 2
sandbox/itl/libs/itl/doc/interface.qbk | 131 +++++++++++++++------------
sandbox/itl/libs/itl/doc/itl.qbk | 4
sandbox/itl/libs/itl/test/test_itl_interval/test_itl_interval.cpp | 76 +++++++++++++++
8 files changed, 243 insertions(+), 165 deletions(-)
Modified: sandbox/itl/boost/itl/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval.hpp (original)
+++ sandbox/itl/boost/itl/interval.hpp 2009-01-13 15:43:44 EST (Tue, 13 Jan 2009)
@@ -287,7 +287,7 @@
*/
-/// A class for intervals
+/// A class template for intervals
/** Bounds of the interval may be closed or open.
Discrete or continuous datatypes may be used as domain datatypes DomainT.
@@ -301,8 +301,6 @@
<tt>float, double, Rational etc.</tt> elements. The domain parameter
may be a built in c++ datatype or a class type. It has to implement
the interface DomainT.
-
- @author Joachim Faulhaber
*/
template <class DomainT, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT)>
#ifdef USE_CONCEPTS
@@ -312,9 +310,6 @@
{
public:
-/** @name A: Type definitions for the template class
-*/
-//@{
/// Domain type or element type
typedef DomainT domain_type;
/// Compare order on the data
@@ -341,146 +336,133 @@
CLOSED = 0x3,
} ;
-//@}
-
- /// Default constructor; yields an empty interval <tt>[1,0]</tt>
+ /** Default constructor; yields an empty interval <tt>[1,0]</tt> */
interval() : _lwb(unon<DomainT>::value()), _upb(neutron<DomainT>::value()),
_boundtypes(CLOSED) {}
- // Use compiler generated copy contructor
+ //NOTE: Compiler generated copy constructor is used
- /// Constructor for a closed singleton interval <tt>[val,val]</tt>
+ /** Constructor for a closed singleton interval <tt>[val,val]</tt> */
explicit interval(const DomainT& val) :
_lwb(val), _upb(val), _boundtypes(CLOSED) {}
- /// Closed interval <tt>[low,up]</tt>
- interval(const DomainT& low, const DomainT& up) :
- _lwb(low), _upb(up), _boundtypes(CLOSED) {}
- /// Interval from <tt>low</tt> to <tt>up</tt> with bounds <tt>bt</tt>
- interval(const DomainT& low, const DomainT& up, bound_types bt) :
+
+ /** Interval from <tt>low</tt> to <tt>up</tt> with bounds <tt>bt</tt> */
+ interval(const DomainT& low, const DomainT& up, bound_types bt = CLOSED) :
_lwb(low), _upb(up), _boundtypes(bt) {}
+ /** Closed interval <tt>[low,up]</tt> */
static interval closed(const DomainT& low, const DomainT& up)
{ return interval(low, up, CLOSED); }
+ /** Rightopen interval <tt>[low,up)</tt> */
static interval rightopen(const DomainT& low, const DomainT& up)
{ return interval(low, up, RIGHT_OPEN); }
+ /** Leftopen interval <tt>(low,up]</tt> */
static interval leftopen(const DomainT& low, const DomainT& up)
{ return interval(low, up, LEFT_OPEN); }
+ /** Open interval <tt>(low,up)</tt> */
static interval open(const DomainT& low, const DomainT& up)
{ return interval(low, up, OPEN); }
- // Use compiler generated assignment operator =
+ //NOTE: Compiler generated assignment operator = used
-/** @name E: Selectors
-*/
-//@{
- /// Lower bound of the interval
+ /** Lower bound of the interval */
DomainT lower()const { return _lwb; }
- /// Upper bound of the interval
+ /** Upper bound of the interval */
DomainT upper()const { return _upb; }
- /// Typ of interval bounds
+ /** Typ of interval bounds */
bound_types boundtypes()const { return _boundtypes; }
-//@}
-/** @name F.P: Tester, predicates
-*/
-//@{
- /// Is the interval empty?
+ /** Is the interval empty? */
bool empty()const;
- /// Does the interval contain <tt>x</tt>?
+ /** Does the interval contain <tt>x</tt>? */
bool contains(const DomainT& x)const;
- /// Both closed: <tt>[x,y]</tt> ?
+ /** Both closed: <tt>[x,y]</tt> ? */
bool is_closed()const { return _boundtypes == CLOSED; }
- /// Left open right closed: <tt>(x,y]</tt> ?
+ /** Left open right closed: <tt>(x,y]</tt> ? */
bool is_leftopen()const { return _boundtypes == LEFT_OPEN; }
- /// Left closed right open: <tt>[x,y)</tt> ?
+ /** Left closed right open: <tt>[x,y)</tt> ? */
bool is_rightopen()const { return _boundtypes == RIGHT_OPEN; }
- /// Both open: <tt>(x,y)</tt> ?
+ /** Both open: <tt>(x,y)</tt> ? */
bool is_open()const { return _boundtypes == OPEN; }
- /// Left bound is open right unknown <tt>(x,y|</tt> ?
+ /** Left bound is open right unknown <tt>(x,y|</tt> ? */
bool leftbound_open()const { return !leftbound_closed(); }
-
- /// Right bound is open left unknown <tt>|x,y)</tt> ?
+ /** Right bound is open left unknown <tt>|x,y)</tt> ? */
bool rightbound_open()const { return !rightbound_closed(); }
-
- /// Left closed right unknown <tt>[x,y|</tt> ?
+ /** Left closed right unknown <tt>[x,y|</tt> ? */
bool leftbound_closed()const { return 0 != (_boundtypes & RIGHT_OPEN); }
-
- /// Right closed left unknown <tt>|x,y]</tt> ?
+ /** Right closed left unknown <tt>|x,y]</tt> */
bool rightbound_closed()const { return 0 != (_boundtypes & LEFT_OPEN); }
-//@}
-
-/** @name F.R: Tester, relations
-*/
-//@{
- /// <tt>*this</tt> is subset of <tt>super</tt>
+ /** <tt>*this</tt> is subset of <tt>super</tt> */
bool contained_in(const interval& super)const ;
- /// <tt>*this</tt> is superset of <tt>sub</tt>
+ /** <tt>*this</tt> is superset of <tt>sub</tt> */
bool contains(const interval& sub)const;
- /// Equality
+ /** Equality on intervals */
bool equal(const interval& x2)const
{ return (empty() && x2.empty()) || (lower_equal(x2) && upper_equal(x2)); }
- //Equality can also be implemented this way:
- //{ return contained_in(x2) && x2.contained_in(*this); }
- /// <tt>*this</tt> and <tt>x2</tt> are disjoint; their intersection is empty
+ /** <tt>*this</tt> and <tt>x2</tt> are disjoint; their intersection is empty */
bool is_disjoint(const interval& x2)const
{ return exclusive_less(x2) || x2.exclusive_less(*this); }
- /// There is no gap between <tt>*this</tt> and <tt>x2</tt> but they have no element in common
+ /** There is no gap between <tt>*this</tt> and <tt>x2</tt> but they have no element in common */
bool touches(const interval& x2)const;
- /// Exclusive less: maximal element of <tt>*this</tt> is less than the minimal element of <tt>x2</tt>
+ /** Maximal element of <tt>*this</tt> is less than the minimal element of <tt>x2</tt> */
bool exclusive_less(const interval& x2)const;
- /// less on intervals
+ /** Less on intervals */
bool less(const interval& x2)const
{ return lower_less(x2) || ( lower_equal(x2) && upper_less(x2) ); }
-//@}
-
-
-/** @name G: Modificators
-*/
-//@{
- /// Set the interval empty
+ /** Set the interval empty */
void clear()
{ set_lwb(unon<DomainT>::value()); set_upb(neutron<DomainT>::value()); _boundtypes=CLOSED; }
- /// Set the intervals values
- interval& set(const DomainT& lw, const DomainT& up, bound_types bt)
- { _lwb=lw; _upb=up; _boundtypes=bt; return *this; }
+ /** Set \c *this interval to from \c low to \c up with boundtypes \c bt */
+ interval& set(const DomainT& low, const DomainT& up, bound_types bt)
+ { _lwb=low; _upb=up; _boundtypes=bt; return *this; }
/** Extend <tt>*this</tt> to <tt>x2</tt> yielding an interval from the minimum of lower bounds
to the maximum of upper bounds */
interval& extend(const interval& x2);
-//@}
-
-/** @name H: Combinators and more
-*/
-//@{
- /// Intersection with the interval <tt>x2</tt>; assign result to <tt>isec</tt>
+ /** Intersection with the interval <tt>x2</tt>; assign result to <tt>isec</tt> */
void intersect(interval& isec, const interval& x2)const;
- /// Returns the intersection with the interval <tt>x2</tt>
- interval intersect(const interval& x2)const { interval isec; intersect(isec, x2); return isec; }
+ /** subtract \c x2 from \c *this interval on it's right side. Assign the difference
+ to \c left_over. The result \c left_over is the part of \c *this left of \c x2.
+\code
+left_over = x1 - x2; //on the right side.
+[a ... : x1
+ [b ... : x2; x1.right_subtract(left_over, x2);
+[a b) : left_over
+\endcode
+ */
+ void left_surplus(interval& left_over, const interval& x2)const;
+
+ /** subtract \c x2 from \c *this interval on it's left side. Assign the difference
+ to \c right_over. The result \c right_over is the part of \c *this right of \c x2.
+\code
+right_over = x1 - x2; //on the left.
+... d) : x1
+... c) : x2; x1.left_subtract(right_over, x2);
+ [c d) : right_over
+\endcode
+ */
+ void right_surplus(interval& rsur, const interval& x2)const;
- /// lsur is the part of <tt>*this</tt> that juts out left over <tt>x2</tt>.
- void left_surplus(interval& lsur, const interval& x2)const;
- /// rsur is the part of <tt>*this</tt> that juts out right over <tt>x2</tt>.
- void right_surplus(interval& rsur, const interval& x2)const;
+ interval& left_subtract(const interval& x2);
/** Interval spanning from lower bound of *this interval to the upper bound of rhs.
- Bordertypes according to the lower bound of *this and the upper bound of rhs.
- */
+ Bordertypes according to the lower bound of *this and the upper bound of rhs. */
interval span(const interval& rhs)const
{
if(empty()) return rhs;
@@ -489,23 +471,12 @@
interval(_lwb, rhs._upb, span(boundtypes(), rhs.boundtypes()));
}
- interval& left_subtract(const interval& x2);
-//@}
-
-
-/** @name S: String representation
- */
-//@{
- /// Interval as string
+
+ /// Interval as string
const std::string as_string()const;
-//@}
- // NOTE ------- DISCRETE ONLY ------- DISCRETE ONLY ------- DISCRETE ONLY -------
-/** @name T: For discrete domain datatypes only that implement operators <tt>++</tt>
- and <tt>--</tt>
- */
-//@{
+
/// First (smallest) element of the interval
DomainT first()const;
/// Last (largest) element of the interval
@@ -560,20 +531,18 @@
/** Sets right border open. */
void open_right_bound();
-//@}
-/** @name U: Utilities and Limits
- */
-//@{
- /// Maximum Interval
+ /// Maximum Interval
static interval always()
{ return interval<DomainT>::closed(std::numeric_limits<DomainT>::min(),
std::numeric_limits<DomainT>::max()); }
-//@}
+
+private:
void set_lwb(DomainT lw) { _lwb=lw; }
void set_upb(DomainT up) { _upb=up; }
+public:
bool lower_less(const interval& x2)const;
bool upper_less(const interval& x2)const;
bool lower_less_equal(const interval& x2)const;
@@ -979,7 +948,8 @@
template <class DomainT, ITL_COMPARE Compare>
inline interval<DomainT,Compare>& interval<DomainT,Compare>::left_subtract(const interval& x2)
{
- set_lwb( BoundT(x2._upb, x2.succession_bounds()) );
+ if(!exclusive_less(x2))
+ set_lwb( BoundT(x2._upb, x2.succession_bounds()) );
return *this;
}
@@ -996,8 +966,11 @@
void interval<DomainT,Compare>::left_surplus(interval<DomainT,Compare>& lsur, const interval<DomainT,Compare>& x2)const
{
if(lower_less(x2)) {
- lsur.set_lwb( BoundT(_lwb,boundtypes()) );
- lsur.set_upb( upb_leftOf(x2) );
+ lsur.set_lwb( BoundT(_lwb,boundtypes()) );
+ if(exclusive_less(x2))
+ lsur.set_upb( BoundT(_upb,boundtypes()) );
+ else
+ lsur.set_upb( upb_leftOf(x2) );
}
else lsur.clear();
}
@@ -1006,7 +979,10 @@
void interval<DomainT,Compare>::right_surplus(interval<DomainT,Compare>& rsur, const interval<DomainT,Compare>& x2)const
{
if(x2.upper_less(*this)) {
- rsur.set_lwb(lwb_rightOf(x2));
+ if(exclusive_less(x2))
+ rsur.set_lwb( BoundT(_lwb,boundtypes()) );
+ else
+ rsur.set_lwb(lwb_rightOf(x2));
rsur.set_upb( BoundT(_upb,boundtypes()) );
}
else rsur.clear();
@@ -1166,12 +1142,19 @@
// ----------------------------------------------------------------------------
template <class DomainT, ITL_COMPARE Compare>
itl::interval<DomainT,Compare>& operator &= ( itl::interval<DomainT,Compare>& section,
- const itl::interval<DomainT,Compare>& sectant)
+ const itl::interval<DomainT,Compare>& sectant)
{
section.intersect(section, sectant);
return section;
}
+template <class DomainT, ITL_COMPARE Compare>
+itl::interval<DomainT,Compare> operator & (const itl::interval<DomainT,Compare>& left,
+ const itl::interval<DomainT,Compare>& right)
+{
+ return itl::interval<DomainT,Compare>(left) &= right;
+}
+
template<class CharType, class CharTraits, class DomainT, ITL_COMPARE Compare>
std::basic_ostream<CharType, CharTraits> &operator<<
(std::basic_ostream<CharType, CharTraits> &stream, interval<DomainT,Compare> const& x)
Modified: sandbox/itl/boost/itl/interval_set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set_algo.hpp (original)
+++ sandbox/itl/boost/itl/interval_set_algo.hpp 2009-01-13 15:43:44 EST (Tue, 13 Jan 2009)
@@ -79,7 +79,7 @@
_left_end(left_end), _right_end(right_end),
_compare_codomain(false), _result(result_is_equal)
{
- _scope = enclosure(_left).intersect(enclosure(_right));
+ _scope = enclosure(_left) & enclosure(_right);
}
enum{firstboth, nextboth, nextleft, nextright, leftaligned, stop};
Modified: sandbox/itl/boost/itl/interval_sets.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_sets.hpp (original)
+++ sandbox/itl/boost/itl/interval_sets.hpp 2009-01-13 15:43:44 EST (Tue, 13 Jan 2009)
@@ -241,7 +241,7 @@
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
-// intersection *=
+// intersection &=
//-----------------------------------------------------------------------------
template
<
Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2009-01-13 15:43:44 EST (Tue, 13 Jan 2009)
@@ -298,6 +298,8 @@
different from \c size(). */
size_t iterative_size()const { return size(); }
+ size_t cardinality()const { return size(); }
+
void absorb_neutrons()
{
//content_is_neutron<key_type, data_type> neutron_dropper;
Modified: sandbox/itl/boost/itl/set.hpp
==============================================================================
--- sandbox/itl/boost/itl/set.hpp (original)
+++ sandbox/itl/boost/itl/set.hpp 2009-01-13 15:43:44 EST (Tue, 13 Jan 2009)
@@ -200,6 +200,8 @@
different from \c size(). */
size_t iterative_size()const { return size(); }
+ size_t cardinality()const { return size(); }
+
/** Erase the elements in *this set to which property \c hasProperty applies.
Keep all the rest. */
template<class Predicate>
Modified: sandbox/itl/libs/itl/doc/interface.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/interface.qbk (original)
+++ sandbox/itl/libs/itl/doc/interface.qbk 2009-01-13 15:43:44 EST (Tue, 13 Jan 2009)
@@ -13,9 +13,6 @@
the libraries design and to focus on structural equalities and differences
with the corresponding containers of the standard template library.
-In the table of associated types of interval_sets
-there are types like key_type, value_type and key_compare
-for the __iterative__ aspect.
[section Class templates]
@@ -259,13 +256,13 @@
[[] [] [] [`DefaultConstructible<CodomainT> && EqualityComparable<CodomainT>`] ]
[[] [only `add` used ] [`+=`] [`&& Combinable<CodomainT,Combine>`] ]
[[] [... and also `subtract` used] [`-=`] [`&& Combinable<CodomainT,Inverse<Combine> >`]]
-[[] [`Section` used and `CodomainT` is a set][`*=`] [`&& Intersectable<CodomainT,Section>`] ]
+[[] [`Section` used and `CodomainT` is a set][`&=`] [`&& Intersectable<CodomainT,Section>`] ]
]
The requirements on the type `CodomainT` of associated values for a __itl_map__ or __itv_map__
depend on the usage of their aggregation functionality. If aggregation on overlap
is never used, that is to say that none of the addition, subtraction and intersection
-operations (`+, +=, add`, `-, -=, subtract`, *, *=, add_intersection) are used on the
+operations (`+, +=, add`, `-, -=, subtract`, &, &=, add_intersection) are used on the
__itv_map__, then `CodomainT` only needs to be
[@http://www.generic-programming.org/languages/conceptcpp/issues/concepts-closed.html Regular].
['*Regular*]
@@ -323,16 +320,16 @@
[section Associated Types]
[table Associated types of sets
-[[Aspects] [] [type] [interval] [interval_sets] [itl::set] [std::set]]
-[[__conceptual__] [data] [domain_type] [DomainT] [DomainT] [DomainT] []]
-[[] [ordering][domain_compare] [Compare<DomainT>] [Compare<DomainT>] [Compare<DomainT>][]]
-[[iterative] [data] [interval_type] [] [Interval<DomainT,Compare>] [] []]
-[[] [] [key_type] [] [Interval<DomainT,Compare>] [] [_Key]]
-[[] [] [value_type] [] [Interval<DomainT,Compare>] [] [_Key]]
-[[] [ordering][interval_compare][] [exclusive_less <interval_type>][] []]
-[[] [] [key_compare] [] [exclusive_less <interval_type>][] [_Compare]]
-[[__conceptual__] [size] [size_type] [size<DomainT>::type] [interval_type:: size_type] [std::size_t] []]
-[[] [] [difference_type] [difference <DomainT>::type][interval_type:: difference_type][std::size_t] []]
+[[Aspects] [] [type] [__itv__] [__itv_sets__] [__itl_set__] [`std::set`]]
+[[__conceptual__] [data] [`domain_type`] [`DomainT`] [`DomainT`] [`DomainT`] []]
+[[] [ordering][`domain_compare`] [`Compare<DomainT>`] [`Compare<DomainT>`] [`Compare<DomainT>`][]]
+[[__iterative__] [data] [`interval_type`] [] [`Interval<DomainT,Compare>`] [] []]
+[[] [] [`key_type`] [] [`Interval<DomainT,Compare>`] [] [`_Key`]]
+[[] [] [`value_type`] [] [`Interval<DomainT,Compare>`] [] [`_Key`]]
+[[] [ordering][`interval_compare`][] [`exclusive_less <interval_type>`] [] []]
+[[] [] [`key_compare`] [] [`exclusive_less <interval_type>`] [] [`_Compare`]]
+[[__conceptual__] [size] [`size_type`] [`size<DomainT>::type`] [`interval_type:: size_type`] [`std::size_t`] []]
+[[] [] [`difference_type`] [`difference <DomainT>::type`][`interval_type:: difference_type`][`std::size_t`] []]
]
[endsect][/ Associated Types]
@@ -340,60 +337,76 @@
[section Function Matrix]
[table
-[[Placeholder] [Argument types] [Description]]
+[[Placeholder] [Argument types] [Description]]
+[[T ] [] [a container type]]
+[[P ] [] [polymorhical container argument type]]
+[[I,J ] [] [polymorhical iterator type]]
+[[1,2,... ] [] [number of implementations for this function]]
+[[A ] [] [implementation generated by compilers]]
[[[#element_type] [*e]] [T::domain_type] [the element type of the container]]
[[[#interval_type] [*i]] [T::interval_type] [the interval type of the container]]
+[[[#itl_set_type] [*s]] [__itl_set__] [itl's set type]]
[[[#interval_set_types] [*S]] [interval_sets] [one of the interval set types]]
[[[#element_mapping_type] [*b]] [T::element_mapping_type] [type of the element mapping of the map]]
[[[#interval_mapping_type][*p]] [T::interval_mapping_type][type of the interval mapping of the map]]
+[[[#itl_map_type] [*m]] [__itl_map__] [itl's map type]]
[[[#interval_map_types] [*M]] [interval_maps] [one of the interval map types]]
]
+[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]]
-[/ interval itvset itvmap itl:set itl:map std:set std:map]
-[[['*Construct, copy, destruct*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
-[[T()] [1] [1] [1] [1] [1] [1] [1]]
-[[T(const T&)] [A] [1] [1] [1] [1] [1] [1]]
-[[T(const P&)] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
-[[T& operator=(const T&)] [A] [1] [1] [1] [1] [1] [1]]
-[[void swap(T&)] [ ] [1] [1] [1] [1] [1] [1]]
-[[['*Emptieness, containment*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
-[[void clear()] [E] [1] [1] [1] [1] [1] [1]]
-[[bool empty()const] [1] [1] [1] [1] [1] [1] [1]]
-[[bool contains(const P&)const] [__ei] [__eiS][__eiS __bpM][?__e] [?__b] [ ] [ ]]
-[[bool contained_in(const P&)const] [__e] [__S] [__M] [?__e] [?__p] [ ] [ ]]
-[[['*Size*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
-[[size_type size()const] [1] [1] [1] [1] [1] [1] [1]]
-[[size_type cardinality()const] [1] [1] [1] [?] [?] [ ] [ ]]
-[[difference_type length()const] [1] [1] [1] [ ] [ ] [ ] [ ]]
-[[size_t iterative_size()const] [1] [1] [1] [?] [?] [ ] [ ]]
-[[size_t interval_count()const] [1] [1] [1] [ ] [ ] [ ] [ ]]
-[[['*Range*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
-[[domain_type lower()const] [1] [1] [1] [ ] [ ] [ ] [ ]]
-[[domain_type upper()const] [1] [1] [1] [ ] [ ] [ ] [ ]]
-[[['*Addition*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
-[[T& add<F>(const P&, const F&)] [ ] [ ] [__bp] [ ] [?__b] [ ] [ ]]
-[[T& add(const P&)] [ ] [__ei] [__bp] [__e] [__b] [ ] [ ]]
-[[T& operator+=(T&, const P&)] [ ] [__eiS] [__bpM] [?__eS] [?__bM] [ ] [ ]]
-[[['*Subtraction*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
-[[T& subtract<F>(const P&, const F&)][ ] [ ] [__bp] [ ] [?__b] [ ] [ ]]
-[[T& subtract(const P&)] [ ] [__ei] [__bp] [__e] [__b] [ ] [ ]]
-[[T& operator-=(T&, const P&)] [ ] [__eiS] [__bpM] [?__eS] [?__bM] [ ] [ ]]
-[[['*Insertion, erasure*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
-[[T& insert(const P&)] [ ] [__ei] [__bp] [__e] [__b] [?__e] [?__b]]
-[[T& erase(const P&)] [ ] [__eiS][__eiS __bpM][__e] [__b] [?__e] [?__b]]
-[[['*Intersection*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
-[[void intersect(T&, const P&)const] [__i] [__eiS][__eiS __bpM][ ] [ ] [ ] [ ]]
-[[void add_intersection(T&, const P&)const][][__eiS][__eiS __bpM][ ] [ ] [ ] [ ]]
-[[T& operator&=(T&, const P&)] [__i] [__eiS][__eiS __bpM][?__eS][?__bM] [ ] [ ]]
-[[['*Iterator related*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
-[[J begin()] [ ] [2] [2] [2] [2] [2] [2]]
-[[J end()] [ ] [2] [2] [2] [2] [2] [2]]
-[[J rbegin()] [ ] [2] [2] [2] [2] [2] [2]]
-[[J rend()] [ ] [2] [2] [2] [2] [2] [2]]
-[[J lower_bound(const I&)] [ ] [2] [2] [2] [2] [2] [2]]
-[[J upper_bound(const I&)] [ ] [2] [2] [2] [2] [2] [2]]
+[/ interval itvset itvmap itl:set itl:map std:set std:map]
+[[['*Construct, copy, destruct*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
+[[`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(const P&,...)`] [3] [ ] [ ] [3] [3] [3] [3]]
+[[`T& T::operator=(const T&)`] [A] [1] [1] [1] [1] [1] [1]]
+[[`void T::swap(T&)`] [ ] [1] [1] [1] [1] [1] [1]]
+[[['*Emptieness, containment*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
+[[`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`] [__e] [__S] [__M] [__s] [__m] [ ] [ ]]
+[[['*Size*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
+[[`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*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
+[[`domain_type T::lower()const`] [1] [1] [1] [ ] [ ] [ ] [ ]]
+[[`domain_type T::upper()const`] [1] [1] [1] [ ] [ ] [ ] [ ]]
+[[['*Addition*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
+[[`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] [ ] [JODO test]]
+[[`T& operator |=( T&, const P&)`] [ ] [__eiS] [__bpM] [__es] [__bm] [ ] [JODO test]]
+[[`T operator | (const T&, const P&)`] [ ] [__eiS] [__bpM] [__es] [__bm] [ ] [JODO test]]
+[[['*Subtraction*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
+[[`T& T::subtract(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] [ ] [ ]]
+[[['*Insertion, erasure*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
+[[`T& T::insert(const P&)`] [ ] [__ei] [__bp] [__e] [__b] [?__e] [?__b]]
+[[`T& T::set(const P&)`] [ ] [__ei?] [__bp?] [__e?] [__b?] [?__e?] [JODO]]
+[[`T& T::erase(const P&)`] [ ] [__eiS][__eiS __bpM][__e] [__b] [?__e] [?__b]]
+[[['*Intersection, symmetric difference*]][ ] [ ] [ ] [ ] [ ] [ ] [ ]]
+[[`void T::intersect(T&, const P&)const`] [__i] [__eiS][__eiS __bpM][ ] [ ] [ ] [ ]]
+[[`void T::add_intersection(T&, const P&)const`][][__eiS][__eiS __bpM][ ] [ ] [ ] [ ]]
+[[`T& operator &=(T&, const P&)`] [__i] [__eiS][__eiS __bpM][?__es][?__bm] [ ] [JODO]]
+[[`T operator & (const T&, const P&)`] [__i] [__eiS][__eiS __bpM][?__es][?__bm] [ ] [JODO]]
+[[`T& operator ^=(T&, const P&)`] [__i] [__eiS][__eiS __bpM][?__es][?__bm] [ ] [JODO]]
+[[`T operator ^ (const T&, const P&)`] [__i] [__eiS][__eiS __bpM][?__es][?__bm] [ ] [JODO]]
+[[['*Iterator related*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
+[[`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]]
]
[endsect]
Modified: sandbox/itl/libs/itl/doc/itl.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/itl.qbk (original)
+++ sandbox/itl/libs/itl/doc/itl.qbk 2009-01-13 15:43:44 EST (Tue, 13 Jan 2009)
@@ -91,14 +91,18 @@
[def __itv_bse_set__ [classref boost::itl::interval_base_set interval_base_set]]
[def __e [link element_type *e*]]
[def __i [link interval_type *i*]]
+[def __s [link itl_set_type *s*]]
[def __S [link interval_set_types *S*]]
[def __b [link element_mapping_type *b*]]
[def __p [link interval_mapping_type *p*]]
+[def __m [link itl_map_type *m*]]
[def __M [link interval_map_types *M*]]
[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*]]
+[def __es [link element_type *e*] [link itl_set_type *s*]]
[def __bM [link element_mapping_type *b*] [link interval_map_types *M*]]
+[def __bm [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*]]
Modified: sandbox/itl/libs/itl/test/test_itl_interval/test_itl_interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_interval/test_itl_interval.cpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_interval/test_itl_interval.cpp 2009-01-13 15:43:44 EST (Tue, 13 Jan 2009)
@@ -225,7 +225,7 @@
}
-BOOST_AUTO_TEST_CASE_TEMPLATE(test_itl_interval_intersect_4_bicremental_types, T, bicremental_types)
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_itl_interval_inplace_intersect_4_bicremental_types, T, bicremental_types)
{
T v0 = make<T>(0);
T v3 = make<T>(3);
@@ -270,3 +270,77 @@
BOOST_CHECK_EQUAL( I3_7D.is_disjoint(I7_9I), true );
BOOST_CHECK_EQUAL( section.empty(), true );
}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_itl_interval_infix_intersect_4_bicremental_types, T, bicremental_types)
+{
+ T v0 = make<T>(0);
+ T v3 = make<T>(3);
+ T v4 = make<T>(4);
+ T v5 = make<T>(5);
+ T v6 = make<T>(6);
+ T v7 = make<T>(7);
+ T v9 = make<T>(9);
+
+ interval<T> section;
+ interval<T> I3_7D = interval<T>::rightopen(v3,v7);
+
+ interval<T> I0_3D = interval<T>::rightopen(v0,v3);
+ section = I3_7D & I0_3D;
+ BOOST_CHECK_EQUAL( I0_3D.is_disjoint(I3_7D), true );
+ BOOST_CHECK_EQUAL( section.empty(), true );
+ BOOST_CHECK_EQUAL( section, interval<T>() );
+
+ interval<T> I0_5D = interval<T>::rightopen(v0,v5);
+ section = I3_7D & I0_5D;
+ BOOST_CHECK_EQUAL( section, interval<T>::rightopen(v3, v5) );
+
+ interval<T> I0_9D = interval<T>::rightopen(v0,v9);
+ section = I3_7D & I0_9D;
+ BOOST_CHECK_EQUAL( section, I3_7D );
+
+ interval<T> I4_5I = interval<T>::closed(v4,v5);
+ section = I3_7D & I4_5I;
+ BOOST_CHECK_EQUAL( section, I4_5I );
+
+ interval<T> C4_6D = interval<T>::open(v4,v6);
+ section = I3_7D & C4_6D;
+ BOOST_CHECK_EQUAL( section, C4_6D );
+
+ interval<T> C4_9I = interval<T>::leftopen(v4,v9);
+ section = I3_7D & C4_9I;
+ BOOST_CHECK_EQUAL( section, interval<T>::open(v4,v7) );
+
+ interval<T> I7_9I = interval<T>::closed(v7,v9);
+ section = I3_7D & I7_9I;
+ BOOST_CHECK_EQUAL( I3_7D.exclusive_less(I7_9I), true );
+ BOOST_CHECK_EQUAL( I3_7D.is_disjoint(I7_9I), true );
+ BOOST_CHECK_EQUAL( section.empty(), true );
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_itl_interval_subtract_4_bicremental_types, T, bicremental_types)
+{
+ T v0 = make<T>(0);
+ T v2 = make<T>(2);
+ T v3 = make<T>(3);
+ T v4 = make<T>(4);
+ T v5 = make<T>(5);
+ T v6 = make<T>(6);
+ T v7 = make<T>(7);
+ T v9 = make<T>(9);
+
+ interval<T> diff_1, diff_2;
+ interval<T> I0_3D = interval<T>::rightopen(v0,v3);
+ interval<T> I2_6D = interval<T>::rightopen(v2,v6);
+ interval<T> I4_7D = interval<T>::rightopen(v4,v7);
+ interval<T> I2_4D = interval<T>::rightopen(v2,v4);
+ I2_6D.left_surplus(diff_1,I4_7D);
+ BOOST_CHECK_EQUAL( diff_1, I2_4D );
+ //diff_2 = I2_6D;
+ //diff_2.left_subtract(I4_7D);
+ //BOOST_CHECK_EQUAL( diff_2, I2_4D );
+
+ diff_1.clear();
+ I0_3D.left_surplus(diff_1,I4_7D);
+ BOOST_CHECK_EQUAL( diff_1, I0_3D );
+
+}