[Boost-commit] svn:boost r50342 - in sandbox/itl: boost/itl libs/itl/example/boost_party libs/itl/test

Subject: [Boost-commit] svn:boost r50342 - in sandbox/itl: boost/itl libs/itl/example/boost_party libs/itl/test
From: afojgo_at_[hidden]
Date: 2008-12-21 06:38:13

Author: jofaber
Date: 2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
New Revision: 50342
URL: http://svn.boost.org/trac/boost/changeset/50342

Log:
Refactored: For Maps: Added template parameter ITL_SECTION Section. Moved template parameter Interval before Alloc. 
Stable {msvc-9.0, partly congcc-4.3-a7}
Text files modified: 
   sandbox/itl/boost/itl/interval_base_map.hpp              |   165 ++++++------                            
   sandbox/itl/boost/itl/interval_map.hpp                   |   119 ++++----                                
   sandbox/itl/boost/itl/interval_maps.hpp                  |   519 ++++++++++++++++++++------------------- 
   sandbox/itl/boost/itl/map.hpp                            |    91 +++---                                  
   sandbox/itl/boost/itl/notate.hpp                         |    13 +                                       
   sandbox/itl/boost/itl/rational.hpp                       |     4                                         
   sandbox/itl/boost/itl/split_interval_map.hpp             |    85 +++---                                  
   sandbox/itl/libs/itl/example/boost_party/boost_party.cpp |     2                                         
   sandbox/itl/libs/itl/test/test_interval_map_shared.hpp   |    33 +                                       
   9 files changed, 530 insertions(+), 501 deletions(-)

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	2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -140,10 +140,10 @@
     typename DomainT,
     typename CodomainT,
     class Traits = itl::neutron_absorber,
-    template<class,ITL_COMPARE>class Interval = itl::interval,
     ITL_COMPARE Compare  = ITL_COMPARE_INSTANCE(std::less, DomainT),
         ITL_COMBINE Combine  = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
-	//ITL_SECTION Section= ITL_SECTION_INSTANCE(itl::inplace_et, CodomainT), 
+	ITL_SECTION Section  = ITL_SECTION_INSTANCE(itl::inplace_star, CodomainT), 
+    template<class,ITL_COMPARE>class Interval = itl::interval,
     ITL_ALLOC   Alloc    = std::allocator
 >
 #ifdef USE_CONCEPTS
@@ -160,11 +160,11 @@
     typedef SubType sub_type;
 
     typedef interval_base_map<SubType,DomainT,CodomainT,
-                              Traits,Interval,Compare,Combine,Alloc>
+                              Traits,Compare,Combine,Section,Interval,Alloc>
                               type;
 
     typedef interval_base_map<SubType,DomainT,CodomainT,
-                              itl::neutron_absorber,Interval,Compare,Combine,Alloc>
+                              itl::neutron_absorber,Compare,Combine,Section,Interval,Alloc>
                               neutron_absorber_type;
 
     /// Domain type (type of the keys) of the map
@@ -188,6 +188,9 @@
     typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
     /// Combine functor for codomain values
     typedef ITL_COMBINE_CODOMAIN(Combine,CodomainT) codomain_combine;
+    /// Intersection functor for codomain values
+    typedef ITL_SECTION_CODOMAIN(Section,CodomainT) codomain_intersect;
+
     /// Comparison functor for intervals which are keys as well
     typedef exclusive_less<interval_type> interval_compare;
 
@@ -200,7 +203,7 @@
 
     /// Container type for the implementation 
     typedef itl::map<interval_type,codomain_type,Traits,
-                     ITL_EXCLUSIVE_LESS(interval_type),Combine,Alloc> ImplMapT;
+                     ITL_EXCLUSIVE_LESS(interval_type),Combine,Section,Alloc> ImplMapT;
 
     /// key type of the implementing container
     typedef typename ImplMapT::key_type   key_type;
@@ -224,7 +227,7 @@
 
     /// The atomized type is elementbased map that is equivalent to the interval map
     typedef typename itl::map<DomainT,CodomainT,
-                              Traits,Compare,Combine,Alloc> atomized_type;
+                              Traits,Compare,Combine,Section,Alloc> atomized_type;
 //@}
         
 public:
@@ -653,16 +656,16 @@
     <
         template
         <    
-            class DomT, class CodomT, 
-            class Trts, template<class DomT2,ITL_COMPARE>class Interv, 
-            ITL_COMPARE Comp, ITL_COMBINE Combi, ITL_ALLOC Allc
+            class DomT, class CodomT, class Trts, 
+            ITL_COMPARE Comp, ITL_COMBINE Combi, ITL_SECTION Sect,
+            template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc
         >
         class IntervalMap
     >
     void add_intersection
     (
         interval_base_map& intersection,
-        const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& sectant
+        const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& sectant
     )const;
 
 //@}
@@ -856,13 +859,13 @@
 template 
 <
     class SubType, class DomainT, class CodomainT, class Traits, 
-    template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, 
-    ITL_COMBINE Combine, ITL_ALLOC Alloc
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, 
+    template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
 typename interval_base_map<SubType,DomainT,CodomainT,Traits,
-                           Interval,Compare,Combine,Alloc>::size_type 
+                           Compare,Combine,Section,Interval,Alloc>::size_type 
 interval_base_map<SubType,DomainT,CodomainT,Traits,
