Boost logo

Boost-Commit :

Date view Thread view Subject view Author view

Subject: [Boost-commit] svn:boost r50305 - in sandbox/itl: boost/itl boost/validate boost/validate/laws libs/itl/doc libs/itl/example/user_groups libs/itl/test libs/validate/example/labatea
From: afojgo_at_[hidden]
Date: 2008-12-17 13:00:57

Author: jofaber
Date: 2008-12-17 13:00:54 EST (Wed, 17 Dec 2008)
New Revision: 50305
URL: http://svn.boost.org/trac/boost/changeset/50305

Log:
Implemented operators. Added operators + - *. Stable {msvc-9.0, partly congcc-4.3-a7}
Added documentation. Concepts.qbk, Infoduction.qbk.
Added:
   sandbox/itl/libs/itl/doc/concepts.qbk (contents, props changed)
   sandbox/itl/libs/itl/doc/introduction.qbk (contents, props changed)
Text files modified:
   sandbox/itl/boost/itl/functors.hpp | 42 ---
   sandbox/itl/boost/itl/interval_base_map.hpp | 6
   sandbox/itl/boost/itl/interval_map.hpp | 16 +
   sandbox/itl/boost/itl/interval_maps.hpp | 416 ++++++++++++++++++++++++++++++++++++---
   sandbox/itl/boost/itl/interval_sets.hpp | 209 +++++++++++++++++++
   sandbox/itl/boost/itl/map.hpp | 44 ++--
   sandbox/itl/boost/itl/split_interval_map.hpp | 11
   sandbox/itl/boost/validate/laws/set_laws.h | 3
   sandbox/itl/boost/validate/realmvalidater.h | 50 ++-
   sandbox/itl/boost/validate/typevalidater.h | 17 -
   sandbox/itl/libs/itl/doc/Jamfile.v2 | 2
   sandbox/itl/libs/itl/doc/examples.qbk | 4
   sandbox/itl/libs/itl/doc/interface.qbk | 149 --------------
   sandbox/itl/libs/itl/doc/itl.qbk | 252 ++---------------------
   sandbox/itl/libs/itl/example/user_groups/user_groups.cpp | 6
   sandbox/itl/libs/itl/test/test_type_lists.hpp | 4
   sandbox/itl/libs/validate/example/labatea/labatea.cpp | 50 +++
   sandbox/itl/libs/validate/example/labatea/vc9_labatea.vcproj | 4
   18 files changed, 757 insertions(+), 528 deletions(-)

Modified: sandbox/itl/boost/itl/functors.hpp
==============================================================================
--- sandbox/itl/boost/itl/functors.hpp (original)
+++ sandbox/itl/boost/itl/functors.hpp 2008-12-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -158,60 +158,32 @@
 
         //--------------------------------------------------------------------------
         // Inverse functor
-#ifdef ITL_USE_COMBINE_TEMPLATE_TEMPLATE
- template<template<class>class Functor, class Type> struct inverse;
+ template<class Functor> struct inverse;
 
         template<class Type>
- struct inverse<itl::inplace_plus, Type>
+ struct inverse<itl::inplace_plus<Type> >
         { typedef itl::inplace_minus<Type> type; };
 
         template<class Type>
- struct inverse<itl::inplace_minus, Type>
+ struct inverse<itl::inplace_minus<Type> >
         { typedef itl::inplace_plus<Type> type; };
 
         template<class Type>
- struct inverse<itl::inplace_star, Type>
+ struct inverse<itl::inplace_star<Type> >
         { typedef itl::inplace_div<Type> type; };
 
         template<class Type>
- struct inverse<itl::inplace_div, Type>
+ struct inverse<itl::inplace_div<Type> >
         { typedef itl::inplace_star<Type> type; };
 
         template<class Type>
- struct inverse<itl::inplace_max, Type>
+ struct inverse<itl::inplace_max<Type> >
         { typedef itl::inplace_min<Type> type; };
 
         template<class Type>
- struct inverse<itl::inplace_min, Type>
+ struct inverse<itl::inplace_min<Type> >
         { typedef itl::inplace_max<Type> type; };
 
-#else //ITL_USE_COMBINE_TEMPLATE_TYPE
- template<class Functor, class Type> struct inverse;
-
- template<class Type>
- struct inverse<itl::inplace_plus<Type>, Type>
- { typedef itl::inplace_minus<Type> type; };
-
- template<class Type>
- struct inverse<itl::inplace_minus<Type>, Type>
- { typedef itl::inplace_plus<Type> type; };
-
- template<class Type>
- struct inverse<itl::inplace_star<Type>, Type>
- { typedef itl::inplace_div<Type> type; };
-
- template<class Type>
- struct inverse<itl::inplace_div<Type>, Type>
- { typedef itl::inplace_star<Type> type; };
-
- template<class Type>
- struct inverse<itl::inplace_max<Type>, Type>
- { typedef itl::inplace_min<Type> type; };
-
- template<class Type>
- struct inverse<itl::inplace_min<Type>, Type>
- { typedef itl::inplace_max<Type> type; };
-#endif
 
 }} // namespace itl boost
 

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-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -228,7 +228,9 @@
         
 public:
     inline static bool has_symmetric_difference()
- { return is_set<codomain_type>::value || !traits::absorbs_neutrons || traits::emits_neutrons; }
+ { return is_set<codomain_type>::value || (!is_set<codomain_type>::value && !traits::emits_neutrons); }
+
+ enum{ is_itl_container = true };
 
 public:
 /** @name B: Constructors, destructors, assignment
@@ -458,7 +460,7 @@
     */
     SubType& subtract(const value_type& x)
     {
- typedef typename inverse<Combine,CodomainT>::type InverseCombine;
+ typedef typename inverse<Combine<CodomainT> >::type InverseCombine;
         if(Traits::emits_neutrons)
                         that()->template add_<InverseCombine>(x);
         else

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-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -237,6 +237,7 @@
     void insert_rear(const interval_type& x_itv, const CodomainT& x_val, iterator& it);
 
     void erase_rest(const interval_type& x_itv, const CodomainT& x_val, iterator& it, iterator& end_it);
+
 } ;
 
 
@@ -395,7 +396,10 @@
     {
         CodomainT added_val = CodomainT();
         Combiner()(added_val, value.CONT_VALUE);
- insertion = this->_map.insert(value_type(value.KEY_VALUE, added_val));
+ if(Traits::absorbs_neutrons && added_val == neutron<CodomainT>::value())
+ return this->_map.end();
+ else
+ insertion = this->_map.insert(value_type(value.KEY_VALUE, added_val));
     }
     else
         insertion = this->_map.insert(value);
@@ -423,7 +427,10 @@
     {
         CodomainT added_val = CodomainT();
         Combiner()(added_val, value.CONT_VALUE);
- insertion = this->_map.insert(value_type(value.KEY_VALUE, added_val));
+ if(Traits::absorbs_neutrons && added_val == neutron<CodomainT>::value())
+ return this->_map.end();
+ else
+ insertion = this->_map.insert(value_type(value.KEY_VALUE, added_val));
     }
     else
         insertion = this->_map.insert(value);
@@ -455,7 +462,10 @@
     {
         CodomainT added_val = CodomainT();
         Combiner()(added_val, x_val);
- insertion = this->_map.insert(value_type(x_itv, added_val));
+ if(Traits::absorbs_neutrons && added_val == neutron<CodomainT>::value())
+ return;
+ else
+ insertion = this->_map.insert(value_type(x_itv, added_val));
     }
     else
         insertion = this->_map.insert(x);

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-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -31,7 +31,7 @@
     class Traits, template<class,ITL_COMPARE>class Interval,
     ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
     template
- <
+ <
         class, class, class, template<class,ITL_COMPARE>class,
         ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
>
@@ -40,10 +40,8 @@
 interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,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,Interval,Compare,Combine,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
 )
 {
     typedef IntervalMap<DomainT,CodomainT,
@@ -54,6 +52,81 @@
     return object;
 }
 