-                  Interval,Compare,Combine,Alloc>::cardinality()const
+                  Compare,Combine,Section,Interval,Alloc>::cardinality()const
 {
     using namespace boost::mpl;
     return if_<
@@ -876,13 +879,13 @@
 template 
 <
     class SubType, class DomainT, class CodomainT, class Traits, 
-    template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, 
-    ITL_COMBINE Combine, ITL_ALLOC Alloc
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, 
+    template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
 typename interval_base_map<SubType,DomainT,CodomainT,Traits,
-                           Interval,Compare,Combine,Alloc>::difference_type 
+                           Compare,Combine,Section,Interval,Alloc>::difference_type 
 interval_base_map<SubType,DomainT,CodomainT,Traits,
-                  Interval,Compare,Combine,Alloc>::length()const
+                  Compare,Combine,Section,Interval,Alloc>::length()const
 {
     difference_type length = neutron<difference_type>::value();
     const_FOR_IMPLMAP(it)
@@ -896,9 +899,9 @@
 template 
 <
     class SubType,
-    class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
-bool interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::contained_in(const interval_base_map& super)const
+bool interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::contained_in(const interval_base_map& super)const
 {
     // x2 should be larger than *this; so every element in this should be in x2
     const_FOR_IMPLMAP(it) 
@@ -911,29 +914,29 @@
 template 
 <
     class SubType,
-    class DomainT, class CodomainT, 
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class DomainT, class CodomainT, class Traits, 
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, 
+    template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
     template
     <
         template
         <    
-            class DomT, class CodomT, 
-            class Trts, template<class DomT2,ITL_COMPARE>class Interv, 
-            ITL_COMPARE Comp, ITL_COMBINE Combi, ITL_ALLOC Allc
+            class DomT, class CodomT, class Trts, 
+            ITL_COMPARE Comp, ITL_COMBINE Combi, ITL_SECTION Sect,
+            template<class DomT2,ITL_COMPARE>class Interv, ITL_ALLOC Allc
         >
         class IntervalMap
     >
-void interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::add_intersection
 (
     interval_base_map& intersection,
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& sectant
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& sectant
 )const
 {
     typedef IntervalMap<DomainT,CodomainT,
-                        Traits,Interval,Compare,Combine,Alloc> sectant_type;
+                        Traits,Compare,Combine,Section,Interval,Alloc> sectant_type;
     if(sectant.empty()) 
         return;
     typename sectant_type::const_iterator common_lwb;
@@ -948,11 +951,11 @@
 template 
 <
     class SubType,
-    class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
-void interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::add_intersection(interval_base_map& section, 
-                    const typename interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+                    const typename interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
                     ::value_type& sectant)const
 {
     interval_type sectant_interval = sectant.KEY_VALUE;
@@ -981,11 +984,11 @@
 template 
 <
     class SubType,
-    class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
-void interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::add_intersection(interval_base_map& section, 
-                    const typename interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+                    const typename interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
                     ::interval_type& sectant_interval)const
 {
     if(sectant_interval.empty()) return;
@@ -1008,9 +1011,9 @@
 template 
 <
     class SubType,
-    class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::join()
 {
     iterator it=_map.begin();
@@ -1057,9 +1060,9 @@
 template 
 <
     class SubType,
-    class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
-std::string interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::as_string()const
+std::string interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::as_string()const
 {
     std::string res(""); 
     const_FOR_IMPLMAP(it) {
@@ -1077,9 +1080,9 @@
 template 
 <
     class SubType,
-    class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
-CodomainT interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::sum()const
+CodomainT interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::sum()const
 {
     CodomainT sum = CodomainT();
     const_FOR_IMPLMAP(it) 
@@ -1091,9 +1094,9 @@
 template 
 <
     class SubType,
-    class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
-void interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::uniformBounds( typename interval<DomainT>::bound_types bt)
+void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::uniformBounds( typename interval<DomainT>::bound_types bt)
 {
     // I can do this only, because I am shure that the contents and the
     // ordering < on interval is invariant wrt. this transformation on bounds
@@ -1103,9 +1106,9 @@
 template 
 <
     class SubType,
-    class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
-void interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::closeLeftBounds()
+void interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::closeLeftBounds()
 {
     // I can do this only, because I am shure that the contents and the
     // ordering < on interval is invariant wrt. this transformation on bounds
@@ -1117,9 +1120,9 @@
 template 
 <
     class SubType,
-    class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
-SubType& interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+SubType& interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::erase(const interval_type& x_itv)
 {
     if(x_itv.empty()) return *that();
@@ -1155,10 +1158,10 @@
 template 
 <
     class SubType,
-    class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
 SubType& 
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::erase(const interval_base_map& erasure)
 {
     const_FORALL(typename interval_base_map, value_pair_, erasure)
@@ -1179,10 +1182,10 @@
 template 
 <
     class SubType,
-    class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
-inline bool operator == (const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& lhs,
-                         const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& rhs)
+inline bool operator == (const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
+                         const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
 {
     //MEMO PORT: This implemetation worked with stlport, sgi and gnu 
     // implementations of the stl. But using MSVC-implementation
@@ -1195,13 +1198,13 @@
 template 
 <
     class SubType,
-    class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
-inline bool is_protonic_equal(const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& lhs,
-                              const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& rhs)
+inline bool is_protonic_equal(const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
+                              const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
 {
-    interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> lhs0 = lhs;
-    interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> rhs0 = rhs;
+    interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> lhs0 = lhs;
+    interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> rhs0 = rhs;
 
     lhs0.absorb_neutrons();
     rhs0.absorb_neutrons();
@@ -1216,10 +1219,10 @@
 template 
 <
     class SubType,
-    class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
-inline bool operator < (const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& lhs,
-                        const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& rhs)
+inline bool operator < (const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
+                        const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
 {
     return std::lexicographical_compare(
         lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), 
@@ -1230,10 +1233,10 @@
 template 
 <
     class SubType,
-    class DomainT, class CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
-inline bool operator <= (const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& lhs,
-                        const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& rhs)
+inline bool operator <= (const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
+                        const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
 {
     return lhs < rhs || lhs == rhs;
 }
@@ -1244,22 +1247,22 @@
 template 
 <
     class SubType,
-    class DomainT, class CodomainT, 
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class DomainT, class CodomainT, class Traits, 
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, 
+    template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
 interval_base_map<SubType,DomainT,CodomainT,
-                  Traits,Interval,Compare,Combine,Alloc>& 
+                  Traits,Compare,Combine,Section,Interval,Alloc>& 
 min_assign
 (
           interval_base_map<SubType,DomainT,CodomainT,
-                            Traits,Interval,Compare,Combine,Alloc>& object,
+                            Traits,Compare,Combine,Section,Interval,Alloc>& object,
     const interval_base_map<SubType,DomainT,CodomainT,
-                            Traits,Interval,Compare,Combine,Alloc>& operand
+                            Traits,Compare,Combine,Section,Interval,Alloc>& operand
 )
 {
     typedef interval_base_map<SubType,DomainT,CodomainT,
-                              Traits,Interval,Compare,Combine,Alloc> map_type;
+                              Traits,Compare,Combine,Section,Interval,Alloc> map_type;
     const_FORALL(typename map_type, elem_, operand) 
         object.template add<inplace_min >(*elem_); 
 
@@ -1269,22 +1272,22 @@
 template 
 <
     class SubType,
-    class DomainT, class CodomainT, 
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class DomainT, class CodomainT, class Traits, 
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, 
+    template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
 interval_base_map<SubType,DomainT,CodomainT,
-                  Traits,Interval,Compare,Combine,Alloc>& 
+                  Traits,Compare,Combine,Section,Interval,Alloc>& 
 max_assign
 (
           interval_base_map<SubType,DomainT,CodomainT,
-                            Traits,Interval,Compare,Combine,Alloc>& object,
+                            Traits,Compare,Combine,Section,Interval,Alloc>& object,
     const interval_base_map<SubType,DomainT,CodomainT,
-                            Traits,Interval,Compare,Combine,Alloc>& operand
+                            Traits,Compare,Combine,Section,Interval,Alloc>& operand
 )
 {
     typedef interval_base_map<SubType,DomainT,CodomainT,
-                              Traits,Interval,Compare,Combine,Alloc>    map_type;
+                              Traits,Compare,Combine,Section,Interval,Alloc>    map_type;
     const_FORALL(typename map_type, elem_, operand) 
         object.template add<inplace_max>(*elem_); 
 
@@ -1295,15 +1298,15 @@
 
 template<class CharType, class CharTraits, 
     class SubType, class DomainT, class CodomainT, class Traits, 
-    template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, 
-    ITL_COMBINE Combine, ITL_ALLOC Alloc>
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, 
+    template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
 std::basic_ostream<CharType, CharTraits>& operator <<
   (std::basic_ostream<CharType, CharTraits>& stream, 
    const interval_base_map<SubType,DomainT,CodomainT,Traits,
-                           Interval,Compare,Combine,Alloc>& object)
+                           Compare,Combine,Section,Interval,Alloc>& object)
 {
     typedef interval_base_map<SubType,DomainT,CodomainT,
-                              Traits,Interval,Compare,Combine,Alloc> IntervalMapT;
+                              Traits,Compare,Combine,Section,Interval,Alloc> IntervalMapT;
     stream << "{";
     const_FORALL(typename IntervalMapT, it, object)
         stream << "(" << (*it).KEY_VALUE << "->" << (*it).CONT_VALUE << ")";

Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp	(original)
+++ sandbox/itl/boost/itl/interval_map.hpp	2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -107,24 +107,25 @@
     typename DomainT,
     typename CodomainT,
     class Traits = itl::neutron_absorber,
-    template<class,ITL_COMPARE>class Interval = itl::interval,
     ITL_COMPARE Compare  = ITL_COMPARE_INSTANCE(std::less, DomainT),
     ITL_COMBINE Combine  = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
+	ITL_SECTION Section  = ITL_SECTION_INSTANCE(itl::inplace_star, CodomainT), 
+    template<class,ITL_COMPARE>class Interval = itl::interval,
     ITL_ALLOC   Alloc    = std::allocator
 >
 class interval_map:
 
-    public interval_base_map<interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>, 
-                             DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+    public interval_base_map<interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>, 
+                             DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
 {
 public:
     typedef Traits traits;
-    typedef interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> type;
+    typedef interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> type;
     typedef type joint_type;
-    typedef interval_base_map <interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>, 
-                               DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> base_type;
+    typedef interval_base_map <interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>, 
+                               DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> base_type;
 
-    typedef interval_map<DomainT,CodomainT,itl::neutron_absorber,Interval,Compare,Combine,Alloc>
+    typedef interval_map<DomainT,CodomainT,itl::neutron_absorber,Compare,Combine,Section,Interval,Alloc>
             neutron_absorber_type;
 
     typedef Interval<DomainT,Compare> interval_type;
@@ -149,7 +150,7 @@
     template<class SubType>
     explicit interval_map
         (const interval_base_map<SubType,DomainT,CodomainT,
-                                 Traits,Interval,Compare,Combine,Alloc>& src)
+                                 Traits,Compare,Combine,Section,Interval,Alloc>& src)
     { assign(src); }
 
     explicit interval_map(mapping_pair_type& base_pair): base_type()
@@ -162,16 +163,16 @@
     template<class SubType>
     interval_map& operator =
         (const interval_base_map<SubType,DomainT,CodomainT,
-                                 Traits,Interval,Compare,Combine,Alloc>& src)
+                                 Traits,Compare,Combine,Section,Interval,Alloc>& src)
     { assign(src); return *this; }
 
     /// Assignment from a base interval_map.
     template<class SubType>
     void assign(const interval_base_map<SubType,DomainT,CodomainT,
-                                        Traits,Interval,Compare,Combine,Alloc>& src)
+                                        Traits,Compare,Combine,Section,Interval,Alloc>& src)
     {
         typedef interval_base_map<SubType,DomainT,CodomainT,
-                                  Traits,Interval,Compare,Combine,Alloc> base_map_type;
+                                  Traits,Compare,Combine,Section,Interval,Alloc> base_map_type;
         this->clear();
         // Can be implemented via _map.insert: Interval joining not necessary.
         const_FORALL(typename base_map_type, it, src) 
@@ -185,8 +186,8 @@
         // that()->funx_. So they must be either public or made accessible by a
         // friend declaration:
         friend class
-        interval_base_map <interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>, 
-                                        DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>;
+        interval_base_map <interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>, 
+                                        DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>;
 
     bool contains_(const value_type& x)const;
 
@@ -242,8 +243,8 @@
 } ;
 
 
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-bool interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+bool interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::contains_(const value_type& interv_value)const
 {
     interval_type interv = interv_value.KEY_VALUE;
@@ -257,8 +258,8 @@
 
 
 template <typename DomainT, typename CodomainT, class Traits,
-          template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-bool interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+bool interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::joinable(const iterator& some, const iterator& next)const
 {
     // assert: next != end && some++ == next
@@ -267,9 +268,9 @@
 }
 
 template <typename DomainT, typename CodomainT, class Traits,
-          template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-typename interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::iterator 
-    interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator 
+    interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::joint_insert(iterator& left_it, const iterator& right_it)
 {
     // both left and right are in the set and they are neighbours
@@ -297,8 +298,8 @@
 
 
 template <typename DomainT, typename CodomainT, class Traits,
-          template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-bool interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+bool interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::join_left(iterator& it)
 {
     if(it == this->_map.begin())
@@ -319,8 +320,8 @@
 }
 
 template <typename DomainT, typename CodomainT, class Traits,
-          template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-bool interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+bool interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::join_right(iterator& it)
 {
     if(it == this->_map.end())
@@ -341,9 +342,9 @@
 
 
 template <typename DomainT, typename CodomainT, class Traits,
-          template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-typename interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::iterator
-interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
+interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::fill_join_left(const value_type& value)
 {
     //collision free insert is asserted
@@ -360,9 +361,9 @@
 }
 
 template <typename DomainT, typename CodomainT, class Traits,
-          template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-typename interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::iterator
-interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
+interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::fill_join_both(const value_type& value)
 {
     //collision free insert is asserted
@@ -380,10 +381,10 @@
 
 //-----------------------------------------------------------------------------
 template <typename DomainT, typename CodomainT, class Traits,
-          template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
     template<class Combiner>
-typename interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::iterator
-interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
+interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::fill_gap_join_left(const value_type& value)
 {
     //collision free insert is asserted
@@ -411,10 +412,10 @@
 }
 
 template <typename DomainT, typename CodomainT, class Traits,
-          template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
     template<class Combiner>
-typename interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::iterator
-interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+typename interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::iterator
+interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::fill_gap_join_both(const value_type& value)
 {
     //collision free insert is asserted
@@ -445,9 +446,9 @@
 //-----------------------------------------------------------------------------
 // add<Combinator>(pair(interval,value)):
 //-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
     template<class Combiner>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::add_(const value_type& x)
 {
     const interval_type& x_itv = x.KEY_VALUE;
@@ -547,9 +548,9 @@
     }
 }
 
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
     template<class Combiner>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::add_rest(const interval_type& x_itv, const CodomainT& x_val, iterator& it, iterator& end_it)
 {
     iterator nxt_it = it; nxt_it++;
@@ -580,9 +581,9 @@
     add_rear<Combiner>(x_rest, x_val, it);
 }
 
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
     template<class Combiner>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::add_rear(const interval_type& x_rest, const CodomainT& x_val, iterator& it)
 {
     interval_type cur_itv = (*it).KEY_VALUE ;
@@ -622,9 +623,9 @@
 //-----------------------------------------------------------------------------
 // subtract<Combinator>(pair(interval,value)):
 //-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
     template<class Combiner>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::subtract_(const value_type& x)
 {
     const interval_type& x_itv = x.KEY_VALUE;
@@ -691,9 +692,9 @@
 
 
 
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
     template<class Combiner>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::subtract_rest(const interval_type& x_itv, const CodomainT& x_val, iterator& it, iterator& end_it)
 {
     iterator nxt_it=it; nxt_it++;
@@ -762,9 +763,9 @@
 //-----------------------------------------------------------------------------
 // insert(pair(interval,value)):
 //-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, 
-          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits,
+          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::insert_(const value_type& x)
 {
     const interval_type& x_itv = x.KEY_VALUE;
@@ -827,9 +828,9 @@
 }
 
 
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, 
-          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits,
+          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::insert_rest(const interval_type& x_itv, const CodomainT& x_val, 
                   iterator& it, iterator& end_it)
 {
@@ -855,9 +856,9 @@
     insert_rear(x_rest, x_val, it);
 }
 
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, 
-          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits,
+          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::insert_rear(const interval_type& x_rest, const CodomainT& x_val, 
                   iterator& it)
 {
@@ -886,8 +887,8 @@
 //-----------------------------------------------------------------------------
 // erase(pair(interval,value)):
 //-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::erase_(const value_type& x)
 {
     const interval_type& x_itv = x.KEY_VALUE;
@@ -945,8 +946,8 @@
 }
 
 
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::erase_rest(const interval_type& x_itv, const CodomainT& x_val, 
                  iterator& it, iterator& end_it)
 {

Modified: sandbox/itl/boost/itl/interval_maps.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_maps.hpp	(original)
+++ sandbox/itl/boost/itl/interval_maps.hpp	2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -16,8 +16,8 @@
 
 template
 <    
-    class, class, class, template<class,ITL_COMPARE>class, 
-    ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+    class, class, class, 
+    ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
 >
 class interval_map;
 
@@ -25,27 +25,53 @@
 //-----------------------------------------------------------------------------
 // addition +=
 //-----------------------------------------------------------------------------
+/*CL
 template 
 <
-    class SubType, class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class SubType, class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& 
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& 
 operator +=
 (
-          interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+          interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
+)
+{
+    typedef IntervalMap<DomainT,CodomainT,
+                        Traits,Compare,Combine,Section,Interval,Alloc> operand_type;
+    const_FORALL(typename operand_type, elem_, operand) 
+        object.add(*elem_); 
+
+    return object; 
+}
+*/
+template 
+<
+	class ObjectT,
+    class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
+    template
+    <
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
+    >
+    class IntervalMap
+>
+ObjectT& operator +=
+(
+          ObjectT& object,
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
 )
 {
     typedef IntervalMap<DomainT,CodomainT,
-                        Traits,Interval,Compare,Combine,Alloc> operand_type;
+                        Traits,Compare,Combine,Section,Interval,Alloc> operand_type;
     const_FORALL(typename operand_type, elem_, operand) 
         object.add(*elem_); 
 
@@ -54,49 +80,47 @@
 
 template 
 <
-    class SubType, class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class SubType, class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> 
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> 
 operator +
 (
-    const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+    const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
 )
 {
-	typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+	typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
         return ObjectT(object) += operand; 
 }
 //-----------------------------------------------------------------------------
 
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& 
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& 
 operator +=
 (
-          IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+          IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
 )
 {
     typedef IntervalMap<DomainT,CodomainT,
-                        Traits,Interval,Compare,Combine,Alloc> operand_type;
+                        Traits,Compare,Combine,Section,Interval,Alloc> operand_type;
     const_FORALL(typename operand_type, elem_, operand) 
         object.add(*elem_); 
 
@@ -105,24 +129,24 @@
 
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+ 
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
 operator +
 (
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
 )
 {
-	typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+	typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
         return ObjectT(object) += operand; 
 }
 //-----------------------------------------------------------------------------
@@ -130,22 +154,22 @@
 //--- value_type --------------------------------------------------------------
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+ 
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& 
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& 
 operator +=
 (
-          IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
+          IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
     const typename 
-          IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::value_type& operand
+          IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::value_type& operand
 )
 {
     return object.add(operand); 
@@ -153,24 +177,24 @@
 
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+ 
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> 
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> 
 operator +
 (
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::value_type& operand
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::value_type& operand
 )
 {
-	typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+	typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
         return ObjectT(object) += operand; 
 }
 //-----------------------------------------------------------------------------
@@ -192,21 +216,21 @@
 */
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+ 
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& 
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& 
 operator +=
 (
-          IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::mapping_pair_type& operand
+          IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::mapping_pair_type& operand
 )
 {
     return object.add(operand); 
@@ -214,24 +238,24 @@
 
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+ 
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
 operator +
 (
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::mapping_pair_type& operand
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::mapping_pair_type& operand
 )
 {
-	typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+	typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
         return ObjectT(object) += operand; 
 }
 //-----------------------------------------------------------------------------
@@ -241,25 +265,25 @@
 //-----------------------------------------------------------------------------
 template 
 <
-    class SubType, class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class SubType, class DomainT, class CodomainT, class Traits,
+ 
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& 
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& 
 operator -=
 (
-          interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+          interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
 )
 {
     typedef IntervalMap<DomainT,CodomainT,
-                        Traits,Interval,Compare,Combine,Alloc> operand_type;
+                        Traits,Compare,Combine,Section,Interval,Alloc> operand_type;
     const_FORALL(typename operand_type, elem_, operand) 
         object.subtract(*elem_); 
 
@@ -268,49 +292,47 @@
 
 template 
 <
-    class SubType, class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class SubType, class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
 operator -
 (
-    const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+    const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
 )
 {
-	typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+	typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
         return ObjectT(object) += operand; 
 }
 //-----------------------------------------------------------------------------
 
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& 
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& 
 operator -=
 (
-          IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+          IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
 )
 {
     typedef IntervalMap<DomainT,CodomainT,
-                        Traits,Interval,Compare,Combine,Alloc> operand_type;
+                        Traits,Compare,Combine,Section,Interval,Alloc> operand_type;
     const_FORALL(typename operand_type, elem_, operand) 
         object.subtract(*elem_); 
 
@@ -319,24 +341,23 @@
 
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
 operator -
 (
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
 )
 {
-	typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+	typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
         return ObjectT(object) -= operand; 
 }
 //-----------------------------------------------------------------------------
@@ -356,21 +377,20 @@
 */
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& 
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& 
 operator -=
 (
-          IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::value_type& operand
+          IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::value_type& operand
 )
 {
     return object.subtract(operand); 
@@ -378,24 +398,23 @@
 
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
 operator -
 (
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::value_type& operand
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::value_type& operand
 )
 {
-	typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+	typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
         return ObjectT(object) -= operand; 
 }
 //-----------------------------------------------------------------------------
@@ -404,21 +423,20 @@
 //--- mapping_type ---------------------------------------------------------
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& 
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& 
 operator -=
 (
-          IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::mapping_pair_type& operand
+          IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::mapping_pair_type& operand
 )
 {
     return object.subtract(operand); 
@@ -426,24 +444,23 @@
 
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
 operator -
 (
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::mapping_pair_type& operand
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::mapping_pair_type& operand
 )
 {
-	typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+	typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
         return ObjectT(object) -= operand; 
 }
 //-----------------------------------------------------------------------------
@@ -453,9 +470,8 @@
 //-----------------------------------------------------------------------------
 template 
 <
-    class SubType, class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class SubType, class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
         class, template<class,ITL_COMPARE>class, 
@@ -463,10 +479,10 @@
     >
     class IntervalSet
 >
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& 
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& 
 operator -=
 (
-          interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
+          interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
     const IntervalSet<DomainT,Interval,Compare,Alloc>& erasure
 )
 {
@@ -479,9 +495,8 @@
 
 template 
 <
-    class SubType, class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class SubType, class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
         class, template<class,ITL_COMPARE>class, 
@@ -489,14 +504,14 @@
     >
     class IntervalSet
 >
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
 operator -
 (
-    const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
+    const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
     const IntervalSet<DomainT,Interval,Compare,Alloc>& operand
 )
 {
-	typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+	typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
         return ObjectT(object) -= operand; 
 }
 //-----------------------------------------------------------------------------
@@ -504,21 +519,20 @@
 //--- value_type --------------------------------------------------------------
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& 
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& 
 operator -=
 (
-          IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::interval_type& operand
+          IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::interval_type& operand
 )
 {
     return object.erase(operand); 
@@ -526,24 +540,23 @@
 
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> 
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> 
 operator -
 (
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::interval_type& operand
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::interval_type& operand
 )
 {
-	typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+	typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
         return ObjectT(object) -= operand; 
 }
 //-----------------------------------------------------------------------------
@@ -554,16 +567,15 @@
 //-----------------------------------------------------------------------------
 template 
 <
-    class SubType, class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class SubType, class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     class OperandT
 >
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& 
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& 
 insert
 (
           interval_base_map<SubType,DomainT,CodomainT,
-                            Traits,Interval,Compare,Combine,Alloc>& object,
+                            Traits,Compare,Combine,Section,Interval,Alloc>& object,
     const OperandT& operand
 )
 {
@@ -577,16 +589,15 @@
 //-----------------------------------------------------------------------------
 template 
 <
-    class SubType, class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class SubType, class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     class OperandT
 >
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& 
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& 
 erase
 (
           interval_base_map<SubType,DomainT,CodomainT,
-                            Traits,Interval,Compare,Combine,Alloc>& object,
+                            Traits,Compare,Combine,Section,Interval,Alloc>& object,
     const OperandT& operand
 )
 {
@@ -600,21 +611,20 @@
 //-----------------------------------------------------------------------------
 template 
 <
-    class SubType, class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class SubType, class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     class SectanT
 >
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& 
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& 
 operator *=
 (
           interval_base_map<SubType,DomainT,CodomainT,
-                            Traits,Interval,Compare,Combine,Alloc>& object,
+                            Traits,Compare,Combine,Section,Interval,Alloc>& object,
     const SectanT& operand
 )
 {
     typedef interval_base_map<SubType,DomainT,CodomainT,
-                              Traits,Interval,Compare,Combine,Alloc> object_type;
+                              Traits,Compare,Combine,Section,Interval,Alloc> object_type;
     object_type intersection;
     object.add_intersection(intersection,operand);
     object.swap(intersection);
@@ -623,44 +633,42 @@
 
 template 
 <
-    class SubType, class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class SubType, class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     class SectanT
 >
-interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
 operator *
 (
-    const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
+    const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
     const SectanT& operand
 )
 {
-	typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+	typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
         return ObjectT(object) *= operand; 
 }
 //-----------------------------------------------------------------------------
 
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
         template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& 
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& 
 operator *=
 (
-          IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+          IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
 )
 {
     typedef IntervalMap<DomainT,CodomainT,
-                        Traits,Interval,Compare,Combine,Alloc> object_type;
+                        Traits,Compare,Combine,Section,Interval,Alloc> object_type;
     object_type intersection;
     object.add_intersection(intersection,operand);
     object.swap(intersection);
@@ -669,24 +677,23 @@
 
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
         template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> 
+IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> 
 operator *
 (
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
-    const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
+    const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
 )
 {
-	typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+	typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
         return ObjectT(object) *= operand; 
 }
 //-----------------------------------------------------------------------------
@@ -696,28 +703,27 @@
 //-----------------------------------------------------------------------------
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class LeftIntervalMap,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class RightIntervalMap
 >
 bool is_element_equal
 (
     const LeftIntervalMap <DomainT,CodomainT,
-                           Traits,Interval,Compare,Combine,Alloc>& left,
+                           Traits,Compare,Combine,Section,Interval,Alloc>& left,
     const RightIntervalMap<DomainT,CodomainT,
-                           Traits,Interval,Compare,Combine,Alloc>& right
+                           Traits,Compare,Combine,Section,Interval,Alloc>& right
 )
 {
     return Interval_Set::is_element_equal(left, right);
@@ -731,13 +737,12 @@
 //--- IntervalMap -------------------------------------------------------------
 template 
 <
-    class SubType, class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class SubType, class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
@@ -745,15 +750,15 @@
 bool is_disjoint
 (
           interval_base_map<SubType,DomainT,CodomainT,
-                            Traits,Interval,Compare,Combine,Alloc>& object,
+                            Traits,Compare,Combine,Section,Interval,Alloc>& object,
     const IntervalMap<DomainT,CodomainT,
-                      Traits,Interval,Compare,Combine,Alloc>& operand
+                      Traits,Compare,Combine,Section,Interval,Alloc>& operand
 )
 {
     typedef interval_base_map<SubType,DomainT,CodomainT,
-                              Traits,Interval,Compare,Combine,Alloc> object_type;
+                              Traits,Compare,Combine,Section,Interval,Alloc> object_type;
     typedef IntervalMap<DomainT,CodomainT,
-                        Traits,Interval,Compare,Combine,Alloc> operand_type;
+                        Traits,Compare,Combine,Section,Interval,Alloc> operand_type;
     object_type intersection;
 
     if(operand.empty())
@@ -780,8 +785,8 @@
 /*CL
 template 
 <
-    class SubType, class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
+    class SubType, class DomainT, class CodomainT, class Traits,
+ 
     ITL_COMPARE Compare, ITL_ALLOC Alloc,
     template
     <    
@@ -794,12 +799,12 @@
 bool is_disjoint
 (
           interval_base_map<SubType,DomainT,CodomainT,
-                            Traits,Interval,Compare,Combine,Alloc>& object,
+                            Traits,Compare,Combine,Section,Interval,Alloc>& object,
     const IntervalSet<DomainT,Interval,Compare,Alloc>& operand
 )
 {
     typedef interval_base_map<SubType,DomainT,CodomainT,
-                              Traits,Interval,Compare,Combine,Alloc> object_type;
+                              Traits,Compare,Combine,Section,Interval,Alloc> object_type;
     typedef IntervalSet<DomainT,Interval,Compare,Alloc> operand_type;
     object_type intersection;
 
@@ -826,13 +831,12 @@
 
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap,
     template
@@ -846,12 +850,12 @@
 bool is_disjoint
 (
     const IntervalMap<DomainT,CodomainT,
-                      Traits,Interval,Compare,Combine,Alloc>&  object,
+                      Traits,Compare,Combine,Section,Interval,Alloc>&  object,
     const IntervalSet<DomainT,Interval,Compare,Alloc>& operand
 )
 {
     typedef IntervalMap<DomainT,CodomainT,
-                        Traits,Interval,Compare,Combine,Alloc> object_type;
+                        Traits,Compare,Combine,Section,Interval,Alloc> object_type;
     typedef IntervalSet<DomainT,Interval,Compare,Alloc> operand_type;
     object_type intersection;
 
@@ -877,13 +881,12 @@
 
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap,
     template
@@ -898,7 +901,7 @@
 (
     const IntervalSet<DomainT,Interval,Compare,Alloc>& left,
     const IntervalMap<DomainT,CodomainT,
-                      Traits,Interval,Compare,Combine,Alloc>&  right
+                      Traits,Compare,Combine,Section,Interval,Alloc>&  right
 )
 {
         return is_disjoint(right, left);
@@ -909,20 +912,19 @@
 //-----------------------------------------------------------------------------
 template 
 <
-    class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+    class DomainT, class CodomainT, class Traits,
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc,
     template
     <    
-        class, class, class, template<class,ITL_COMPARE>class, 
-        ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+        class, class, class, 
+        ITL_COMPARE, ITL_COMBINE, ITL_SECTION, template<class,ITL_COMPARE>class, ITL_ALLOC
     >
     class IntervalMap
 >
-typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::interval_type 
-enclosure(const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object)
+typename IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::interval_type 
+enclosure(const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object)
 {
-    typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> IntervalMapT;
+    typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> IntervalMapT;
     typedef typename IntervalMapT::interval_type interval_type;
     return 
         object.empty() ? neutron<interval_type>::value()
@@ -932,14 +934,13 @@
 
 template 
 <
-    class SubType, class DomainT, class CodomainT,
-    class Traits, template<class,ITL_COMPARE>class Interval, 
-    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc
+    class SubType, class DomainT, class CodomainT, class Traits, 
+    ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
 >
-typename interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::interval_type 
-enclosure(const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object)
+typename interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>::interval_type 
+enclosure(const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object)
 {
-    typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> IntervalMapT;
+    typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> IntervalMapT;
     typedef typename IntervalMapT::interval_type interval_type;
     return 
         object.empty() ? neutron<interval_type>::value()

Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp	(original)
+++ sandbox/itl/boost/itl/map.hpp	2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -105,6 +105,7 @@
         class Traits = itl::neutron_absorber,
         ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
         ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
+		ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, CodomainT), 
         ITL_ALLOC   Alloc   = std::allocator 
     >
     class map: private std::map<DomainT, CodomainT, ITL_COMPARE_DOMAIN(Compare,DomainT), 
@@ -113,12 +114,12 @@
     public:
         typedef Alloc<typename std::pair<const DomainT, CodomainT> >  allocator_type;
 
-        typedef typename itl::map<DomainT,CodomainT,Traits, Compare,Combine,Alloc> type;
+        typedef typename itl::map<DomainT,CodomainT,Traits, Compare,Combine,Section,Alloc> type;
         typedef typename std::map<DomainT, CodomainT, ITL_COMPARE_DOMAIN(Compare,DomainT),
                                   allocator_type>              base_type;
         typedef typename itl::set<DomainT, Compare, Alloc >       set_type;
 
-        typedef itl::map<DomainT,CodomainT,itl::neutron_absorber,Compare,Combine,Alloc> 
+        typedef itl::map<DomainT,CodomainT,itl::neutron_absorber,Compare,Combine,Section,Alloc> 
                                                                neutron_absorber_type;
         typedef Traits traits;
 
@@ -316,60 +317,60 @@
 
     /** Standard equality, which is lexicographical equality of the sets
         as sequences, that are given by their Compare order. */
-    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-    inline bool operator == (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& lhs,
-                             const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& rhs)
+    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+    inline bool operator == (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
+                             const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
     {
         typedef std::map<DomainT,CodomainT,ITL_COMPARE_DOMAIN(Compare,DomainT),Alloc<DomainT> > base_type;
         return operator==((const base_type&)lhs, (const base_type&)rhs);
     }
 
     //JODO comment... 
-    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-    inline bool is_element_equal(const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& lhs,
-                                 const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& rhs)
+    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+    inline bool is_element_equal(const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
+                                 const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
     {
         typedef std::map<DomainT,CodomainT,ITL_COMPARE_DOMAIN(Compare,DomainT),Alloc<DomainT> > base_type;
         return operator==((const base_type&)lhs, (const base_type&)rhs);
     }
 
     /** Protonic equality is equality on all elements that do not carry a neutron as content. */
-    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-    inline bool is_protonic_equal (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& lhs,
-                                   const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& rhs)
+    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+    inline bool is_protonic_equal (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
+                                   const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
     {
         //JODO: Efficient implementation.
         typedef std::map<DomainT,CodomainT,ITL_COMPARE_DOMAIN(Compare,DomainT),Alloc<DomainT> > base_type;
 
-        itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc> lhs0 = lhs;
-        itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc> rhs0 = rhs;
+        itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> lhs0 = lhs;
+        itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> rhs0 = rhs;
         lhs0.absorb_neutrons();
         rhs0.absorb_neutrons();
         return operator==((const base_type&)lhs0, (const base_type&)rhs0);
     }
 
     /** Strict weak less ordering which is given by the Compare order */
-    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-    inline bool operator < (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& lhs,
-        const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& rhs)
+    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+    inline bool operator < (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
+        const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
     {
         typedef std::map<DomainT,CodomainT,ITL_COMPARE_DOMAIN(Compare,DomainT),Alloc<DomainT> > base_type;
         return operator<((const base_type&)lhs, (const base_type&)rhs);
     }
 
     /** Partial ordering which is induced by Compare */
-    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-    inline bool operator <= (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& lhs,
-        const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& rhs)
+    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+    inline bool operator <= (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
+        const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
     {
         typedef std::map<DomainT,CodomainT,ITL_COMPARE_DOMAIN(Compare,DomainT),Alloc<DomainT> > base_type;
         return operator<=((const base_type&)lhs, (const base_type&)rhs);
     }
 
-    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
         template <class Combiner>
-    typename map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>::iterator
-        map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>::add(const value_type& val)
+    typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::iterator
+        map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::add(const value_type& val)
     {
         if(Traits::absorbs_neutrons && val.CONT_VALUE == CodomainT())
             return end();
@@ -401,9 +402,9 @@
         }
     }
 
-    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-    typename map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>::size_type 
-        map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>
+    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+    typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::size_type 
+        map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
         ::erase(const value_type& value_pair)
     {
         if(Traits::absorbs_neutrons && value_pair.CONT_VALUE == CodomainT())
@@ -421,9 +422,9 @@
     }
 
 
-    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-    typename map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>::iterator
-        map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>::subtract(const value_type& val)
+    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+    typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::iterator
+        map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::subtract(const value_type& val)
     {
         if(Traits::emits_neutrons)
             return add<inverse_data_combine>(val);
@@ -447,8 +448,8 @@
     }
 
 
-    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-    std::string map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>::as_string()const
+    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+    std::string map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::as_string()const
     { 
         std::string repr;
         const_FORALL_THIS(it) {
@@ -463,9 +464,9 @@
         return repr;
     }
 
-    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
         template<class Predicate>
-    map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>
+    map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
         ::erase_if(const Predicate& pred)
     {
         iterator it = begin();
@@ -477,10 +478,10 @@
     }
 
 
-    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
         template<class Predicate>
-    map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>
-        ::assign_if(const map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& src, const Predicate& pred)
+    map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
+        ::assign_if(const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& src, const Predicate& pred)
     {
         clear();
         const_iterator it = src.begin();
@@ -492,12 +493,12 @@
     }
     //-------------------------------------------------------------------------
     template <typename DomainT, typename CodomainT, class Traits, 
-              ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-    map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& 
-        insert(map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& object, 
-               const map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& insertee) 
+              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) 
     {
-        typedef map<DomainT,CodomainT,Traits,Compare,Combine,Alloc> map_type;
+        typedef map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> map_type;
 
         const_FORALL(typename map_type, elem_, insertee) 
             object.insert(*elem_); 
@@ -506,12 +507,12 @@
     }
 
     template <typename DomainT, typename CodomainT, class Traits, 
-              ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-    map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& 
-        erase(map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& object, 
-              const map<DomainT,CodomainT,Traits,Compare,Combine,Alloc>& erasee) 
+              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) 
     {
-        typedef map<DomainT,CodomainT,Traits,Compare,Combine,Alloc> map_type;
+        typedef map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> map_type;
 
         const_FORALL(typename map_type, elem_, erasee) 
             object.erase(*elem_); 

Modified: sandbox/itl/boost/itl/notate.hpp
==============================================================================
--- sandbox/itl/boost/itl/notate.hpp	(original)
+++ sandbox/itl/boost/itl/notate.hpp	2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -79,6 +79,7 @@
 
 #define ITL_USE_COMPARE_TEMPLATE_TEMPLATE
 #define ITL_USE_COMBINE_TEMPLATE_TEMPLATE
+#define ITL_USE_SECTION_TEMPLATE_TEMPLATE
 
 //------------------------------------------------------------------------------
 // template parameter Compare can not be a template type parameter as long as
@@ -109,6 +110,18 @@
 #endif
 
 //------------------------------------------------------------------------------
+// template parameter Section could be a template type parameter.
+#ifdef ITL_USE_SECTION_TEMPLATE_TEMPLATE
+#   define ITL_SECTION template<class>class
+#   define ITL_SECTION_CODOMAIN(itl_intersect, codomain_type) itl_intersect<codomain_type> 
+#   define ITL_SECTION_INSTANCE(section_instance,codomain_type) section_instance
+#else//ITL_USE_SECTION_TEMPLATE_TYPE
+#   define ITL_SECTION class
+#   define ITL_SECTION_CODOMAIN(itl_intersect, codomain_type) itl_intersect 
+#   define ITL_SECTION_INSTANCE(section_instance,codomain_type) section_instance<codomain_type>
+#endif
+
+//------------------------------------------------------------------------------
 #define ITL_ALLOC    template<class>class
 
 #endif // __itl_NOTATE_H_JOFA_990119__

Modified: sandbox/itl/boost/itl/rational.hpp
==============================================================================
--- sandbox/itl/boost/itl/rational.hpp	(original)
+++ sandbox/itl/boost/itl/rational.hpp	2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -7,9 +7,7 @@
 +----------------------------------------------------------------------------*/
 
 /*-----------------------------------------------------------------------------
-itl_ptime provides adapter code for boost::posix_time::ptime.
-It implements incrementation (++) decrementation (--) and a neutral element
-w.r.t. addition (neutron()).
+itl_rational provides adapter code for boost::rational.
 -----------------------------------------------------------------------------*/
 
 #ifndef __itl_rational_JOFA_080913_H__

Modified: sandbox/itl/boost/itl/split_interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_map.hpp	(original)
+++ sandbox/itl/boost/itl/split_interval_map.hpp	2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -129,23 +129,24 @@
         typename DomainT,
         typename CodomainT,
         class Traits = itl::neutron_absorber,
-        template<class,ITL_COMPARE>class Interval = itl::interval,
         ITL_COMPARE Compare  = ITL_COMPARE_INSTANCE(std::less, DomainT),
         ITL_COMBINE Combine  = ITL_COMBINE_INSTANCE(itl::inplace_plus, CodomainT),
+		ITL_SECTION Section  = ITL_SECTION_INSTANCE(itl::inplace_star, CodomainT), 
+		template<class,ITL_COMPARE>class Interval = itl::interval,
         ITL_ALLOC   Alloc    = std::allocator
     >
     class split_interval_map:
-        public interval_base_map<split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>, 
-                                 DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+        public interval_base_map<split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>, 
+                                 DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     {
     public:
         typedef Traits traits;
-        typedef split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> type;
-        typedef       interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> joint_type;
-        typedef interval_base_map <split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>, 
-                                   DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> base_type;
+        typedef split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> type;
+        typedef       interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> joint_type;
+        typedef interval_base_map <split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>, 
+                                   DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> base_type;
 
-        typedef split_interval_map<DomainT,CodomainT,itl::neutron_absorber,Interval,Compare,Combine,Alloc>
+        typedef split_interval_map<DomainT,CodomainT,itl::neutron_absorber,Compare,Combine,Section,Interval,Alloc>
             neutron_absorber_type;
 
         typedef Interval<DomainT,Compare> interval_type;
@@ -175,16 +176,16 @@
         template<class SubType>
         split_interval_map& operator =
             (const interval_base_map<SubType,DomainT,CodomainT,
-                                     Traits,Interval,Compare,Combine,Alloc>& src)
+                                     Traits,Compare,Combine,Section,Interval,Alloc>& src)
         { assign(src); return *this; }
 
         /// Assignment from a base interval_map.
         template<class SubType>
         void assign(const interval_base_map<SubType,DomainT,CodomainT,
-                                            Traits,Interval,Compare,Combine,Alloc>& src)
+                                            Traits,Compare,Combine,Section,Interval,Alloc>& src)
         {
             typedef interval_base_map<SubType,DomainT,CodomainT,
-                                      Traits,Interval,Compare,Combine,Alloc> base_map_type;
+                                      Traits,Compare,Combine,Section,Interval,Alloc> base_map_type;
             this->clear();
             // Can be implemented via _map.insert: Interval joining not necessary.
             const_FORALL(typename base_map_type, it, src) 
@@ -199,8 +200,8 @@
                 // friend declaration:
         friend class  
                         interval_base_map
-			<split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>, 
-                                DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc  >;
+			<split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>, 
+                                DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc  >;
 
         bool contains_(const value_type& x)const;
 
@@ -240,8 +241,8 @@
     } ;
 
 
-    template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-    bool split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+    template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+    bool split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
         ::contains_(const value_type& interv_value)const
     {
         interval_type interv = interv_value.KEY_VALUE;
@@ -257,8 +258,8 @@
 
 
 template <typename DomainT, typename CodomainT, class Traits,
-          template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::fill(const value_type& value)
 {
     //collision free insert is asserted
@@ -270,9 +271,9 @@
 }
 
 template <typename DomainT, typename CodomainT, class Traits,
-          template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
     template<class Combiner>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::fill_gap(const value_type& value)
 {
     //collision free insert is asserted
@@ -298,9 +299,9 @@
 //-----------------------------------------------------------------------------
 // add<Combinator>(pair(interval,value)):
 //-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
     template<class Combiner>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::add_(const value_type& x)
 {
     const interval_type& x_itv = x.KEY_VALUE;
@@ -387,9 +388,9 @@
     }
 }
 
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
     template<class Combiner>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::add_rest(const interval_type& x_itv, const CodomainT& x_val, 
                iterator& it, iterator& end_it)
 {
@@ -416,9 +417,9 @@
     add_rear<Combiner>(x_rest, x_val, it);
 }
 
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
     template<class Combiner>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::add_rear(const interval_type& x_rest, const CodomainT& x_val, iterator& it)
 {
     interval_type cur_itv = (*it).KEY_VALUE ;
@@ -451,9 +452,9 @@
 //-----------------------------------------------------------------------------
 // subtract<Combinator>(pair(interval,value)):
 //-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
     template<class Combiner>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::subtract_(const value_type& x)
 {
     const interval_type& x_itv = x.KEY_VALUE;
@@ -510,9 +511,9 @@
 
 
 
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
     template<class Combiner>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::subtract_rest(const interval_type& x_itv, const CodomainT& x_val, 
                     iterator& it, iterator& end_it)
 {
@@ -562,9 +563,9 @@
 //-----------------------------------------------------------------------------
 // insert(pair(interval,value)):
 //-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, 
-          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits, 
+          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::insert_(const value_type& x)
 {
     const interval_type& x_itv = x.KEY_VALUE;
@@ -619,9 +620,9 @@
 }
 
 
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, 
-          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits, 
+          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::insert_rest(const interval_type& x_itv, const CodomainT& x_val, 
                   iterator& it, iterator& end_it)
 {
@@ -640,9 +641,9 @@
     insert_rear(x_rest, x_val, it);
 }
 
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, 
-          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits, 
+          ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::insert_rear(const interval_type& x_rest, const CodomainT& x_val, 
                   iterator& it)
 {
@@ -664,8 +665,8 @@
 //-----------------------------------------------------------------------------
 // erase(pair(interval,value)):
 //-----------------------------------------------------------------------------
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::erase_(const value_type& x)
 {
     const interval_type& x_itv = x.KEY_VALUE;
@@ -723,8 +724,8 @@
 }
 
 
-template <typename DomainT, typename CodomainT, class Traits, template<class,ITL_COMPARE>class Interval, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc>
-void split_interval_map<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+void split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
     ::erase_rest(const interval_type& x_itv, const CodomainT& x_val, 
                  iterator& it, iterator& end_it)
 {

Modified: sandbox/itl/libs/itl/example/boost_party/boost_party.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/boost_party/boost_party.cpp	(original)
+++ sandbox/itl/libs/itl/example/boost_party/boost_party.cpp	2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -68,7 +68,7 @@
 typedef interval_map<ptime, GuestSetT> BoostPartyAttendenceHistoryT;
 
 // A party's height shall be defined as the maximum height of all guests ;-)
-typedef interval_map<ptime, int, neutron_absorber, interval, less, inplace_max > BoostPartyHeightHistoryT;
+typedef interval_map<ptime, int, neutron_absorber, less, inplace_max > BoostPartyHeightHistoryT;
 
 void boost_party()
 {

Modified: sandbox/itl/libs/itl/test/test_interval_map_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_shared.hpp	(original)
+++ sandbox/itl/libs/itl/test/test_interval_map_shared.hpp	2008-12-21 06:38:12 EST (Sun, 21 Dec 2008)
@@ -12,9 +12,10 @@
 
 template <template<class T, class U,
                    class Traits = neutron_absorber,
-                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
                    ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+                   ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_ALLOC   Alloc   = std::allocator
                   >class IntervalMap, 
           class T, class U>
@@ -160,9 +161,10 @@
 
 template <template<class T, class U,
                    class Traits = neutron_absorber,
-                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
                    ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+                   ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_ALLOC   Alloc   = std::allocator
                   >class IntervalMap, 
           class T, class U>
@@ -222,9 +224,10 @@
 
 template <template<class T, class U,
                    class Traits = neutron_absorber,
-                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
                    ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+                   ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_ALLOC   Alloc   = std::allocator
                   >class IntervalMap, 
           class T, class U>
@@ -276,9 +279,10 @@
 
 template <template<class T, class U,
                    class Traits = neutron_absorber,
-                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
                    ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+                   ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_ALLOC   Alloc   = std::allocator
                   >class IntervalMap, 
           class T, class U>
@@ -308,9 +312,10 @@
 
 template <template<class T, class U,
                    class Traits = neutron_absorber,
-                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
                    ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+                   ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_ALLOC   Alloc   = std::allocator
                   >class IntervalMap, 
           class T, class U>
@@ -358,9 +363,10 @@
 
 template <template<class T, class U,
                    class Traits = neutron_absorber,
-                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
                    ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+                   ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_ALLOC   Alloc   = std::allocator
                   >class IntervalMap, 
           class T, class U>
@@ -410,9 +416,10 @@
 
 template <template<class T, class U,
                    class Traits = neutron_absorber,
-                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
                    ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+                   ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_ALLOC   Alloc   = std::allocator
                   >class IntervalMap, 
           class T, class U>
@@ -453,9 +460,10 @@
 
 template <template<class T, class U,
                    class Traits = neutron_absorber,
-                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
                    ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+                   ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_ALLOC   Alloc   = std::allocator
                   >class IntervalMap, 
           class T, class U>
@@ -516,9 +524,10 @@
 // Test for nontrivial intersection of interval maps with intervals and values
 template <template<class T, class U,
                    class Traits = neutron_absorber,
-                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
                    ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+                   ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_ALLOC   Alloc   = std::allocator
                   >class IntervalMap, 
           class T, class U>
@@ -628,9 +637,10 @@
 // Test for nontrivial erasure of interval maps with intervals and interval sets
 template <template<class T, class U,
                    class Traits = neutron_absorber,
-                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
                    ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+                   ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_ALLOC   Alloc   = std::allocator
                   >class IntervalMap, 
           class T, class U>
@@ -744,9 +754,10 @@
 // Test first_collision
 template <template<class T, class U,
                    class Traits = neutron_absorber,
-                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
                    ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+                   ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inplace_star, U),
+                   template<class,ITL_COMPARE>class Interval = interval,
                    ITL_ALLOC   Alloc   = std::allocator
                   >class IntervalMap, 
           class T, class U>