+template
+<
+ class SubType, class DomainT, class CodomainT,
+ class Traits, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ >
+ class IntervalMap
+>
+interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,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
+)
+{
+ typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,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,
+ template
+ <
+ class, class, class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ >
+ class IntervalMap
+>
+IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
+operator +=
+(
+ IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,
+ Traits,Interval,Compare,Combine,Alloc> operand_type;
+ const_FORALL(typename operand_type, elem_, operand)
+ object.add(*elem_);
+
+ return object;
+}
+
+template
+<
+ class DomainT, class CodomainT,
+ class Traits, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ >
+ class IntervalMap
+>
+IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+operator +
+(
+ const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ return ObjectT(object) += operand;
+}
+//-----------------------------------------------------------------------------
+
 //--- value_type --------------------------------------------------------------
 template
 <
@@ -70,17 +143,39 @@
 IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
 operator +=
 (
- IntervalMap<DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& object,
+ 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,Interval,Compare,Combine,Alloc>::value_type& operand
 )
 {
     return object.add(operand);
 }
 
-//--- mapping_type ---------------------------------------------------------
+template
+<
+ class DomainT, class CodomainT,
+ class Traits, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ >
+ class IntervalMap
+>
+IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,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
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ return ObjectT(object) += operand;
+}
+//-----------------------------------------------------------------------------
+
+//--- mapping_type ------------------------------------------------------------
 // Addition (+=) of a base value pair.
 /* Addition of an value pair <tt>x=(I,y)</tt>
 
@@ -110,16 +205,36 @@
 IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,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,Interval,Compare,Combine,Alloc>& object,
+ const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::mapping_pair_type& operand
 )
 {
     return object.add(operand);
 }
 
+template
+<
+ class DomainT, class CodomainT,
+ class Traits, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ >
+ class IntervalMap
+>
+IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,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
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ return ObjectT(object) += operand;
+}
+//-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 // subtraction -=
@@ -139,10 +254,8 @@
 interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,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,Interval,Compare,Combine,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
 )
 {
     typedef IntervalMap<DomainT,CodomainT,
@@ -153,6 +266,81 @@
     return object;
 }
 
+template
+<
+ class SubType, class DomainT, class CodomainT,
+ class Traits, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ >
+ class IntervalMap
+>
+interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,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
+)
+{
+ typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,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,
+ template
+ <
+ class, class, class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ >
+ class IntervalMap
+>
+IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
+operator -=
+(
+ IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,
+ Traits,Interval,Compare,Combine,Alloc> operand_type;
+ const_FORALL(typename operand_type, elem_, operand)
+ object.subtract(*elem_);
+
+ return object;
+}
+
+template
+<
+ class DomainT, class CodomainT,
+ class Traits, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ >
+ class IntervalMap
+>
+IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+operator -
+(
+ const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ return ObjectT(object) -= operand;
+}
+//-----------------------------------------------------------------------------
+
 //--- value_type --------------------------------------------------------------
 // Subtraction of an interval value pair
 /* Subtraction of an interval value pair <tt>x=(I,y)</tt>.
@@ -181,16 +369,38 @@
 IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,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,Interval,Compare,Combine,Alloc>& object,
+ const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::value_type& operand
 )
 {
     return object.subtract(operand);
 }
 
+template
+<
+ class DomainT, class CodomainT,
+ class Traits, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ >
+ class IntervalMap
+>
+IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,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
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ return ObjectT(object) -= operand;
+}
+//-----------------------------------------------------------------------------
+
+
 //--- mapping_type ---------------------------------------------------------
 template
 <
@@ -207,16 +417,36 @@
 IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,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,Interval,Compare,Combine,Alloc>& object,
+ const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::mapping_pair_type& operand
 )
 {
     return object.subtract(operand);
 }
 
+template
+<
+ class DomainT, class CodomainT,
+ class Traits, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ >
+ class IntervalMap
+>
+IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,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
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ return ObjectT(object) -= operand;
+}
+//-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 // erasure -= of elements given by an interval_set
@@ -236,8 +466,7 @@
 interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
 operator -=
 (
- interval_base_map<SubType,DomainT,CodomainT,
- Traits,Interval,Compare,Combine,Alloc>& object,
+ interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
     const IntervalSet<DomainT,Interval,Compare,Alloc>& erasure
 )
 {
@@ -248,6 +477,30 @@
     return object;
 }
 
+template
+<
+ class SubType, class DomainT, class CodomainT,
+ class Traits, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ template
+ <
+ class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_ALLOC
+ >
+ class IntervalSet
+>
+interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+operator -
+(
+ const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
+ const IntervalSet<DomainT,Interval,Compare,Alloc>& operand
+)
+{
+ typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ return ObjectT(object) -= operand;
+}
+//-----------------------------------------------------------------------------
+
 //--- value_type --------------------------------------------------------------
 template
 <
@@ -264,16 +517,37 @@
 IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,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,Interval,Compare,Combine,Alloc>& object,
+ const typename IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>::interval_type& operand
 )
 {
     return object.erase(operand);
 }
 
+template
+<
+ class DomainT, class CodomainT,
+ class Traits, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ >
+ class IntervalMap
+>
+IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,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
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ return ObjectT(object) -= operand;
+}
+//-----------------------------------------------------------------------------
+
 
 //-----------------------------------------------------------------------------
 // insert
@@ -347,6 +621,76 @@
     return object;
 }
 
+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 SectanT
+>
+interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+operator *
+(
+ const interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
+ const SectanT& operand
+)
+{
+ typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Interval,Compare,Combine,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,
+ template
+ <
+ class, class, class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ >
+ class IntervalMap
+>
+IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>&
+operator *=
+(
+ IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,
+ Traits,Interval,Compare,Combine,Alloc> object_type;
+ object_type intersection;
+ object.add_intersection(intersection,operand);
+ object.swap(intersection);
+ return object;
+}
+
+template
+<
+ class DomainT, class CodomainT,
+ class Traits, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_ALLOC Alloc,
+ template
+ <
+ class, class, class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_COMBINE, ITL_ALLOC
+ >
+ class IntervalMap
+>
+IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>
+operator *
+(
+ const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& object,
+ const IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc>& operand
+)
+{
+ typedef IntervalMap<DomainT,CodomainT,Traits,Interval,Compare,Combine,Alloc> ObjectT;
+ return ObjectT(object) *= operand;
+}
+//-----------------------------------------------------------------------------
+
 //-----------------------------------------------------------------------------
 // is_element_equal
 //-----------------------------------------------------------------------------

Modified: sandbox/itl/boost/itl/interval_sets.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_sets.hpp (original)
+++ sandbox/itl/boost/itl/interval_sets.hpp 2008-12-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -14,8 +14,7 @@
 namespace boost{namespace itl
 {
 
-template<typename, template<class,ITL_COMPARE>class,
- ITL_COMPARE, ITL_ALLOC>
+template<typename, template<class,ITL_COMPARE>class, ITL_COMPARE, ITL_ALLOC>
 class interval_set;
 
 //-----------------------------------------------------------------------------
@@ -46,6 +45,29 @@
     return object;
 }
 
+template
+<
+ class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_ALLOC Alloc,
+ template
+ <
+ class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_ALLOC
+ >
+ class IntervalSet
+>
+interval_base_set<SubType,DomainT,Interval,Compare,Alloc>
+operator +
+(
+ const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object,
+ const IntervalSet <DomainT,Interval,Compare,Alloc>& operand
+)
+{
+ typedef interval_base_set<SubType,DomainT,Interval,Compare,Alloc> ObjectT;
+ return ObjectT(object) += operand;
+}
+//-----------------------------------------------------------------------------
+
 //--- interval_type -----------------------------------------------------------
 template
 <
@@ -68,6 +90,29 @@
     return object.add(interval);
 }
 
+template
+<
+ class DomainT, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_ALLOC Alloc,
+ template
+ <
+ class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_ALLOC
+ >
+ class IntervalSet
+>
+IntervalSet<DomainT,Interval,Compare,Alloc>
+operator +
+(
+ const IntervalSet<DomainT,Interval,Compare,Alloc>& object,
+ const typename IntervalSet<DomainT,Interval,Compare,Alloc>::interval_type& operand
+)
+{
+ typedef IntervalSet<DomainT,Interval,Compare,Alloc> ObjectT;
+ return ObjectT(object) += operand;
+}
+//-----------------------------------------------------------------------------
+
 //--- domain_type -------------------------------------------------------------
 template
 <
@@ -90,6 +135,28 @@
     return object.add(value);
 }
 
+template
+<
+ class DomainT, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_ALLOC Alloc,
+ template
+ <
+ class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_ALLOC
+ >
+ class IntervalSet
+>
+IntervalSet<DomainT,Interval,Compare,Alloc>
+operator +
+(
+ const IntervalSet<DomainT,Interval,Compare,Alloc>& object,
+ const typename IntervalSet<DomainT,Interval,Compare,Alloc>::domain_type& operand
+)
+{
+ typedef IntervalSet<DomainT,Interval,Compare,Alloc> ObjectT;
+ return ObjectT(object) += operand;
+}
+//-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 // difference -=
@@ -119,6 +186,30 @@
         return object;
 }
 
+template
+<
+ class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_ALLOC Alloc,
+ template
+ <
+ class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_ALLOC
+ >
+ class IntervalSet
+>
+interval_base_set<SubType,DomainT,Interval,Compare,Alloc>
+operator -
+(
+ const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object,
+ const IntervalSet <DomainT,Interval,Compare,Alloc>& operand
+)
+{
+ typedef interval_base_set<SubType,DomainT,Interval,Compare,Alloc> ObjectT;
+ return ObjectT(object) -= operand;
+}
+//-----------------------------------------------------------------------------
+
+
 //--- interval_type -----------------------------------------------------------
 template
 <
@@ -141,6 +232,29 @@
     return object.subtract(interval);
 }
 
+template
+<
+ class DomainT, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_ALLOC Alloc,
+ template
+ <
+ class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_ALLOC
+ >
+ class IntervalSet
+>
+IntervalSet<DomainT,Interval,Compare,Alloc>
+operator -
+(
+ const IntervalSet<DomainT,Interval,Compare,Alloc>& object,
+ const typename IntervalSet<DomainT,Interval,Compare,Alloc>::interval_type& operand
+)
+{
+ typedef IntervalSet<DomainT,Interval,Compare,Alloc> ObjectT;
+ return ObjectT(object) -= operand;
+}
+//-----------------------------------------------------------------------------
+
 //--- domain_type -------------------------------------------------------------
 template
 <
@@ -163,6 +277,28 @@
     return object.subtract(value);
 }
 
+template
+<
+ class DomainT, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_ALLOC Alloc,
+ template
+ <
+ class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_ALLOC
+ >
+ class IntervalSet
+>
+IntervalSet<DomainT,Interval,Compare,Alloc>
+operator -
+(
+ const IntervalSet<DomainT,Interval,Compare,Alloc>& object,
+ const typename IntervalSet<DomainT,Interval,Compare,Alloc>::domain_type& operand
+)
+{
+ typedef IntervalSet<DomainT,Interval,Compare,Alloc> ObjectT;
+ return ObjectT(object) -= operand;
+}
+//-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 // intersection *=
@@ -213,6 +349,29 @@
     return object;
 }
 
+template
+<
+ class SubType, class DomainT, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_ALLOC Alloc,
+ template
+ <
+ class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_ALLOC
+ >
+ class IntervalSet
+>
+interval_base_set<SubType,DomainT,Interval,Compare,Alloc>
+operator *
+(
+ const interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object,
+ const IntervalSet <DomainT,Interval,Compare,Alloc>& operand
+)
+{
+ typedef interval_base_set<SubType,DomainT,Interval,Compare,Alloc> ObjectT;
+ return ObjectT(object) *= operand;
+}
+//-----------------------------------------------------------------------------
+
 //--- interval_type -----------------------------------------------------------
 template
 <
@@ -246,6 +405,29 @@
     return object;
 }
 
+template
+<
+ class DomainT, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_ALLOC Alloc,
+ template
+ <
+ class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_ALLOC
+ >
+ class IntervalSet
+>
+IntervalSet<DomainT,Interval,Compare,Alloc>
+operator *
+(
+ const IntervalSet<DomainT,Interval,Compare,Alloc>& object,
+ const typename IntervalSet<DomainT,Interval,Compare,Alloc>::interval_type& operand
+)
+{
+ typedef IntervalSet<DomainT,Interval,Compare,Alloc> ObjectT;
+ return ObjectT(object) *= operand;
+}
+//-----------------------------------------------------------------------------
+
 //--- domain_type -------------------------------------------------------------
 template
 <
@@ -270,6 +452,29 @@
     return object *= interval_type(value);
 }
 
+template
+<
+ class DomainT, template<class,ITL_COMPARE>class Interval,
+ ITL_COMPARE Compare, ITL_ALLOC Alloc,
+ template
+ <
+ class, template<class,ITL_COMPARE>class,
+ ITL_COMPARE, ITL_ALLOC
+ >
+ class IntervalSet
+>
+IntervalSet<DomainT,Interval,Compare,Alloc>
+operator *
+(
+ const IntervalSet<DomainT,Interval,Compare,Alloc>& object,
+ const DomainT& operand
+)
+{
+ typedef IntervalSet<DomainT,Interval,Compare,Alloc> ObjectT;
+ return ObjectT(object) *= operand;
+}
+//-----------------------------------------------------------------------------
+
 //-----------------------------------------------------------------------------
 // is_element_equal
 //-----------------------------------------------------------------------------

Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2008-12-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -123,29 +123,29 @@
         typedef Traits traits;
 
     public:
- typedef DomainT domain_type;
- typedef DomainT key_type;
- typedef CodomainT codomain_type;
- typedef CodomainT mapped_type;
- typedef CodomainT data_type;
- typedef std::pair<const DomainT, CodomainT> value_type;
- typedef ITL_COMPARE_DOMAIN(Compare,DomainT) key_compare;
- typedef ITL_COMBINE_CODOMAIN(Combine,CodomainT) data_combine;
- typedef typename inverse<Combine,CodomainT>::type inverse_data_combine;
- typedef inplace_star<CodomainT> data_intersect;
- typedef typename base_type::value_compare value_compare;
+ typedef DomainT domain_type;
+ typedef DomainT key_type;
+ typedef CodomainT codomain_type;
+ typedef CodomainT mapped_type;
+ typedef CodomainT data_type;
+ typedef std::pair<const DomainT, CodomainT> value_type;
+ typedef ITL_COMPARE_DOMAIN(Compare,DomainT) key_compare;
+ typedef ITL_COMBINE_CODOMAIN(Combine,CodomainT) data_combine;
+ typedef typename inverse<Combine<CodomainT> >::type inverse_data_combine;
+ typedef inplace_star<CodomainT> data_intersect;
+ typedef typename base_type::value_compare value_compare;
 
     public:
- typedef typename base_type::pointer pointer;
- typedef typename base_type::const_pointer const_pointer;
- typedef typename base_type::reference reference;
- typedef typename base_type::const_reference const_reference;
- typedef typename base_type::iterator iterator;
- typedef typename base_type::const_iterator const_iterator;
- typedef typename base_type::size_type size_type;
- typedef typename base_type::difference_type difference_type;
- typedef typename base_type::reverse_iterator reverse_iterator;
- typedef typename base_type::const_reverse_iterator const_reverse_iterator;
+ typedef typename base_type::pointer pointer;
+ typedef typename base_type::const_pointer const_pointer;
+ typedef typename base_type::reference reference;
+ typedef typename base_type::const_reference const_reference;
+ typedef typename base_type::iterator iterator;
+ typedef typename base_type::const_iterator const_iterator;
+ typedef typename base_type::size_type size_type;
+ typedef typename base_type::difference_type difference_type;
+ typedef typename base_type::reverse_iterator reverse_iterator;
+ typedef typename base_type::const_reverse_iterator const_reverse_iterator;
         
     public:
         map(){}
@@ -188,7 +188,7 @@
 
     public:
         inline static bool has_symmetric_difference()
- { return itl::is_set<codomain_type>::value || !traits::absorbs_neutrons || traits::emits_neutrons; }
+ { return is_set<codomain_type>::value || (!is_set<codomain_type>::value && !traits::emits_neutrons); }
 
     public:
         // --------------------------------------------------------------------

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-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -285,7 +285,11 @@
     {
         CodomainT added_val = CodomainT();
         Combiner()(added_val, value.CONT_VALUE);
- this->_map.insert(value_type(value.KEY_VALUE, added_val));
+
+ if(Traits::absorbs_neutrons && added_val == neutron<CodomainT>::value())
+ return;
+ else
+ this->_map.insert(value_type(value.KEY_VALUE, added_val));
     }
     else
         this->_map.insert(value);
@@ -314,6 +318,11 @@
         CodomainT added_val = CodomainT();
         Combiner()(added_val, x_val);
         insertion = this->_map.insert(value_type(x_itv, added_val));
+
+ if(Traits::absorbs_neutrons && added_val == neutron<CodomainT>::value())
+ return;
+ else
+ insertion = this->_map.insert(value_type(x_itv, added_val));
     }
     else
         insertion = this->_map.insert(x);

Modified: sandbox/itl/boost/validate/laws/set_laws.h
==============================================================================
--- sandbox/itl/boost/validate/laws/set_laws.h (original)
+++ sandbox/itl/boost/validate/laws/set_laws.h 2008-12-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -341,7 +341,7 @@
 
     public:
 
- bool holds()
+ bool holds()
         {
             // --- left hand side ------------------------
             Type a_plus_b = this->template getInputValue<operand_a>();
@@ -369,6 +369,7 @@
             return Equality<Type>()(lhs, rhs);
         }
 
+
         bool debug_holds()
         {
             // --- left hand side ------------------------

Modified: sandbox/itl/boost/validate/realmvalidater.h
==============================================================================
--- sandbox/itl/boost/validate/realmvalidater.h (original)
+++ sandbox/itl/boost/validate/realmvalidater.h 2008-12-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -13,19 +13,10 @@
 #include <stdio.h>
 #include <time.h>
 #include <boost/validate/typevalidater.h>
-
-#define ITL_LOCATION(message) location(__FILE__,__LINE__,message)
+#include <boost/validate/utility.hpp>
 
 namespace boost{namespace itl
 {
- std::string location(const std::string& file, int line, const std::string& message)
- {
- std::string result = file;
- result += "(" + to_string<int>::apply(line) + "): ";
- result += message;
- return result;
- }
-
     namespace RootType
     {
         enum RootTypes
@@ -46,6 +37,11 @@
         enum CodomainTypes { Int, Double, set_int, CodomainTypes_size };
     }
 
+ namespace NeutronHandlerType
+ {
+ enum NeutronHandlerTypes { absorber, enricher, emitter, NeutronHandlerTypes_size };
+ }
+
     
     class RealmValidater
     {
@@ -98,13 +94,13 @@
             _isValid = true;
             _rootChoice.setSize(RootType::Types_size);
             _rootChoice.setMaxWeights(100);
- _rootChoice[RootType::itl_set] = 14;
- _rootChoice[RootType::interval_set] = 14;
- _rootChoice[RootType::separate_interval_set] = 14;
- _rootChoice[RootType::split_interval_set] = 14;
- _rootChoice[RootType::itl_map] = 14;
- _rootChoice[RootType::interval_map] = 15;
- _rootChoice[RootType::split_interval_map] = 15;
+ _rootChoice[RootType::itl_set] = 0;
+ _rootChoice[RootType::interval_set] = 0;
+ _rootChoice[RootType::separate_interval_set] = 0;
+ _rootChoice[RootType::split_interval_set] = 0;
+ _rootChoice[RootType::itl_map] = 33;
+ _rootChoice[RootType::interval_map] = 33;
+ _rootChoice[RootType::split_interval_map] = 34;
             setRootTypeNames();
             _rootChoice.init();
 
@@ -145,12 +141,17 @@
 
         void validate()
         {
- srand(static_cast<unsigned>(time(NULL))); //Different numbers each run
- //srand(static_cast<unsigned>(1)); //Same numbers each run (std)
+ //srand(static_cast<unsigned>(time(NULL))); //Different numbers each run
+ srand(static_cast<unsigned>(1)); //Same numbers each run (std)
             //srand(static_cast<unsigned>(4711)); //Same numbers each run (varying)
 
             for(int idx=0; hasValidProfile(); idx++)
             {
+ if(_frequencies.size() == 402)
+ {
+ reportFrequencies("freq402.txt");
+ break;
+ }
                 if(idx>0 && idx % 100 == 0)
                     reportFrequencies();
                 validateType();
@@ -318,6 +319,17 @@
                 std::cout << "------------------------------------------------------------------------------" << std::endl;
         }
 
+ void reportFrequencies(const std::string& filename)
+ {
+ FILE* fp = fopen(filename.c_str(), "w");
+ int valid_count = 1;
+ FORALL(ValidationCounterT, it, _frequencies)
+ {
+ fprintf(fp, "%3d %-66s\n", valid_count, it->KEY_VALUE.c_str());
+ valid_count++;
+ }
+ }
+
         void reportTypeChoiceError(const std::string& location, int rootChoice, const ChoiceT& chooser)const
         {
             std::cout << location

Modified: sandbox/itl/boost/validate/typevalidater.h
==============================================================================
--- sandbox/itl/boost/validate/typevalidater.h (original)
+++ sandbox/itl/boost/validate/typevalidater.h 2008-12-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -16,27 +16,12 @@
 #include <boost/validate/laws/order.h>
 #include <boost/validate/laws/pushouts.h>
 #include <boost/validate/lawvalidater.h>
+#include <boost/validate/algebra_validater.hpp>
 
 namespace boost{namespace itl
 {
     typedef WeightedNumberGentor<int> ChoiceT;
 
- class AlgebraValidater
- {
- public:
- virtual ~AlgebraValidater(){}
- // the choice probability, and also the availability of laws is individual to each type
- // Somehow it has to be defined in conjunction to every type. So it is an aspect of
- // type traits.
- virtual void setProfile()=0;
- virtual void validate()=0;
- virtual void addFrequencies(ValidationCounterT&)=0;
- virtual void addViolations(ViolationCounterT&, ViolationMapT&)=0;
-
- virtual bool hasValidProfile()const{ return true; }
- };
-
-
     // ------------------------------------------------------------------------
     // Orderings
     // ------------------------------------------------------------------------

Modified: sandbox/itl/libs/itl/doc/Jamfile.v2
==============================================================================
--- sandbox/itl/libs/itl/doc/Jamfile.v2 (original)
+++ sandbox/itl/libs/itl/doc/Jamfile.v2 2008-12-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -25,7 +25,7 @@
         <doxygen:param>MACRO_EXPANSION=NO
         <doxygen:param>EXPAND_ONLY_PREDEF=YES
         <doxygen:param>SEARCH_INCLUDES=NO
- <reftitle>"Interval Template Library DocTest"
+ <reftitle>"Interval Template Library Reference"
     ;
 
 

Added: sandbox/itl/libs/itl/doc/concepts.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/concepts.qbk 2008-12-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -0,0 +1,310 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+[section Concepts]
+
+[section Aspects]
+
+There are two major ['*aspects*] or ['*views*] of itl containers. The first and predominant
+aspect is called __bi_conceptual__. The second and minor aspect is called __bi_iterative__ or
+iteration related.
+
+[/ table
+[[Aspect] [Abstraction level][] [] [Practical]]
+[[__Conceptual__][more abstract][concept related] [iterator independent][interval_sets(maps) can be used as sets(maps)
+ except for element iteration.]]
+[[__Iterative__] [less abstract][implementation related][iterator dependent] [interval_sets(maps) iterate over intervals]]
+]
+
+[table
+[[][__Conceptual__][__Iterative__]]
+[[Abstraction level][more abstract][less abstract]]
+[[][sequence of elements is irrelevant][sequence of elements is relevant]]
+[[][iterator independent][iterator dependent]]
+[[Informs about][membership of elements][sequence of intervals (segmentation)]]
+[[Equality][equality of elements][lexicographical equality]]
+[[Practical][interval_sets(maps) can be used as sets(maps)
+ of elements(element value pairs) ]
+ [Segmentation information is available.
+ See e.g. [link boost_itl.examples.month_and_week_grid Timegrids for months and weeks]]]
+[[] [no iteration over elements] [iteration over intervals]]
+]
+
+On the __conceptual__ aspect
+
+* in __itv__ implements a set of elements partially.
+* an __itv_set__ implements a set of elements.
+* an __itv_map__ implements a map of element value pairs.
+
+On the iteration related or __iterative__ aspect
+
+* an __itv_set__ implements a set of intervals.
+* an __itv_map__ implements a map of interval value pairs.
+
+[endsect][/ Aspects]
+
+
+[section Sets and Maps]
+
+[h5 A Set Concept]
+
+On the __conceptual__ aspect the __itl_set__ and all __itv_bsets__ are models
+of a concept `Set`.
+The `Set` concept of the Interval Template Library refers to the
+mathematical notion of a set.
+
+[table
+[[Function] [Variant][implemented as] ]
+[[empty set ] [] [`Set::Set()`] ]
+[[subset relation] [] [`bool Set::contained_in(const Set& s2)const`] ]
+[[equality ] [] [`bool is_element_equal(const Set& s1, const Set& s2)`]]
+[[set union] [inplace][`Set& operator += (Set& s1, const Set& s2)`] ]
+[[] [] [`Set operator + (const Set& s1, const Set& s2)`]]
+[[set difference] [inplace][`Set& operator -= (Set& s1, const Set& s2)`] ]
+[[] [] [`Set operator - (const Set& s1, const Set& s2)`]]
+[[set intersection][inplace][`Set& operator *= (Set& s1, const Set& s2)`] ]
+[[] [] [`Set operator * (const Set& s1, const Set& s2)`]]
+]
+
+Equality on `Sets` is not implemented as `operator ==`, because `operator ==`
+is used for the stronger lexicographical equality, that takes the
+sequence of elements into account. The sequence of elements belongs to
+the __iterative__ aspect.
+
+Being models of concept `Set`, __itl_set__ and all __itv_bsets__
+implement these
+operations and obey the associated laws on `Sets`. See e.g.
+[@http://en.wikipedia.org/wiki/Algebra_of_sets an algebra of sets here].
+
+[h5 Making intervals complete]
+
+An __itv__ is considered to be a set of elements as well.
+With respect to the `Set` concept
+presented above __itv__ implements the concept only partially. The reason for
+that is that addition `operator +=` and subtraction `operator -=` can not
+be defined on __itvs__. Two intervals `[1,2]` and `[4,5]` are not addable to
+a single new __itv__. In other words __itvs__ are incomplete w.r.t. union and
+difference. __Itv_sets__ can be defined as the ['*completion*] of intervals
+for the union and difference operations.
+
+[h5 A Map Concept]
+
+On the __conceptual__ aspect __itl_map__ and all __itv_bmaps__ are models of a
+concept `Map`.
+Since a `map` is a `set of pairs`, we try to design the `Map` concept in accordance
+to the `Set` concept above.
+
+[table
+[[Function] [Variant][implemented as] ]
+[[empty map ] [] [`Map::Map()`] ]
+[[subset relation] [] [`bool Map::contained_in(const Map& s2)const`] ]
+[[equality ] [] [`bool is_element_equal(const Map& s1, const Map& s2)`]]
+[[set union] [inplace][`Map& operator += (Map& s1, const Map& s2)`] ]
+[[] [] [`Map operator + (const Map& s1, const Map& s2)`]]
+[[set difference] [inplace][`Map& operator -= (Map& s1, const Map& s2)`] ]
+[[] [] [`Map operator - (const Map& s1, const Map& s2)`]]
+[[set intersection][inplace][`Map& operator *= (Map& s1, const Map& s2)`] ]
+[[] [] [`Map operator * (const Map& s1, const Map& s2)`]]
+]
+
+As one can see, on the abstract kernel the signatures of the itl's `Set` and `Map`
+concepts are identical, except for the typename. This is not a trivial
+signature since the major
+operations that are used in fundamental axioms that make up the semantics
+of the concepts are given. While signatures are identical
+The sets of valid laws are different, which will be discussed in more detail
+in section JODO.
+
+[/ This is due to the fact, that Map::operator+= is not just adding and
+Map::operator-= is not only removing ... liegt and der implementierung von
+add und subtract.]
+
+[/ Auf dem Kern sind die Signaturen (fast) gleich. Unterschiede Semantik.
+vor allem +=, -= und erst recht *=]
+
+These semantical differences are mainly based on the implementation
+of the pivotal memberfunctions `add` and `subtract` for elements
+and intervals that again serve for implementing
+`operator +=` and `operator -=`.
+[endsect][/ Abstract Sets and Maps]
+
+[section Addability, Subtractability and Aggregate on Overlap]
+
+While addition and subtraction on `Sets` implement set union and
+set difference, for `Maps` we want to implement ['*aggregation*] on
+the associated values for the case of collision (of key elements)
+or overlap (of key intervals), which has been refered to as
+['*aggregate on overlap*] or ['*aggrovering*] above.
+
+This kind of `Addability` and `Subtractability` allows to compute
+a lot of useful aggregation results on an __itv_map_s__ associated
+values, just by adding and subtracting value pairs.
+Various examples of ['*aggrovering*] are given in
+[link boost_itl.examples section examples].
+In addition this concept of `Addability` and `Subtractability`
+contains the classical `Insertability` and `Erasability` of
+key value pairs as a special case so it provides a broader
+new semantics without loss of the /classical/ one.
+
+Aggregation is implemented for functions `add` and `subtract`
+by propagating a `Combiner` functor to combine associated values
+of type `CodomainT`. The standard `Combiner` is set as
+default template parameter
+`template<class>class Combine = inplace_plus`, which
+is again generically implemented by `operator +=` for all
+Addable types.
+
+For `Combine` functors, the Itl provides an __inverse__ functor.
+
+[table
+[[Combine<T>] [inverse<Combine<T> >::type]]
+[[__ip_plus__`<T>`] [__ip_minus__`<T>`] ]
+[[__ip_star__`<T>`] [__ip_div__`<T>`] ]
+[[__ip_max__`<T>`] [__ip_min__`<T>`] ]
+[[__ip_identity__`<T>`][__ip_erasure__`<T>`]]
+[[`Functor`] [__ip_erasure__`<T>`]]
+]
+
+The meta function __inverse__ is mutually implemented for
+all but the default functor `Functor`
+such that e.g.
+`inverse<inplace_minus<T> >::type` yields `inplace_plus<T>`.
+Not in every case, e.g. `max/min`, does the __inverse__ functor
+invert the effect of it's antetype. But for the default
+it does:
+
+[table
+[[] [`add<Combine<CodomainT> >((k,x))`] [`subtract<inverse<Combine<CodomainT> >::type>((k,x))`]]
+[[Instance] [`add<inplace_plus<int> >((k,x))`] [`subtract<inplace_minus<int> >((k,x))`]]
+[[Inversion][adds `x` on overlap. This inverts a preceeding `subtract` of `x` on `k`][subtracts `x` on overlap. This inverts a preceeding `add` of `x` on `k`]]
+]
+
+
+As already mentioned aggregating `Addability` and `Subtractability`
+on `Maps` contains the /classical/ `Insertability` and `Erasability` of
+key value pairs as a special case:
+
+[table
+[[aggregating function][equivalent /classical/ function]]
+[[`add<inplace_identity<CodomainT> >(const value_type&)`] [`insert(const value_type&)`]]
+[[`subtract<inplace_erasure<CodomainT> >(const value_type&)`][`erase(const value_type&)`]]
+]
+
+The aggregating member function templates `add` and `subtract`
+are not in the public interface of __itv_bmaps__, because
+the `Combine` functor is intended to be an invariant
+of __itv_bmap_s__
+template instance to avoid, that clients
+spoil the aggregation by accidently calling
+variing aggregation functors.
+But you could instantiate an __itv_map__ to have
+`insert/erase` semantics this way:
+``
+interval_map<int,int,neutron_absorber,interval,
+ std::less,
+ inplace_identity //Combine parameter specified
+ > m;
+interval<int> itv = interval<int>::rightopen(2,7);
+m.add(make_pair(itv,42)); //same as insert
+m.subtract(make_pair(itv,42)); //same as erase
+``
+
+This is, of course, only a clarifying example. Member functions
+`insert` and `erase` are available in __itv_bmap_s__ interface
+so they can be called directly.
+
+[endsect][/ Addability, Subtractability and Aggregation on Overlap]
+
+
+[section Kind of nuclear: Map Traits]
+
+Itl maps differ in their behavior dependent on how they handle
+['*neutral elements*] of the associated type `CodomainT`. This
+section became ['kind of nuclear] at least in wording.
+But rest assured `itl::Maps` won't contaminate your software.
+
+In the itl we call ['*neutral elements*] `neutrons` and all values
+that [*are not] `neutrons` we call `protons`. The way, in which
+`neutrons` are dealt with in maps can be specified by the template parameter
+`Traits`. In the pseudo code snipplets below `0` will be used to denote
+`neutrons`, which can be
+different objects like `const double 0.0`, empty sets, empty strings,
+null-vectors etc. dependent of the instance type for parameter `CodomainT`.
+The existence of a ['*neutral element*] wrt. an `operator+=` is a requirement
+for template type `CodomainT`.
+
+[table
+[[Trait][]]
+[[__absorber__][value pairs that carry neutrons `(x,0)` are never stored]]
+[[__enricher__][value pairs that carry neutrons `(x,0)` are never deleted by subtract]]
+[[__emitter__] [all value pairs that don't carry protons have neutrons as mapped values.]]
+]
+
+[h4 Neutron Absorber]
+
+From a pragmatic perspective value pairs that carry `neutrons` as
+mapped values can often be deleted. If we count, for instance,
+the number of overlaps of inserted intervals in an __itv_map__
+(see example [overlap_counter]), most of the time, we are not
+interested in whether an overlap has been counted `0` times or
+has not been counted at all.
+
+A Map that does never insert
+associated neutrons or deletes them when they emerge, is called
+__absorber__. To be a __absorber__ is the default setting
+for the Trait parameter. Moreover a __absorber__ is able
+to erase a pair `(x,y)` from a map `{(x,y)}` by calling
+`subtract((x,y))` or `operator -`:
+
+``{(x,y)} - (x,y) == {}``
+
+[h4 Neutron Enricher]
+
+With a __enricher__, on the contrary, subtraction of a
+pair `(x,y)` that is in the map results in a pair `(x,0)`.
+`{(x,y)} - (x,y) == {(x,0)}`. Mapping pairs that carry
+`neutrons` may emerge as a result of computations and they can
+not be erased by subtractions, so they are /enriched/ in the map.
+
+A neutron enricher carries the information, if values have
+been added or aggregated for certain keys and resulted in a `neutron`
+value or if they have not been aggregated at all: No values
+exists for a key.
+
+The following distinction can *not* be made for a __absorber__ map
+but it can be made for an __enricher__ map:
+[pre
+(k,y) does not exist in the map: Pair (k,y) has NOT been dealt with
+(k,0) key k carries 0 : Pair (k,y) has been dealt with resulting in y=0
+]
+
+Sometimes this subtle distiction is needed. Then a __enricher__
+is the right choice. Also, If we want to give two `itl::Maps`
+a common set of keys in order to, say, iterate synchronously
+over both maps, we need __enricher__ s.
+
+[h4 Neutron Emitter]
+
+The third neutronic Trait is called __emitter__.
+A map that is a __emitter__ is defined on every value
+of it's domain. It emits a
+neutron value for every key value, that has not been set or
+aggregated to a value unequal to the `neutron` value.
+
+That way a __emitter__ map is an ['*infinite vector*], that
+is always initialized with neutron values.
+
+Of course those initial neutronic values for all keys of the
+maps domain is *not* stored on the __emitter__ map. So it's
+implementation is as minimal as the implementation of a
+__absorber__.
+
+[endsect] [/ kind of nuclear]
+
+[endsect][/ Concepts]
+

Modified: sandbox/itl/libs/itl/doc/examples.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/examples.qbk (original)
+++ sandbox/itl/libs/itl/doc/examples.qbk 2008-12-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -23,7 +23,7 @@
         [[basic] [[link boost_itl.examples.interval_container Interval container]]
                 [__itv_set__,\n__sep_itv_set__,\n__spl_itv_set__,\n__spl_itv_map__]
                                        [basic charactersistics of interval container]]
- [[basic] [overlap_counter][__itv_map__][The most simple application of an interval map: Counting
+ [[basic] [[link boost_itl.examples.overlap_counter overlap counter]][__itv_map__][The most simple application of an interval map: Counting
                                                   the overlaps of added intervals.]]
         [[advanced][[link boost_itl.examples.month_and_week_grid Timegrids for months and weeks]]
                                     [__spl_itv_set__]
@@ -106,7 +106,7 @@
 
 Example [*interval container] demonstrates the characteristic behaviors
 of different interval containers that are also summarized
-in the introductory [link boost.itl.introduction.interval_combining_styles Interval Combining Styles].
+in the introductory [link boost_itl.introduction.interval_combining_styles Interval Combining Styles].
 
 [import ../example/interval_container/interval_container.cpp]
 [example_interval_container]

Modified: sandbox/itl/libs/itl/doc/interface.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/interface.qbk (original)
+++ sandbox/itl/libs/itl/doc/interface.qbk 2008-12-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -6,159 +6,16 @@
     http://www.boost.org/LICENSE_1_0.txt)
 ]
 
-[section Concepts]
-
-[section Abstract Sets and Maps]
-
-On the __conceptual__ aspect the __itl_set__ and all __itv_bset__ are a model
-of a concept Set.
-The Set concept of the Interval Template Library refers to the
-mathematical notion of a set.
-
-[table
-[[Function] [Variant][implemented as] ]
-[[empty set ] [] [`Set::Set()`] ]
-[[subset relation] [] [`bool Set::contained_in(const Set& s2)const`] ]
-[[equality ] [] [`bool is_element_equal(const Set& s1, const Set& s2)`]]
-[[set union] [inplace][`Set& operator += (Set& s1, const Set& s2)`] ]
-[[] [] [`Set operator + (const Set& s1, const Set& s2)`]]
-[[set difference] [inplace][`Set& operator -= (Set& s1, const Set& s2)`] ]
-[[] [] [`Set operator - (const Set& s1, const Set& s2)`]]
-[[set intersection][inplace][`Set& operator *= (Set& s1, const Set& s2)`] ]
-[[] [] [`Set operator * (const Set& s1, const Set& s2)`]]
-]
-
-Equality on Sets is not implemented as `operator ==`, because `==` is used for
-the stronger lexicographical equality, that takes the sequence of elements into
-account.
-
-Being models of concept Set, __itl_set__ and all __itv_bsets__ and __itl_set__
-implement these
-operations and obey the associated laws on Sets. See e.g.
-[@http://en.wikipedia.org/wiki/Algebra_of_sets an algebra of sets here].
-
-
-On the __conceptual__ aspect __itl_map__ and all __itv_bmaps__ are models of a
-concept Map.
-Since a map is a set of pairs, we try to design the map concept in accordance
-to the Set concept above.
-
-[table
-[[Function] [Variant][implemented as] ]
-[[empty map ] [] [`Map::Map()`] ]
-[[subset relation] [] [`bool Map::contained_in(const Map& s2)const`] ]
-[[equality ] [] [`bool is_element_equal(const Map& s1, const Map& s2)`]]
-[[set union] [inplace][`Map& operator += (Map& s1, const Map& s2)`] ]
-[[] [] [`Map operator + (const Map& s1, const Map& s2)`]]
-[[set difference] [inplace][`Map& operator -= (Map& s1, const Map& s2)`] ]
-[[] [] [`Map operator - (const Map& s1, const Map& s2)`]]
-[[set intersection][inplace][`Map& operator *= (Map& s1, const Map& s2)`] ]
-[[] [] [`Map operator * (const Map& s1, const Map& s2)`]]
-]
-
-As one can see, on the abstract kernel the signatures of the itl's Set and Map
-concepts are identical, except for the typename. This is not a trivial
-signature since the major
-operations that are used in fundamental axioms that make up the semantics
-of the concepts are given. Interestingly, while signatures are identical
-The set of valid laws are different.
-
-[/ This is due to the fact, that Map::operator+= is not just adding and
-Map::operator-= is not only removing ... liegt and der implementierung von
-add und subtract.]
-
-[/ Auf dem Kern sind die Signaturen (fast) gleich. Unterschiede Semantik.
-vor allem +=, -= und erst recht *=]
-
-[/ insert = add<inplace_identity>]
-[/ erase = subtract<inplace_identity>]
-
-[/ Kind of nuclear]
-
-Itl maps differ in their behavior dependent on how they handle
-neutral elements of the associated value type CodomainT. In the
-itl we call neutral elements neutrons. The way, in which
-neutrons are dealt with can be specified by the template parameter
-Traits.
-
-[/ Tabellchen absorber, enricher, emitter]
-
-From a pragmatic perspective value pairs that carry neutrons as
-mapped values can often be deleted. A Map that does never insert
-associated neutrons or deletes them when they emerge, is called
-a neutron_absorber. To be a neutron_absorber is the default setting
-for the Trait parameter. Moreover a neutron_absorber is able
-to erase a pair (x,y) from a map {(x,y)} by calling subtract((x,y))
-{(x,y)}.subtract((x,y)) == {}.
-
-With a neutron_enricher, on the contrary, subtraction of a
-pair (x,y) that is in the map results in a pair (x,0).
-{(x,y)}.subtract((x,y)) == {(x,0)}. Mapping pairs that carry
-neutrons may emerge as a result of computations and they can
-not be erased by subtractions, so they are enriched in the map.
-
-A neutron enricher carries the information, if values have
-been aggregated for certain keys and resulted in a neutron value
-or if they have not been aggregated at all: No values
-exists for a key.
-
-For a neutron_absorber this distinction can not be made:
-# key k exists and associated value is a neutron:
- There where aggregations.
-# key k does not exist: No aggregation at all for k.
-
-Sometimes this distictin is needed. Then a neutron_enricher
-is the right choice. Also, If we want to give to itl::Maps
-A common set of keys in order to say iterate synchroniously
-over both maps, we need neutron_enrichers.
-
-The third neutronic trait is called neutron_emitter.
-A map that is a neutron_emitter is defined on every value
-of it's domain. It emits a neutron value for
-every key value, that has not been set or aggregated to
-a values unequal to the neutron value.
-
-That way a neutron emitter map is an infinite array, that
-is always initialized with neutron values.
-
-[endsect]
-
-[endsect]
-
 [section Interface]
 
-Section Interface gives an overview over the types and functions
-of the ITL. Synoptical tables allow to review the overall structure of
+Section *Interface* gives an overview over the types and functions
+of the *Itl*. Synoptical tables allow to review the overall structure of
 the libraries design and to recognize structural equalities and differences
 with the corresponding containers of the standard template library.
 
-There are two majaor aspects or views of itl containers. The first and predominant
-aspect is called __conceptual__. The second and minor aspect is called iterative or
-iteration related.
-
-[table
-[[Aspect] [Abstraction level][] [] [Practical]]
-[[__Conceptual__][more abstract][concept related] [iterator independent][interval_sets(maps) can be used as sets(maps)
- except for element iteration.]]
-[[Iterative] [less abstract][implementation related][iterator dependent] [interval_sets(maps) iterate over intervals]]
-]
-
-On the __conceptual__ aspect
-
-* in interval implements a set of elements partially.
-* an interval_set implements a set of elements.
-* an interval_map implements a map of element value pairs.
-
-On the iteration related or iterative aspect
-
-* an interval_set implements a set of intervals.
-* an interval_map implements a map of interval value pairs.
-
-
-
 In the table of associated types of interval_sets
 there are types like key_type, value_type and key_compare
-for the iterative aspect.
+for the __iterative__ aspect.
 
 [section Class templates]
 

Added: sandbox/itl/libs/itl/doc/introduction.qbk
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/doc/introduction.qbk 2008-12-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -0,0 +1,229 @@
+[/
+ Copyright (c) 2008-2009 Joachim Faulhaber
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+]
+
+[section Introduction]
+
+[section Definition and Basic Example]
+
+The [*Interval Template Library (ITL)] provides __itvs__ and two kinds of
+interval containers: __itv_sets__ and __itv_maps__.
+
+* An __itv_bset__ implements a [*set] as a set of intervals.
+* An __itv_bmap__ implements a [*map] as a map of interval value pairs.
+
+[h4 Two Aspects]
+
+__Itv_bsets__ and __itv_bmaps__ expose two different aspects in
+their interfaces: (1) The functionality of a set or a map, which is the more
+['*abstract aspect*]. And (2) the functionality of a container of intervals which
+is the more specific and ['*implementation related aspect*]. In practice both
+aspects are useful and are therefore supported.
+
+The first aspect, that will be called __bi_conceptual__ ['*aspect*], is the more important one.
+It means that we can use an __itv_set__ or __itv_map__ like a
+set or map ['*of elements*]. It exposes the same functions.
+``
+interval_set<int> mySet;
+mySet.insert(42);
+bool has_answer = mySet.contains(42);
+``
+
+
+The second aspect, that will be called __bi_iterative__ ['*aspect*], allows to exploit the
+fact, that the elements of __itv_sets__ and __itv_maps__ are clustered in
+__itvs__ that we can iterate over.
+
+``
+// Switch on my favorite telecasts using an interval_set
+interval<seconds> news(make_seconds("20:00:00"), make_seconds("20:15:00"));
+interval<seconds> talk_show(make_seconds("22:45:30"), make_seconds("23:30:50"));
+interval_set<seconds> myTvProgram;
+myTVProgram.add(news).add(talk_show);
+
+// Iterating over elements (seconds) would be silly ...
+for(interval_set<seconds>::iterator telecast = myTvProgam.begin();
+ telecast != myTvProgam.end(); ++telecast)
+ //...so this iterates over intervals
+ TV.switch_on(*telecast);
+``
+
+Working with __itv_sets__ and __itv_maps__ can be
+beneficial whenever the elements of
+sets appear in contiguous chunks: __itvs__. This is obviously the
+case in many problem domains, particularly in fields that deal with
+computations related to date and time.
+
+[h4 Addabitlity and Subtractability]
+
+Unlike `std::sets` and `maps`, __itv_sets__ and __itv_maps__ implement
+concept `Addable` and `Subtractable`. So __itv_sets__ define an
+`operator +=` that is naturally implemented as ['*set union*] and an
+`operator -=` that is consequently implemented as ['*set difference*].
+In the *Itl* __itv_maps__ are addable and subtractable as well.
+It turned out to be a very fruitful concept to propagate the
+addition or subtraction to the __itv_map_s__ associated values
+in cases where the insertion of an interval value pair into an
+__itv_map__ resulted in a collision of the inserted interval
+value pair with interval value pairs, that are already in the
+__itv_map__. This operation propagation is called ['*aggregate on overlap*].
+
+
+[h4 Aggregate on Overlap]
+
+This is a first motivating example of a very small party, demonstrationg the
+['*aggregate on overlap*] principle ['*(aggrovering)*] on __itv_maps__:
+
+In the example Mary enters the party first. She attends during the
+time interval `[20:00,22:00)`. Harry enters later. He stays within `[21:00,23:00)`.
+``
+typedef itl::set<string> guests;
+interval_map<time, guests> party;
+party += make_pair(interval<time>::rightopen(20:00, 22:00), guests("Mary"));
+party += make_pair(interval<time>::rightopen(21:00, 23:00), guests("Harry"));
+// party now contains
+[20:00, 21:00)->{"Mary"}
+[21:00, 22:00)->{"Harry","Mary"} //guest sets aggregated on overlap
+[22:00, 23:00)->{"Harry"}
+``
+['*On overlap of intervals*], the corresponding name sets are ['*accumulated*]. At
+the ['*points of overlap*] the intervals are ['*split*]. The accumulation of content on
+overlap of intervals is done via an `operator +=` that has to be implemented
+for the associated values of the __itv_map__. In the example
+the associated values are `guest sets`. Thus a `guest set` has to implement
+`operator +=` as set union.
+
+As can be seen from the example an __itv_map__ has both
+a ['*decompositional behavior*] (on the time dimension) as well as
+an ['*accumulative one*] (on the associated values).
+[endsect]
+
+[section Itl's class templates]
+
+In addition to interval containers the *itl* provides element containers
+__itl_set__ and __itl_map__.
+
+* An __itl_set__ is behavioral equal to __itv_bsets__
+ except for iteration, that is to say behavioral equal on
+ the __bi_conceptual__ aspect.
+
+* An __itl_map__ is behavioral equal to __itv_bmaps__
+ except for iteration, that is to say behavioral equal on
+ the __bi_conceptual__ aspect. Specifically a __itl_map__
+ implements ['*aggregate on overlap*], which is
+ named ['*aggregate on collision*] for an element container.
+
+The following table gives an overview over the main
+class templates provided by the *itl*.
+
+[table Synopsis over the itl's class templates
+[[granularity][style] [sets] [maps] ]
+[[interval] [] [__itv__] [] ]
+[[] [joining] [__itv_set__] [__itv_set__] ]
+[[] [separating][__sep_itv_set__][] ]
+[[] [splitting] [__spl_itv_set__][__spl_itv_set__]]
+[[element] [] [__ele_set__] [__ele_map__] ]
+]
+
+__Itv__ is placed deliberately in column *sets* because an
+interval is a set as well. Column ['*style*] refers to
+the different ways in which interval containers combine added
+intervals. These ['*combining styles*] are described in the next
+section.
+
+[endsect]
+
+[section Interval Combining Styles]
+
+When we add intervals or interval value pairs to interval containers,
+the intervals can be added in different ways: Intervals can be
+joined or splitted or kept separate. The different interval combining
+styles are shown by example in the tables below.
+
+[table Interval container's ways to combine intervals
+ [[] [joining] [separating] [splitting]]
+ [[set] [[classref boost::itl::interval_set interval_set]]
+ [[classref boost::itl::separate_interval_set separate_interval_set]]
+ [[classref boost::itl::split_interval_set split_interval_set]]]
+ [[map] [[classref boost::itl::interval_map interval_map]]
+ []
+ [[classref boost::itl::split_interval_map split_interval_map]]]
+ [[] [Intervals are joined on overlap or touch\n(if associated values are equal).]
+ [Intervals are joined on overlap, not on touch.]
+ [Intervals are split on overlap.\nAll interval borders are preserved.]]
+]
+
+[table Interval combining styles by example
+ [[] [joining] [separating] [splitting]]
+ [[set] [[classref boost::itl::interval_set interval_set] /A/]
+ [[classref boost::itl::separate_interval_set separate_interval_set] /B/]
+ [[classref boost::itl::split_interval_set split_interval_set] /C/]]
+[[]
+[``
+ {[1 3) }
++ [2 4)
++ [4 5)
+= {[1 5)}``]
+[``
+ {[1 3)} }
++ [2 4)
++ [4 5)
+= {[1 4)[4 5)}``]
+[``
+ {[1 3) }
++ [2 4)
++ [4 5)
+= {[1 2)[2 3)[3 4)[4 5)}``]
+]
+
+ [[map] [[classref boost::itl::interval_map interval_map] /D/]
+ []
+ [[classref boost::itl::split_interval_map split_interval_map] /E/]]
+
+[[]
+[``
+ {[1 3)->1 }
++ [2 4)->1
++ [4 5)->1
+= {[1 2)[2 3)[3 5) }
+ | ->1 ->2 ->1 |``]
+[]
+[``
+ {[1 3)->1 }
++ [2 4)->1
++ [4 5)->1
+= {[1 2)[2 3)[3 4)[4 5) }
+ | ->1 ->2 ->1 ->1 |``]
+]
+]
+
+Note that =interval_sets= /A/, /B/ and /C/ represent the same set of elements ={1,2,3,4}=
+and =interval_maps= /D/ and /E/ represent the same map of elements [^{1->1, 2->2, 3->1, 4->1}].
+See example program [link boost_itl.examples.interval_container Interval container]
+for an additional demo.
+
+[h4 Joining interval containers]
+
+__Itv_set__ and __itv_map__ are always
+in a ['*minimal representation*]. This is useful in many cases, where the
+points of insertion or intersecton of intervals are not relevant. So in most
+instances __itv_set__ and
+__itv_map__ will be the first choice
+for an interval container.
+
+[h4 Splitting interval containers]
+
+__Spl_itv_set__ and __spl_itv_map__ on the contrary
+have an ['*insertion memory*]. They do accumulate interval borders both
+from additions and intersections. This is specifically useful, if we want
+to enrich an interval container with certain time grids, like e.g. months
+or calendar weeks or both. See example [link boost_itl.examples.month_and_week_grid timegrids for months and weeks].
+
+[endsect]
+
+[endsect][/ Introduction]
+

Modified: sandbox/itl/libs/itl/doc/itl.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/itl.qbk (original)
+++ sandbox/itl/libs/itl/doc/itl.qbk 2008-12-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -49,16 +49,34 @@
 [def __Itv_bmap__ [classref boost::itl::interval_base_map Interval_map]]
 [def __itv_bmaps__ [classref boost::itl::interval_base_map interval_maps]]
 [def __Itv_bmaps__ [classref boost::itl::interval_base_map Interval_maps]]
+[def __itv_bmap_s__ [classref boost::itl::interval_base_map interval_map's]]
 [def __Itv_map__ [classref boost::itl::interval_map Interval_map]]
 [def __spl_itv_map__ [classref boost::itl::split_interval_map split_interval_map]]
 [def __Spl_itv_map__ [classref boost::itl::split_interval_map Split_interval_map]]
 [def __spl_itv_maps__ [classref boost::itl::split_interval_map split_interval_maps]]
 
+[def __inverse__ [classref boost::itl::inverse inverse]]
+[def __ip_plus__ [classref boost::itl::inplace_plus inplace_plus]]
+[def __ip_minus__ [classref boost::itl::inplace_minus inplace_minus]]
+[def __ip_star__ [classref boost::itl::inplace_star inplace_star]]
+[def __ip_div__ [classref boost::itl::inplace_div inplace_div]]
+[def __ip_min__ [classref boost::itl::inplace_min inplace_min]]
+[def __ip_max__ [classref boost::itl::inplace_max inplace_max]]
+[def __ip_identity__ [classref boost::itl::inplace_identity inplace_identity]]
+[def __ip_erasure__ [classref boost::itl::inplace_erasure inplace_erasure]]
+
+[def __itv_bmap_add__ [memberref boost::itl::interval_base_map::add add]]
+
+
 [def __ele_map__ [classref boost::itl::map map]]
 [def __ele_maps__ [classref boost::itl::map maps]]
 [def __itl_map__ [classref boost::itl::map itl::map]]
 [def __itl_maps__ [classref boost::itl::map itl::maps]]
 
+[def __absorber__ [classref boost::itl::neutron_absorber neutron_absorber]]
+[def __enricher__ [classref boost::itl::neutron_enricher neutron_enricher]]
+[def __emitter__ [classref boost::itl::neutron_emitter neutron_emitter]]
+
 [def __itv_bse_set__ [classref boost::itl::interval_base_set interval_base_set]]
 [def __e [link element_type *e*]]
 [def __i [link interval_type *i*]]
@@ -73,10 +91,13 @@
 [def __eiS [link element_type *e*] [link interval_type *i*] [link interval_set_types *S*]]
 [def __bpM [link element_mapping_type *b*] [link interval_mapping_type *p*] [link interval_map_types *M*]]
 
-[def __conceptual__ functional]
-[def __Conceptual__ Functional]
-[def __iterative__ sequential]
-[def __Itervative__ Sequential]
+[def __bi_conceptual__ ['*conceptual*]]
+[def __conceptual__ conceptual]
+[def __Conceptual__ Conceptual]
+
+[def __bi_iterative__ ['*iterative*]]
+[def __iterative__ iterative]
+[def __Iterative__ Iterative]
 
 [/ Cited Boost resources ]
 
@@ -88,231 +109,14 @@
 [def __GO_TO__ [$images/callouts/R.png]]
 
 
-[section Introduction]
-
-[section Definition and Basic Example]
-
-The ['*Interval Template Library (ITL)*] provides __itvs__ and two kinds of
-interval containers: __itv_sets__ and __itv_maps__.
-
-* An __itv_bset__ implements a [*set] as a set of intervals.
-* An __itv_bmap__ implements a [*map] as a map of interval value pairs.
-
-[h4 Two Aspects]
-
-__Itv_bsets__ and __itv_bmaps__ expose two different aspects in
-their interfaces: (1) The functionality of a set or a map, which is the more
-['abstract aspect]. And (2) the functionality of a container of intervals which
-is the more specific and ['implementation related aspect]. In practice both
-aspects are useful and are therefore supported.
-
-The first aspect, that will be called ['*__conceptual__ aspect*], is the more important one.
-It means that we can use an __itv_set__ or __itv_map__ like a
-set or map ['*of elements*]. The it exposes the same functions.
-``
-interval_set<int> mySet;
-mySet.insert(42);
-bool has_answer = mySet.contains(42);
-``
-
-
-The second aspect, that will be called ['*iterative aspect*], allows to exploit the
-fact, that the elements of __itv_sets__ and __itv_maps__ are clustered in
-__itvs__ that we can iterate over.
-
-``
-// Switch on my favorite telecasts using an interval_set
-interval<seconds> news(make_seconds("20:00:00"), make_seconds("20:15:00"));
-interval<seconds> talk_show(make_seconds("22:45:30"), make_seconds("23:30:50"));
-interval_set<seconds> myTvProgram;
-myTVProgram.add(news).add(talk_show);
-
-// Iterating over elements (seconds) would be silly ...
-for(interval_set<seconds>::iterator telecast = myTvProgam.begin();
- telecast != myTvProgam.end(); ++telecast)
- //...so this iterates over intervals
- TV.switch_on(*telecast);
-``
-
-Working with interval_sets and interval_maps can be
-beneficial whenever the elements of
-sets appear in contiguous chunks: __itvs__. This is obviously the
-case in many problem domains, namely in fields that deal with problems
-related to date and time.
-
-[h4 Addabitlity and Subtractability]
-
-Unlike std::sets and maps, __itv_sets__ and __itv_maps__ implement
-concept Addable and Subtractable. So __itv_sets__ define an
-`operator +=` that is naturally implemented as ['*set union*] and an
-`operator -=` that is consequently implemented as ['*set difference*].
-In the *itl* also __itv_maps__ are Addable and Subtractable.
-It turned out to be a very fruitful concept to propagate the
-addition or subtraction to the __itv_map_s__ associated values
-in cases where the insertion of an interval value pair into an
-__itv_map__ resulted in a collision of the inserted interval
-value pare with intervals value pairs, that were already in the
-__itv_map__. This operation propagation is called ['*aggregate on overlap*].
-
-
-[h4 Aggregate on Overlap]
-
-This is a first motivating example of a very small party, demonstrationg the
-['*aggregate on overlap*] principle ['*(aggrovering)*] on __itv_maps__:
-
-In the example Mary enters the party first. She attends during the
-time interval [20:00,22:00). Harry enters later he stays within [21:00,23:00).
-``
-typedef itl::set<string> guests;
-interval_map<time, guests> party;
-party += make_pair(interval<time>::rightopen(20:00, 22:00), guests("Mary"));
-party += make_pair(interval<time>::rightopen(21:00, 23:00), guests("Harry"));
-// party now contains
-[20:00, 21:00)->{"Mary"}
-[21:00, 22:00)->{"Harry","Mary"} //guest sets aggregated on overlap
-[22:00, 23:00)->{"Harry"}
-``
-On overlap of intervals, the corresponding name sets are accumulated. At
-the points of overlap the intervals are split. The accumulation of content on
-overlap of intervals is done via an `operator +=` that has to be implemented
-for the associated values of the __itv_map__. In the example
-the associated values are guest sets. This set has thus to implement
-`operator +=` as set union.
-
-As can be seen from the example an __itv_map__ has both
-a ['*decompositional behavior*] (on the time dimension) as well as
-an ['*accumulative one*] (on the associated values).
-[endsect]
-
-[section Itl's class templates]
-
-In completion to interval containers the *itl* provides element containers
-__itl_set__ and __itl_map__.
-
-* An __itl_set__ is behavioral equal to __itv_bsets__
- except for iteration. That is to say behavioral equal on
- the __conceptual__ aspect.
-
-* An __itl_map__ is behavioral equal to __itv_bmaps__
- except for iteration, that is on the conceptional
- aspect. Specifically a __itl_map__
- implements ['*aggregate on overlap*], which is
- named ['*aggregate on collision*] for an element container.
-
-The following tabel gives an overview over the main
-class templates provided by the *itl*.
-
-[table Synopsis over the itl's class templates
-[[granularity][style] [sets] [maps] ]
-[[interval] [] [__itv__] [] ]
-[[] [joining] [__itv_set__] [__itv_set__] ]
-[[] [separating][__sep_itv_set__][] ]
-[[] [splitting] [__spl_itv_set__][__spl_itv_set__]]
-[[element] [] [__ele_set__] [__ele_map__] ]
-]
-
-__Itv__ is placed deliberately in column *sets* because an
-interval is a set as well. Column ['*style*] refers to
-the different ways in which interval containers digest added
-intervals. These combining styles are described in the next
-section.
-
-[endsect]
-
-[section Interval Combining Styles]
-
-When we add intervals or interval value pairs to interval containers,
-the intervals can be added in different ways: Intervals can be
-joined or splitted or kept separate. The different interval combining
-styles are shown by example in the tables below.
-
-[table Interval container's ways to combine intervals
- [[] [joining] [separating] [splitting]]
- [[set] [[classref boost::itl::interval_set interval_set]]
- [[classref boost::itl::separate_interval_set separate_interval_set]]
- [[classref boost::itl::split_interval_set split_interval_set]]]
- [[map] [[classref boost::itl::interval_map interval_map]]
- []
- [[classref boost::itl::split_interval_map split_interval_map]]]
- [[] [Intervals are joined on overlap or touch\n(if associated values are equal).]
- [Intervals are joined on overlap, not on touch.]
- [Intervals are split on overlap.\nAll interval borders are preserved.]]
-]
-
-[table Interval combining styles by example
- [[] [joining] [separating] [splitting]]
- [[set] [[classref boost::itl::interval_set interval_set] /A/]
- [[classref boost::itl::separate_interval_set separate_interval_set] /B/]
- [[classref boost::itl::split_interval_set split_interval_set] /C/]]
-[[]
-[``
- {[1 3) }
-+ [2 4)
-+ [4 5)
-= {[1 5)}``]
-[``
- {[1 3)} }
-+ [2 4)
-+ [4 5)
-= {[1 4)[4 5)}``]
-[``
- {[1 3) }
-+ [2 4)
-+ [4 5)
-= {[1 2)[2 3)[3 4)[4 5)}``]
-]
-
- [[map] [[classref boost::itl::interval_map interval_map] /D/]
- []
- [[classref boost::itl::split_interval_map split_interval_map] /E/]]
-
-[[]
-[``
- {[1 3)->1 }
-+ [2 4)->1
-+ [4 5)->1
-= {[1 2)[2 3)[3 5) }
- | ->1 ->2 ->1 |``]
-[]
-[``
- {[1 3)->1 }
-+ [2 4)->1
-+ [4 5)->1
-= {[1 2)[2 3)[3 4)[4 5) }
- | ->1 ->2 ->1 ->1 |``]
-]
-]
-
-Note that =interval_sets= /A/, /B/ and /C/ represent the same set of elements ={1,2,3,4}=
-and =interval_maps= /D/ and /E/ represent the same map of elements [^{1->1, 2->2, 3->1, 4->1}].
-
-[h4 Joining interval containers]
-
-__Itv_set__ and __itv_map__ are always
-in a ['*minimal representation*]. This is useful in many cases, where the
-points of insertion or intersecton of intervals are not relevant. So in most
-instances __itv_set__ and
-__itv_map__ will be the first choice
-for an interval container.
-
-[h4 Splitting interval containers]
-
-__Spl_itv_set__ and __spl_itv_map__ on the contrary
-have an ['*insertion memory*]. They do accumulate interval borders both
-from additions and intersections. This is specifically useful, if we want
-to enrich an interval container with certain time grids, like e.g. months
-or calendar weeks or both. See example month_and_week_grid.cpp.
-
-[endsect]
-
-[endsect]
-
 [/aggregate on overlap aggrovering]
 [/aggregate on collide aggrolliding]
 [/split on insertion sploning splonsing; split on addition splonadding,
- spladding, splinsertion; decomposition on insertion]
+ spladding, splinsertion, splinsoring; decomposition on insertion]
 
+[include introduction.qbk]
 [include examples.qbk]
+[include concepts.qbk]
 [include interface.qbk]
 [include acknowledgments.qbk]
 [xinclude itldoc.xml]

Modified: sandbox/itl/libs/itl/example/user_groups/user_groups.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/user_groups/user_groups.cpp (original)
+++ sandbox/itl/libs/itl/example/user_groups/user_groups.cpp 2008-12-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -112,11 +112,9 @@
           from_string("2008-02-01"), from_string("2008-10-15")),
           director_of_admin);
 
- MembershipT all_users = med_users;
- all_users += admin_users;
+ MembershipT all_users = med_users + admin_users;
 
- MembershipT super_users = med_users;
- super_users *= admin_users;
+ MembershipT super_users = med_users * admin_users;
 
     MembershipT::iterator med_ = med_users.begin();
     cout << "----- Membership of medical staff -----------------------------------\n";

Modified: sandbox/itl/libs/itl/test/test_type_lists.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_type_lists.hpp (original)
+++ sandbox/itl/libs/itl/test/test_type_lists.hpp 2008-12-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -23,7 +23,7 @@
     ,short, int, long
     ,float, double
     ,boost::rational<int>
- ,boost::posix_time::ptime
+// ,boost::posix_time::ptime
 // ,boost::gregorian::date
> bicremental_types;
 
@@ -45,7 +45,7 @@
 typedef ::boost::mpl::list<
     unsigned short, unsigned int, unsigned long
     ,short, int, long
- ,boost::posix_time::ptime
+// ,boost::posix_time::ptime
 // ,boost::gregorian::date
> discrete_types;
 

Modified: sandbox/itl/libs/validate/example/labatea/labatea.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labatea/labatea.cpp (original)
+++ sandbox/itl/libs/validate/example/labatea/labatea.cpp 2008-12-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -9,6 +9,9 @@
 +----------------------------------------------------------------------------*/
 #include <iostream>
 #include <stdio.h>
+
+#include <boost/itl/ptime.hpp> //CL (4 a quick test only)
+
 #include <boost/validate/loki_xt/Tuple.h>
 #include <boost/itl/set.hpp>
 #include <boost/itl/map.hpp>
@@ -16,7 +19,9 @@
 #include <boost/validate/laws/monoid.h>
 #include <boost/validate/gentor/gentorprofile.h>
 #include <boost/validate/gentor/rangegentor.h>
-#include <boost/validate/realmvalidater.h>
+
+#include <boost/validate/typevalidater.h>
+//#include <boost/validate/realmvalidater.h>
 #include <boost/itl/interval_set.hpp>
 #include <boost/itl_xt/numbergentor.hpp>
 #include <boost/itl_xt/setgentor.hpp>
@@ -24,16 +29,18 @@
 
 using namespace std;
 using namespace Loki;
+using namespace boost;
 using namespace boost::itl;
+using namespace boost::posix_time;
 
 
 void test_Validater()
 {
- //GentorProfileSgl::it()->set_range_int(-10, 10);
- //GentorProfileSgl::it()->set_range_double(-10.0, 10.0);
- //GentorProfileSgl::it()->set_range_ContainerSize(0, 20);
- //GentorProfileSgl::it()->set_range_interval_int(-20, 20);
- //GentorProfileSgl::it()->set_maxIntervalLength(5);
+ GentorProfileSgl::it()->set_range_int(-10, 10);
+ GentorProfileSgl::it()->set_range_double(-10.0, 10.0);
+ GentorProfileSgl::it()->set_range_ContainerSize(0, 20);
+ GentorProfileSgl::it()->set_range_interval_int(-20, 20);
+ GentorProfileSgl::it()->set_maxIntervalLength(5);
 
 
     //typedef BinaryPushout<itl::split_interval_map<int,double>, itl::map<int,double>, Interval::Atomize, inplace_plus>
@@ -47,25 +54,48 @@
     //LawValidater<Map_Cluster_Intersect_DiagramT, RandomGentor> map_cluster_star_pushout;
     //map_cluster_star_pushout.setTrialsCount(1000);
     //map_cluster_star_pushout.run();
+
+ //typedef InplaceSymmetricDifference<interval_map<int, int, neutron_absorber >, std_equal> TestLawT;
+ //LawValidater<TestLawT, RandomGentor> test_law;
+ //test_law.setTrialsCount(1000);
+ //test_law.run();
+
+ //typedef InplaceDistributivity
+ // <interval_map<int, int, neutron_absorber >,
+ // inplace_plus, inplace_star, itl::protonic_equal> TestLawT;
+ //LawValidater<TestLawT, RandomGentor> test_law;
+ //test_law.setTrialsCount(1000);
+ //test_law.run();
+
+ typedef InplaceAssociativity
+ <interval_map<int, int, neutron_absorber >, inplace_plus> TestLawT;
+ LawValidater<TestLawT, RandomGentor> test_law;
+ test_law.setTrialsCount(1000);
+
+ std::cout << "Start\n";
+ ptime start(microsec_clock::local_time());
+ test_law.run();
+ ptime stop(microsec_clock::local_time());
+ std::cout << "Stop. Time elapsed: " << stop - start << endl;
 }
 
 
 void test_realmvalidater()
 {
- RealmValidater validater;
+// RealmValidater validater;
     cout <<
     ">> ------------------------------------------------------ <<\n"
     ">> -------- Law based test automaton 'LaBatea' ---------- <<\n"
     ">> Output will be generated in a few seconds\n"
     ">> terminate by typing <CTRL>C\n"
     ">> ------------------------------------------------------ <<\n";
- validater.validate();
+// validater.validate();
 };
 
 
 int main()
 {
- //test_Validater();
- test_realmvalidater();
+ test_Validater();
+ //test_realmvalidater();
     return 0;
 }

Modified: sandbox/itl/libs/validate/example/labatea/vc9_labatea.vcproj
==============================================================================
--- sandbox/itl/libs/validate/example/labatea/vc9_labatea.vcproj (original)
+++ sandbox/itl/libs/validate/example/labatea/vc9_labatea.vcproj 2008-12-17 13:00:54 EST (Wed, 17 Dec 2008)
@@ -63,7 +63,7 @@
                         <Tool
                                 Name="VCLinkerTool"
                                 LinkIncremental="2"
- AdditionalLibraryDirectories="../../../../lib"
+ AdditionalLibraryDirectories="../../../../lib; ../../../../stage/lib"
                                 GenerateDebugInformation="true"
                                 SubSystem="1"
                                 RandomizedBaseAddress="1"
@@ -139,7 +139,7 @@
                         <Tool
                                 Name="VCLinkerTool"
                                 LinkIncremental="1"
- AdditionalLibraryDirectories="../../../../lib"
+ AdditionalLibraryDirectories="../../../../lib; ../../../../stage/lib"
                                 GenerateDebugInformation="true"
                                 SubSystem="1"
                                 OptimizeReferences="2"

Date view Thread view Subject view Author view

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