Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r50864 - in sandbox/itl: boost/itl boost/itl/type_traits boost/itl_xt boost/validate boost/validate/laws libs/itl/doc libs/itl/example/boost_party libs/itl/test libs/itl/test/test_quantifier_map libs/itl_xt/test/meta_functors libs/validate/example/labat_single libs/validate/example/labatea
From: afojgo_at_[hidden]
Date: 2009-01-29 03:47:28

Next message: ockham_at_[hidden]: "[Boost-commit] svn:boost r50865 - sandbox/SOC/2006/tree/trunk/libs/tree/test"
Previous message: dave_at_[hidden]: "[Boost-commit] svn:boost r50863 - in trunk/libs/parameter: doc doc/html test test/literate"

Author: jofaber
Date: 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
New Revision: 50864
URL: http://svn.boost.org/trac/boost/changeset/50864

Log:
Refactored. Renamed Map::Traits. Introduced is_total<T>. Stable {msvc-9.0, partly congcc-4.3-a7}

Added:
   sandbox/itl/boost/itl/type_traits/is_total.hpp (contents, props changed)
Removed:
   sandbox/itl/boost/itl/type_traits/emits_neutrons.hpp
Text files modified:
   sandbox/itl/boost/itl/interval_base_map.hpp | 34 +++++++-------
   sandbox/itl/boost/itl/interval_map.hpp | 16 +++---
   sandbox/itl/boost/itl/interval_set.hpp | 2
   sandbox/itl/boost/itl/map.hpp | 44 +++++++++---------
   sandbox/itl/boost/itl/map_algo.hpp | 4
   sandbox/itl/boost/itl/separate_interval_set.hpp | 2
   sandbox/itl/boost/itl/set.hpp | 4
   sandbox/itl/boost/itl/split_interval_map.hpp | 14 +++---
   sandbox/itl/boost/itl/split_interval_set.hpp | 2
   sandbox/itl/boost/itl_xt/tuple_computer.hpp | 2
   sandbox/itl/boost/validate/itl_validater.hpp | 10 ++--
   sandbox/itl/boost/validate/itv_map_groupig_validater.hpp | 32 ++++++------
   sandbox/itl/boost/validate/itv_map_settic_validater.hpp | 26 +++++-----
   sandbox/itl/boost/validate/itv_set_validater.hpp | 8 +-
   sandbox/itl/boost/validate/laws/set_laws.h | 18 +++---
   sandbox/itl/boost/validate/realmvalidater.h | 24 +++++-----
   sandbox/itl/boost/validate/typevalidater.h | 58 ++++++++++++------------
   sandbox/itl/libs/itl/doc/concepts.qbk | 74 +++++++++++++++++++-------------
   sandbox/itl/libs/itl/doc/itl.qbk | 10 ++--
   sandbox/itl/libs/itl/doc/semantics.qbk | 92 ++++++++++++++++++++--------------------
   sandbox/itl/libs/itl/example/boost_party/boost_party.cpp | 2
   sandbox/itl/libs/itl/test/test_interval_map_shared.hpp | 34 +++++++-------
   sandbox/itl/libs/itl/test/test_laws.hpp | 2
   sandbox/itl/libs/itl/test/test_quantifier_map/test_quantifier_map_shared.cpp | 18 +++---
   sandbox/itl/libs/itl_xt/test/meta_functors/meta_functors.cpp | 2
   sandbox/itl/libs/validate/example/labat_single/labat_single.cpp | 20 ++++----
   sandbox/itl/libs/validate/example/labatea/labatea.cpp | 14 +++---
   27 files changed, 291 insertions(+), 277 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 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -139,7 +139,7 @@
     class SubType,
     typename DomainT,
     typename CodomainT,
- class Traits = itl::neutron_absorber,
+ class Traits = itl::partial_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_et, CodomainT),
@@ -164,8 +164,8 @@
                               type;

     typedef interval_base_map<SubType,DomainT,CodomainT,
- itl::neutron_absorber,Compare,Combine,Section,Interval,Alloc>
- neutron_absorber_type;
+ itl::partial_absorber,Compare,Combine,Section,Interval,Alloc>
+ partial_absorber_type;

         typedef type overloadable_type;

@@ -242,7 +242,7 @@

public:
     inline static bool has_symmetric_difference()
- { return is_set<codomain_type>::value || (!is_set<codomain_type>::value && !traits::emits_neutrons); }
+ { return is_set<codomain_type>::value || (!is_set<codomain_type>::value && !traits::is_total); }

         enum{ is_itl_container = true };

@@ -454,7 +454,7 @@
         will be decremented by <tt>y</tt>: <tt>y0 -= y</tt> via operator <tt>-=</tt>
         which has to be implemented for CodomainT. If <tt>y</tt> becomes
         the neutral element CodomainT() <tt>k</tt> will also be removed from
- the map, if the Traits include the property neutron_absorber.
+ the map, if the Traits include the property partial_absorber.

         Insertion and subtraction are reversible as follows:
         <tt>m0=m; m.add(x); m.subtract(x);</tt> implies <tt>m==m0 </tt>
@@ -476,11 +476,11 @@

         If <tt>y</tt> becomes the neutral element CodomainT() <tt>k</tt> will
         also be removed from the map, if the Traits include the property
- neutron_absorber.
+ partial_absorber.
     */
     SubType& subtract(const value_type& x)
     {
- if(Traits::emits_neutrons && !is_set<codomain_type>::value)
+ if(Traits::is_total && !is_set<codomain_type>::value)
                         that()->template add_<inverse_codomain_combine>(x);
         else
                         that()->template subtract_<inverse_codomain_combine>(x);
@@ -743,13 +743,13 @@
             erase_if(content_is_neutron<value_type>());
     }

- /// Copies this map into a neutron_absorber type.
+ /// Copies this map into a partial_absorber type.
     /** \c x is a copy of \c *this as a neutron_aborber.
         A neutron absorber is a map that does not store neutral elements
         (<tt>neutron() == codomain_type()</tt>)
         as associated values.
     */
- void as_neutron_absorber(neutron_absorber_type& x)const
+ void as_neutron_absorber(partial_absorber_type& x)const
     { FOR_IMPLMAP(it) x.add(*it); }

     /// Join bounding intervals
@@ -973,7 +973,7 @@
     typedef IntervalMap<DomainT,CodomainT,
                         Traits,Compare,Combine,Section,Interval,Alloc> sectant_type;

- if(Traits::emits_neutrons)
+ if(Traits::is_total)
         {
                 intersection = *this;
                 intersection += sectant;
@@ -1002,7 +1002,7 @@
                     const typename interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
                     ::value_type& sectant)const
{
- if(Traits::emits_neutrons)
+ if(Traits::is_total)
         {
                 section = *this;
                 section.add(sectant);
@@ -1076,12 +1076,12 @@
         // That which is not shall be added
         // So x has to be 'complementary added' or flipped

- if(Traits::emits_neutrons && Traits::absorbs_neutrons)
+ if(Traits::is_total && Traits::absorbs_neutrons)
         {
                 clear();
                 return *that();
         }
- if(Traits::emits_neutrons && !Traits::absorbs_neutrons)//JODO
+ if(Traits::is_total && !Traits::absorbs_neutrons)//JODO
         {
                 (*that()) += x;
                 FORALL(typename ImplMapT, it_, _map)
@@ -1140,7 +1140,7 @@
         //If span is not empty here, it is not in the set so it shall be added
         add(value_type(span, x_value));

- if(Traits::emits_neutrons && !Traits::absorbs_neutrons) //JODO
+ if(Traits::is_total && !Traits::absorbs_neutrons) //JODO
                 FORALL(typename ImplMapT, it_, _map)
                         it_->CONT_VALUE = neutron<codomain_type>::value();

@@ -1171,12 +1171,12 @@
{
     typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> operand_type;

- if(Traits::emits_neutrons && Traits::absorbs_neutrons)
+ if(Traits::is_total && Traits::absorbs_neutrons)
         {
                 clear();
                 return *that();
         }
- if(Traits::emits_neutrons && !Traits::absorbs_neutrons)//JODO
+ if(Traits::is_total && !Traits::absorbs_neutrons)//JODO
         {
                 (*that()) += operand;
                 FORALL(typename ImplMapT, it_, _map)
@@ -1206,7 +1206,7 @@
     while(it != operand.end())
         add(*it++);

- if(Traits::emits_neutrons && !Traits::absorbs_neutrons) //JODO
+ if(Traits::is_total && !Traits::absorbs_neutrons) //JODO
                 FORALL(typename ImplMapT, it_, _map)
                         it_->CONT_VALUE = neutron<codomain_type>::value();

Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -111,7 +111,7 @@
<
     typename DomainT,
     typename CodomainT,
- class Traits = itl::neutron_absorber,
+ class Traits = itl::partial_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_et, CodomainT),
@@ -132,8 +132,8 @@
     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,Compare,Combine,Section,Interval,Alloc>
- neutron_absorber_type;
+ typedef interval_map<DomainT,CodomainT,itl::partial_absorber,Compare,Combine,Section,Interval,Alloc>
+ partial_absorber_type;

     typedef Interval<DomainT,Compare> interval_type;
     typedef typename base_type::iterator iterator;
@@ -404,7 +404,7 @@
         return this->_map.end();

     std::pair<iterator,bool> insertion;
- if(Traits::emits_neutrons)
+ if(Traits::is_total)
     {
         CodomainT added_val = Combiner::neutron();
         Combiner()(added_val, value.CONT_VALUE);
@@ -435,7 +435,7 @@
         return this->_map.end();

     std::pair<iterator,bool> insertion;
- if(Traits::emits_neutrons)
+ if(Traits::is_total)
     {
         CodomainT added_val = Combiner::neutron();
         Combiner()(added_val, value.CONT_VALUE);
@@ -470,7 +470,7 @@
         return;

     std::pair<iterator,bool> insertion;
- if(Traits::emits_neutrons)
+ if(Traits::is_total)
     {
         CodomainT added_val = Combiner::neutron();
         Combiner()(added_val, x_val);
@@ -1035,8 +1035,8 @@
{ enum{value = Traits::absorbs_neutrons}; };

template <class KeyT, class DataT, class Traits>
-struct emits_neutrons<itl::interval_map<KeyT,DataT,Traits> >
-{ enum{value = Traits::emits_neutrons}; };
+struct is_total<itl::interval_map<KeyT,DataT,Traits> >
+{ enum{value = Traits::is_total}; };

template <class KeyT, class DataT, class Traits>
struct type_to_string<itl::interval_map<KeyT,DataT,Traits> >

Modified: sandbox/itl/boost/itl/interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_set.hpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -405,7 +405,7 @@
{ enum{value = false}; };

template <class Type>
-struct emits_neutrons<itl::interval_set<Type> >
+struct is_total<itl::interval_set<Type> >
{ enum{value = false}; };

template <class Type>

Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -47,43 +47,43 @@
namespace boost{namespace itl
{

- struct neutron_absorber
+ struct partial_absorber
     {
         enum { absorbs_neutrons = true };
- enum { emits_neutrons = false };
+ enum { is_total = false };
     };

     template<>
- inline std::string type_to_string<neutron_absorber>::apply() { return "@0"; }
+ inline std::string type_to_string<partial_absorber>::apply() { return "@0"; }

- struct neutron_enricher
+ struct partial_enricher
     {
         enum { absorbs_neutrons = false };
- enum { emits_neutrons = false };
+ enum { is_total = false };

     };

     template<>
- inline std::string type_to_string<neutron_enricher>::apply() { return "e0"; }
+ inline std::string type_to_string<partial_enricher>::apply() { return "e0"; }

- struct neutron_emitter
+ struct total_absorber
     {
         enum { absorbs_neutrons = true };
- enum { emits_neutrons = true };
+ enum { is_total = true };
     };

     template<>
- inline std::string type_to_string<neutron_emitter>::apply() { return "^0"; }
+ inline std::string type_to_string<total_absorber>::apply() { return "^0"; }

- struct neutron_polluter
+ struct total_enricher
     {
         enum { absorbs_neutrons = false };
- enum { emits_neutrons = true };
+ enum { is_total = true };
     };

     template<>
- inline std::string type_to_string<neutron_polluter>::apply() { return "e^0"; }
+ inline std::string type_to_string<total_enricher>::apply() { return "e^0"; }

     /*JODO move this comment to concept InplaceAddable, InplaceSubtractable, InplaceCombinable
@@ -103,7 +103,7 @@
     <
         typename DomainT,
         typename CodomainT,
- class Traits = itl::neutron_absorber,
+ class Traits = itl::partial_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_et, CodomainT),
@@ -120,8 +120,8 @@
                                   allocator_type> base_type;
         typedef typename itl::set<DomainT, Compare, Alloc > set_type;

- typedef itl::map<DomainT,CodomainT,itl::neutron_absorber,Compare,Combine,Section,Alloc>
- neutron_absorber_type;
+ typedef itl::map<DomainT,CodomainT,itl::partial_absorber,Compare,Combine,Section,Alloc>
+ partial_absorber_type;
         typedef Traits traits;

     public:
@@ -193,7 +193,7 @@

     public:
         inline static bool has_symmetric_difference()
- { return is_set<codomain_type>::value || (!is_set<codomain_type>::value && !traits::emits_neutrons); }
+ { return is_set<codomain_type>::value || (!is_set<codomain_type>::value && !traits::is_total); }

     public:
         // --------------------------------------------------------------------
@@ -229,7 +229,7 @@
             subtraced from the data value stored in the map. */
         map& subtract(const value_type& value_pair)
                 {
- if(Traits::emits_neutrons && !is_set<codomain_type>::value)
+ if(Traits::is_total && !is_set<codomain_type>::value)
                                 this->template add<inverse_codomain_combine>(value_pair);
                         else
                                 this->template subtract<inverse_codomain_combine>(value_pair);
@@ -311,7 +311,7 @@
             *this;

         std::pair<iterator, bool> insertion;
- if(Traits::emits_neutrons)
+ if(Traits::is_total)
         {
             CodomainT added_val = Combiner::neutron();
             Combiner()(added_val, val.CONT_VALUE);
@@ -591,7 +591,7 @@
                      const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
     {
                 typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- if(Traits::emits_neutrons && !is_set<typename ObjectT::codomain_type>::value)
+ if(Traits::is_total && !is_set<typename ObjectT::codomain_type>::value)
             const_FORALL(typename ObjectT, it_, operand)
                                 object.template add<ObjectT::inverse_codomain_combine>(*it_);
         else Set::subtract(object, operand);
@@ -633,7 +633,7 @@
     operator &= ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
                      const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
     {
- if(Traits::emits_neutrons) return object += operand;
+ if(Traits::is_total) return object += operand;
                 else{ Map::intersect(object, operand); return object; }
         }

@@ -719,8 +719,8 @@
     { enum{value = Traits::absorbs_neutrons}; };

     template <class DomainT, class CodomainT, class Traits>
- struct emits_neutrons<itl::map<DomainT,CodomainT,Traits> >
- { enum{value = Traits::emits_neutrons}; };
+ struct is_total<itl::map<DomainT,CodomainT,Traits> >
+ { enum{value = Traits::is_total}; };

     template <class DomainT, class CodomainT, class Traits>
     struct type_to_string<itl::map<DomainT,CodomainT,Traits> >

Modified: sandbox/itl/boost/itl/map_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/map_algo.hpp (original)
+++ sandbox/itl/boost/itl/map_algo.hpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -163,7 +163,7 @@
         template<class MapType>
         void flip(MapType& result, const MapType& x2)
         {
- if(emits_neutrons<MapType>::value && absorbs_neutrons<MapType>::value)
+ if(is_total<MapType>::value && absorbs_neutrons<MapType>::value)
                         {
                                 result.clear();
                                 return;
@@ -192,7 +192,7 @@
                                 }
                         }

- if(emits_neutrons<MapType>::value && !absorbs_neutrons<MapType>::value)//JODO
+ if(is_total<MapType>::value && !absorbs_neutrons<MapType>::value)//JODO
                                 FORALL(typename MapType, it_, result)
                                         it_->CONT_VALUE = neutron<typename MapType::codomain_type>::value();
         }

Modified: sandbox/itl/boost/itl/separate_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/separate_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/separate_interval_set.hpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -288,7 +288,7 @@
{ enum{value = false}; };

template <class Type>
-struct emits_neutrons<itl::separate_interval_set<Type> >
+struct is_total<itl::separate_interval_set<Type> >
{ enum{value = false}; };

template <class Type>

Modified: sandbox/itl/boost/itl/set.hpp
==============================================================================
--- sandbox/itl/boost/itl/set.hpp (original)
+++ sandbox/itl/boost/itl/set.hpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -43,7 +43,7 @@
#include <boost/itl/type_traits/is_interval_splitter.hpp>
#include <boost/itl/type_traits/is_interval_separator.hpp>
#include <boost/itl/type_traits/absorbs_neutrons.hpp>
-#include <boost/itl/type_traits/emits_neutrons.hpp>
+#include <boost/itl/type_traits/is_total.hpp>
#include <boost/itl/set_algo.hpp>
#include <boost/itl/predicates.hpp>

@@ -512,7 +512,7 @@
     { enum{value = false}; };

     template <class Type>
- struct emits_neutrons<itl::set<Type> >
+ struct is_total<itl::set<Type> >
     { enum{value = false}; };

     template <class Type>

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 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -128,7 +128,7 @@
     <
         typename DomainT,
         typename CodomainT,
- class Traits = itl::neutron_absorber,
+ class Traits = itl::partial_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_et, CodomainT),
@@ -148,8 +148,8 @@
         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,Compare,Combine,Section,Interval,Alloc>
- neutron_absorber_type;
+ typedef split_interval_map<DomainT,CodomainT,itl::partial_absorber,Compare,Combine,Section,Interval,Alloc>
+ partial_absorber_type;

         typedef Interval<DomainT,Compare> interval_type;
         typedef typename base_type::iterator iterator;
@@ -287,7 +287,7 @@
     if(Traits::absorbs_neutrons && value.CONT_VALUE == Combiner::neutron())
         return;

- if(Traits::emits_neutrons)
+ if(Traits::is_total)
     {
         CodomainT added_val = Combiner::neutron();
         Combiner()(added_val, value.CONT_VALUE);
@@ -318,7 +318,7 @@
         return;

     std::pair<iterator,bool> insertion;
- if(Traits::emits_neutrons)
+ if(Traits::is_total)
     {
         CodomainT added_val = Combiner::neutron();
         Combiner()(added_val, x_val);
@@ -805,8 +805,8 @@
{ enum{value = Traits::absorbs_neutrons}; };

template <class KeyT, class DataT, class Traits>
-struct emits_neutrons<itl::split_interval_map<KeyT,DataT,Traits> >
-{ enum{value = Traits::emits_neutrons}; };
+struct is_total<itl::split_interval_map<KeyT,DataT,Traits> >
+{ enum{value = Traits::is_total}; };

template <class KeyT, class DataT, class Traits>
struct type_to_string<itl::split_interval_map<KeyT,DataT,Traits> >

Modified: sandbox/itl/boost/itl/split_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_set.hpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -444,7 +444,7 @@
     { enum{value = false}; };

     template <class Type>
- struct emits_neutrons<itl::split_interval_set<Type> >
+ struct is_total<itl::split_interval_set<Type> >
     { enum{value = false}; };

     template <class Type>

Deleted: sandbox/itl/boost/itl/type_traits/emits_neutrons.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/emits_neutrons.hpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
+++ (empty file)
@@ -1,21 +0,0 @@
-/*----------------------------------------------------------------------------+
-Copyright (c) 2008-2008: Joachim Faulhaber
-+-----------------------------------------------------------------------------+
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENCE.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt)
-+----------------------------------------------------------------------------*/
-#ifndef __itl_type_traits_emits_neutrons_JOFA_081004_H__
-#define __itl_type_traits_emits_neutrons_JOFA_081004_H__
-
-namespace boost{ namespace itl
-{
- template <class Type> struct emits_neutrons;
-
- template <class Type> struct emits_neutrons{ enum {value = false}; };
-
-}} // namespace boost itl
-
-#endif
-
-

Added: sandbox/itl/boost/itl/type_traits/is_total.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl/type_traits/is_total.hpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -0,0 +1,21 @@
+/*----------------------------------------------------------------------------+
+Copyright (c) 2008-2008: Joachim Faulhaber
++-----------------------------------------------------------------------------+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENCE.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
++----------------------------------------------------------------------------*/
+#ifndef __itl_type_traits_is_total_JOFA_081004_H__
+#define __itl_type_traits_is_total_JOFA_081004_H__
+
+namespace boost{ namespace itl
+{
+ template <class Type> struct is_total;
+
+ template <class Type> struct is_total{ enum {value = false}; };
+
+}} // namespace boost itl
+
+#endif
+
+

Modified: sandbox/itl/boost/itl_xt/tuple_computer.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/tuple_computer.hpp (original)
+++ sandbox/itl/boost/itl_xt/tuple_computer.hpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -102,7 +102,7 @@
         typedef var_tuple<VarCount> var_tuple_type;
         typedef var_tuple_order<var_tuple_type> tuple_order_type;
         /// Container type for the implementation
- typedef itl::map<var_tuple_type, CounterT, neutron_absorber, var_tuple_order> ImplMapTD;
+ typedef itl::map<var_tuple_type, CounterT, partial_absorber, var_tuple_order> ImplMapTD;
         /// iterator
         typedef typename ImplMapTD::iterator iterator;
         /// const_iterator

Modified: sandbox/itl/boost/validate/itl_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/itl_validater.hpp (original)
+++ sandbox/itl/boost/validate/itl_validater.hpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -39,7 +39,7 @@

     namespace NeutronHandlerType
     {
- enum NeutronHandlerTypes { absorber, enricher, emitter, polluter, NeutronHandlerTypes_size };
+ enum NeutronHandlerTypes { partial_absorber, partial_enricher, total_absorber, total_enricher, NeutronHandlerTypes_size };
     }


@@ -157,10 +157,10 @@
         void setNeutronHandlerTypeNames()
         {
             std::vector<std::string> type_names(NeutronHandlerType::NeutronHandlerTypes_size);
- type_names[NeutronHandlerType::absorber] = "absorber";
- type_names[NeutronHandlerType::enricher] = "enricher";
- type_names[NeutronHandlerType::emitter] = "emitter";
- type_names[NeutronHandlerType::polluter] = "polluter";
+ type_names[NeutronHandlerType::partial_absorber] = "partial_absorber";
+ type_names[NeutronHandlerType::partial_enricher] = "partial_enricher";
+ type_names[NeutronHandlerType::total_absorber] = "total_absorber";
+ type_names[NeutronHandlerType::total_enricher] = "total_enricher";
             _neutronizerChoice.setTypeNames(type_names);
         }

Modified: sandbox/itl/boost/validate/itv_map_groupig_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/itv_map_groupig_validater.hpp (original)
+++ sandbox/itl/boost/validate/itv_map_groupig_validater.hpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -57,10 +57,10 @@

             _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
             _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::absorber] = 25;
- _neutronizerChoice[NeutronHandlerType::enricher] = 25;
- _neutronizerChoice[NeutronHandlerType::emitter] = 25;
- _neutronizerChoice[NeutronHandlerType::polluter] = 25;
+ _neutronizerChoice[NeutronHandlerType::partial_absorber] = 25;
+ _neutronizerChoice[NeutronHandlerType::partial_enricher] = 25;
+ _neutronizerChoice[NeutronHandlerType::total_absorber] = 25;
+ _neutronizerChoice[NeutronHandlerType::total_enricher] = 25;
             setNeutronHandlerTypeNames();
             _neutronizerChoice.init();

@@ -103,30 +103,30 @@
             //-----------------------------------------------------------------
             case RootType::itl_map: {
                 switch(neutronizerChoice) {
- case NeutronHandlerType::absorber: return new InplaceMapValidater<itl::map<int,int> >;
- case NeutronHandlerType::enricher: return new InplaceMapValidater<itl::map<int,int,neutron_enricher > >;
- case NeutronHandlerType::emitter : return new InplaceMapValidater<itl::map<int,int,neutron_emitter > >;
- case NeutronHandlerType::polluter: return new InplaceMapValidater<itl::map<int,int,neutron_polluter > >;
+ case NeutronHandlerType::partial_absorber: return new InplaceMapValidater<itl::map<int,int> >;
+ case NeutronHandlerType::partial_enricher: return new InplaceMapValidater<itl::map<int,int,partial_enricher > >;
+ case NeutronHandlerType::total_absorber : return new InplaceMapValidater<itl::map<int,int,total_absorber > >;
+ case NeutronHandlerType::total_enricher: return new InplaceMapValidater<itl::map<int,int,total_enricher > >;
                 default: return choiceError(ITL_LOCATION("\nRootType::itl_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
                 }//switch neutronizerChoice
             }//case itl_map
             //-----------------------------------------------------------------
             case RootType::interval_map: {
                 switch(neutronizerChoice) {
- case NeutronHandlerType::absorber: return new IntervalMapValidater<interval_map<int,int> >;
- case NeutronHandlerType::enricher: return new IntervalMapValidater<interval_map<int,int,neutron_enricher > >;
- case NeutronHandlerType::emitter : return new IntervalMapValidater<interval_map<int,int,neutron_emitter > >;
- case NeutronHandlerType::polluter: return new IntervalMapValidater<interval_map<int,int,neutron_polluter > >;
+ case NeutronHandlerType::partial_absorber: return new IntervalMapValidater<interval_map<int,int> >;
+ case NeutronHandlerType::partial_enricher: return new IntervalMapValidater<interval_map<int,int,partial_enricher > >;
+ case NeutronHandlerType::total_absorber : return new IntervalMapValidater<interval_map<int,int,total_absorber > >;
+ case NeutronHandlerType::total_enricher: return new IntervalMapValidater<interval_map<int,int,total_enricher > >;
                 default: return choiceError(ITL_LOCATION("\nRootType::interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
                 }//switch neutronizerChoice
             }//case interval_map
             //-----------------------------------------------------------------
             case RootType::split_interval_map: {
                 switch(neutronizerChoice) {
- case NeutronHandlerType::absorber: return new IntervalMapValidater<split_interval_map<int,int> >;
- case NeutronHandlerType::enricher: return new IntervalMapValidater<split_interval_map<int,int,neutron_enricher > >;
- case NeutronHandlerType::emitter : return new IntervalMapValidater<split_interval_map<int,int,neutron_emitter > >;
- case NeutronHandlerType::polluter: return new IntervalMapValidater<split_interval_map<int,int,neutron_polluter > >;
+ case NeutronHandlerType::partial_absorber: return new IntervalMapValidater<split_interval_map<int,int> >;
+ case NeutronHandlerType::partial_enricher: return new IntervalMapValidater<split_interval_map<int,int,partial_enricher > >;
+ case NeutronHandlerType::total_absorber : return new IntervalMapValidater<split_interval_map<int,int,total_absorber > >;
+ case NeutronHandlerType::total_enricher: return new IntervalMapValidater<split_interval_map<int,int,total_enricher > >;
                 default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
                 }//switch neutronizerChoice
             }//case split_interval_map

Modified: sandbox/itl/boost/validate/itv_map_settic_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/itv_map_settic_validater.hpp (original)
+++ sandbox/itl/boost/validate/itv_map_settic_validater.hpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -57,10 +57,10 @@

             _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
             _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::absorber] = 50;
- _neutronizerChoice[NeutronHandlerType::enricher] = 50;
- _neutronizerChoice[NeutronHandlerType::emitter] = 0;
- _neutronizerChoice[NeutronHandlerType::polluter] = 0;
+ _neutronizerChoice[NeutronHandlerType::partial_absorber] = 50;
+ _neutronizerChoice[NeutronHandlerType::partial_enricher] = 50;
+ _neutronizerChoice[NeutronHandlerType::total_absorber] = 0;
+ _neutronizerChoice[NeutronHandlerType::total_enricher] = 0;
             setNeutronHandlerTypeNames();
             _neutronizerChoice.init();

@@ -103,27 +103,27 @@
             //-----------------------------------------------------------------
             case RootType::itl_map: {
                 switch(neutronizerChoice) {
- case NeutronHandlerType::absorber: return new InplaceMapValidater<itl::map<int,itl::set<int> > >;
- case NeutronHandlerType::enricher: return new InplaceMapValidater<itl::map<int,itl::set<int>,neutron_enricher> >;
- //case NeutronHandlerType::emitter : return new InplaceMapValidater<itl::map<int,itl::set<int>,neutron_emitter > >;
+ case NeutronHandlerType::partial_absorber: return new InplaceMapValidater<itl::map<int,itl::set<int> > >;
+ case NeutronHandlerType::partial_enricher: return new InplaceMapValidater<itl::map<int,itl::set<int>,partial_enricher> >;
+ //case NeutronHandlerType::total_absorber : return new InplaceMapValidater<itl::map<int,itl::set<int>,total_absorber > >;
                 default: return choiceError(ITL_LOCATION("\nRootType::itl_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
                 }//switch neutronizerChoice
             }//case itl_map
             //-----------------------------------------------------------------
             case RootType::interval_map: {
                 switch(neutronizerChoice) {
- case NeutronHandlerType::absorber: return new IntervalMapValidater<interval_map<int,itl::set<int> > >;
- case NeutronHandlerType::enricher: return new IntervalMapValidater<interval_map<int,itl::set<int>,neutron_enricher> >;
- //case NeutronHandlerType::emitter : return new IntervalMapValidater<interval_map<int,itl::set<int>,neutron_emitter > >;
+ case NeutronHandlerType::partial_absorber: return new IntervalMapValidater<interval_map<int,itl::set<int> > >;
+ case NeutronHandlerType::partial_enricher: return new IntervalMapValidater<interval_map<int,itl::set<int>,partial_enricher> >;
+ //case NeutronHandlerType::total_absorber : return new IntervalMapValidater<interval_map<int,itl::set<int>,total_absorber > >;
                 default: return choiceError(ITL_LOCATION("\nRootType::interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
                 }//switch neutronizerChoice
             }//case interval_map
             //-----------------------------------------------------------------
             case RootType::split_interval_map: {
                 switch(neutronizerChoice) {
- case NeutronHandlerType::absorber: return new IntervalMapValidater<split_interval_map<int,itl::set<int> > >;
- case NeutronHandlerType::enricher: return new IntervalMapValidater<split_interval_map<int,itl::set<int>,neutron_enricher> >;
- //case NeutronHandlerType::emitter : return new IntervalMapValidater<split_interval_map<int,itl::set<int>,neutron_emitter > >;
+ case NeutronHandlerType::partial_absorber: return new IntervalMapValidater<split_interval_map<int,itl::set<int> > >;
+ case NeutronHandlerType::partial_enricher: return new IntervalMapValidater<split_interval_map<int,itl::set<int>,partial_enricher> >;
+ //case NeutronHandlerType::total_absorber : return new IntervalMapValidater<split_interval_map<int,itl::set<int>,total_absorber > >;
                 default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
                 }//switch neutronizerChoice
             }//case split_interval_map

Modified: sandbox/itl/boost/validate/itv_set_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/itv_set_validater.hpp (original)
+++ sandbox/itl/boost/validate/itv_set_validater.hpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -57,10 +57,10 @@

             _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
             _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::absorber] = 100;
- _neutronizerChoice[NeutronHandlerType::enricher] = 0;
- _neutronizerChoice[NeutronHandlerType::emitter] = 0;
- _neutronizerChoice[NeutronHandlerType::polluter] = 0;
+ _neutronizerChoice[NeutronHandlerType::partial_absorber] = 100;
+ _neutronizerChoice[NeutronHandlerType::partial_enricher] = 0;
+ _neutronizerChoice[NeutronHandlerType::total_absorber] = 0;
+ _neutronizerChoice[NeutronHandlerType::total_enricher] = 0;
             setNeutronHandlerTypeNames();
             _neutronizerChoice.init();

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 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -20,8 +20,8 @@
     template <typename Type,
               template<class>class Combiner = inplace_plus,
                       template<class>class Equality = itl::std_equal>
- class InplaceSelfRemovability
- : public Law<InplaceSelfRemovability<Type,Combiner,Equality>,
+ class InplaceNaturalInversion
+ : public Law<InplaceNaturalInversion<Type,Combiner,Equality>,
                      LOKI_TYPELIST_1(Type), LOKI_TYPELIST_2(Type,Type)>
     {
         //a - a == 0
@@ -32,15 +32,15 @@
     public:
                 typedef typename inverse<Combiner<Type> >::type InverseCombinerT;

- std::string name()const { return "InplaceSelfRemovability"; }
+ std::string name()const { return "InplaceNaturalInversion"; }
         std::string formula()const { return "a -= a; a == 0"; }

         std::string typeString()const
         {
- return "SelfRemovability<"+type_to_string<Type>::apply()+","
+ return "NaturalInversion<"+type_to_string<Type>::apply()+","
                                       +unary_template_to_string<Combiner>::apply()+","
                                       +unary_template_to_string<Equality>::apply()
- +">";
+ +">";
         }

     public:
@@ -70,8 +70,8 @@
     template <typename Type,
               template<class>class Combiner = inplace_plus,
                       template<class>class Equality = itl::std_equal>
- class InplaceInverseRemovability
- : public Law<InplaceInverseRemovability<Type,Combiner,Equality>,
+ class InplaceInverseExistence
+ : public Law<InplaceInverseExistence<Type,Combiner,Equality>,
                      LOKI_TYPELIST_1(Type), LOKI_TYPELIST_2(Type,Type)>
     {
         //(0 - a) + a == 0
@@ -82,12 +82,12 @@
     public:
                 typedef typename inverse<Combiner<Type> >::type InverseCombinerT;

- std::string name()const { return "InplaceInverseRemovability"; }
+ std::string name()const { return "InplaceInverseExistence"; }
         std::string formula()const { return "(0-a) + a == 0"; }

         std::string typeString()const
         {
- return "InverseRemovability<"+type_to_string<Type>::apply()+","
+ return "InverseExistence<"+type_to_string<Type>::apply()+","
                                       +unary_template_to_string<Combiner>::apply()+","
                                       +unary_template_to_string<Equality>::apply()
                                                                           +">";

Modified: sandbox/itl/boost/validate/realmvalidater.h
==============================================================================
--- sandbox/itl/boost/validate/realmvalidater.h (original)
+++ sandbox/itl/boost/validate/realmvalidater.h 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -56,10 +56,10 @@

             _neutronizerChoice.setSize(NeutronHandlerType::NeutronHandlerTypes_size);
             _neutronizerChoice.setMaxWeights(100);
- _neutronizerChoice[NeutronHandlerType::absorber] = 50;
- _neutronizerChoice[NeutronHandlerType::enricher] = 50;
- _neutronizerChoice[NeutronHandlerType::emitter] = 0;
- _neutronizerChoice[NeutronHandlerType::polluter] = 0;
+ _neutronizerChoice[NeutronHandlerType::partial_absorber] = 50;
+ _neutronizerChoice[NeutronHandlerType::partial_enricher] = 50;
+ _neutronizerChoice[NeutronHandlerType::total_absorber] = 0;
+ _neutronizerChoice[NeutronHandlerType::total_enricher] = 0;
             setNeutronHandlerTypeNames();
             _neutronizerChoice.init();

@@ -166,8 +166,8 @@

                 case DomainType::Double:
                     switch(codomainChoice) {
- case CodomainType::Int: return new InplaceMapValidater<itl::map<double,int,neutron_enricher> >;
- case CodomainType::set_int: return new InplaceSetValidater<itl::map<double,itl::set<int>,neutron_enricher > >;
+ case CodomainType::Int: return new InplaceMapValidater<itl::map<double,int,partial_enricher> >;
+ case CodomainType::set_int: return new InplaceSetValidater<itl::map<double,itl::set<int>,partial_enricher > >;
                     default: return choiceError(ITL_LOCATION("\nRootType::itl_map: codomainChoice:\n"),
                                                 codomainChoice, _codomainChoice);
                     }//switch codomain
@@ -181,15 +181,15 @@
                 switch(domainChoice) {
                 case DomainType::Int:
                     switch(codomainChoice) {
- case CodomainType::Int: return new IntervalMapValidater<interval_map<int,int,neutron_emitter> >;
+ case CodomainType::Int: return new IntervalMapValidater<interval_map<int,int,total_absorber> >;
                     case CodomainType::set_int: return new IntervalMapValidater<interval_map<int,itl::set<int> > >;
                     default: return choiceError(ITL_LOCATION("\nRootType::interval_map: codomainChoice:\n"),
                                                 codomainChoice, _codomainChoice);
                     }// switch codomain
                 case DomainType::Double:
                     switch(codomainChoice) {
- case CodomainType::Int: return new IntervalMapValidater<interval_map<double,int,neutron_polluter> >;
- case CodomainType::set_int: return new IntervalMapValidater<interval_map<double,itl::set<int>,neutron_enricher > >;
+ case CodomainType::Int: return new IntervalMapValidater<interval_map<double,int,total_enricher> >;
+ case CodomainType::set_int: return new IntervalMapValidater<interval_map<double,itl::set<int>,partial_enricher > >;
                     default: return choiceError(ITL_LOCATION("\nRootType::interval_map: codomainChoice:\n"),
                                                 codomainChoice, _codomainChoice);
                     }// switch codomain
@@ -202,14 +202,14 @@
                 switch(domainChoice) {
                 case DomainType::Int:
                     switch(codomainChoice) {
- case CodomainType::Int: return new IntervalMapValidater<split_interval_map<int,int,neutron_enricher> >;
- case CodomainType::set_int: return new IntervalMapValidater<split_interval_map<int,itl::set<int>,neutron_enricher> >;
+ case CodomainType::Int: return new IntervalMapValidater<split_interval_map<int,int,partial_enricher> >;
+ case CodomainType::set_int: return new IntervalMapValidater<split_interval_map<int,itl::set<int>,partial_enricher> >;
                     default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: codomainChoice:\n"),
                                                 codomainChoice, _codomainChoice);
                     }
                 case DomainType::Double:
                     switch(codomainChoice) {
- case CodomainType::Int: return new IntervalMapValidater<split_interval_map<double,int,neutron_emitter> >;
+ case CodomainType::Int: return new IntervalMapValidater<split_interval_map<double,int,total_absorber> >;
                     case CodomainType::set_int: return new IntervalSetValidater<split_interval_map<double,itl::set<int> > >;
                     default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: codomainChoice:\n"),
                                                 codomainChoice, _codomainChoice);

Modified: sandbox/itl/boost/validate/typevalidater.h
==============================================================================
--- sandbox/itl/boost/validate/typevalidater.h (original)
+++ sandbox/itl/boost/validate/typevalidater.h 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -263,7 +263,7 @@
             //JODO _lawChoice[inplaceStarDistributivity] = 100; // only (map|cop)<set> NOT (map|cop)<group>
             //JODO _lawChoice[inplacePlusDeMorgan] = 100; // only (map|cop)<set> NOT (map|cop)<group>
             //JODO _lawChoice[inplaceStarDeMorgan] = 100; // only (map|cop)<set> NOT (map|cop)<group>
- //JODO _lawChoice[inplaceSelfRemovability] = 25; // only cop NOT map
+ //JODO _lawChoice[inplaceNaturalInversion] = 25; // only cop NOT map
             _lawChoice.init();
         }

@@ -326,7 +326,7 @@
             inplaceSetBaseLaws,
             inplaceSymmetricDifference,
             inplaceFlip,
- inplaceSelfRemovability,
+ inplaceNaturalInversion,
             inplacePlusDistributivity,
             inplaceStarDistributivity,
             inplacePlusDashRightDistrib,
@@ -348,7 +348,7 @@
             _lawChoice[inplaceSetBaseLaws] = base_weight;
             _lawChoice[inplaceSymmetricDifference] = weight;
             _lawChoice[inplaceFlip] = weight;
- _lawChoice[inplaceSelfRemovability] = weight;
+ _lawChoice[inplaceNaturalInversion] = weight;
             _lawChoice[inplacePlusDistributivity] = weight;
             _lawChoice[inplaceStarDistributivity] = weight;
             _lawChoice[inplacePlusDashRightDistrib] = weight;
@@ -376,15 +376,15 @@
             case inplaceSymmetricDifference: return new LawValidater<InplaceSymmetricDifference<Type>, RandomGentor>;
             case inplaceFlip: return new LawValidater<InplaceFlip<Type>, RandomGentor>;

- case inplaceSelfRemovability:
+ case inplaceNaturalInversion:
                                 if( itl::is_map<Type>::value && itl::is_set<typename Type::codomain_type>::value
- && !absorbs_neutrons<Type>::value && !emits_neutrons<Type>::value)
+ && !absorbs_neutrons<Type>::value && !is_total<Type>::value)
                                         return new
                                                 mpl::if_<mpl::bool_<is_map<Type>::value>,
- LawValidater<InplaceSelfRemovability<Type, inplace_plus, protonic_equal>, RandomGentor>,
- LawValidater<InplaceSelfRemovability<Type, inplace_plus, std_equal>, RandomGentor> >::type;
+ LawValidater<InplaceNaturalInversion<Type, inplace_plus, protonic_equal>, RandomGentor>,
+ LawValidater<InplaceNaturalInversion<Type, inplace_plus, std_equal>, RandomGentor> >::type;
                                 else
- return new LawValidater<InplaceSelfRemovability<Type, inplace_plus, std_equal>, RandomGentor>;
+ return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, std_equal>, RandomGentor>;

             case inplacePlusDistributivity:
                 if( itl::is_interval_container<Type>::value && itl::is_interval_splitter<Type>::value)
@@ -394,14 +394,14 @@

             case inplaceStarDistributivity:
                 if( itl::is_interval_container<Type>::value && itl::is_interval_splitter<Type>::value
- && absorbs_neutrons<Type>::value && !emits_neutrons<Type>::value)
+ && absorbs_neutrons<Type>::value && !is_total<Type>::value)
                                         return new LawValidater<InplaceDistributivity<Type, inplace_et, inplace_plus, element_equal>, RandomGentor>;
                                 else
                                         return new LawValidater<InplaceDistributivity<Type, inplace_et, inplace_plus, std_equal>, RandomGentor>;

             case inplacePlusDashRightDistrib:
                 if( itl::is_interval_container<Type>::value && itl::is_interval_splitter<Type>::value
- && absorbs_neutrons<Type>::value && !emits_neutrons<Type>::value)
+ && absorbs_neutrons<Type>::value && !is_total<Type>::value)
                                         return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, element_equal>, RandomGentor>;
                                 else
                                         return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, std_equal>, RandomGentor>;
@@ -431,7 +431,7 @@
             case inplaceSetBaseLaws: return InplaceSetBaseValidater<Type>::chooseValidater();
             case inplaceSymmetricDifference: return new LawValidater<InplaceSymmetricDifference<Type>, RandomGentor>;
             case inplaceFlip: return new LawValidater<InplaceFlip<Type>, RandomGentor>;
- case inplaceSelfRemovability: return new LawValidater<InplaceSelfRemovability<Type, inplace_plus, std_equal>, RandomGentor>;
+ case inplaceNaturalInversion: return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, std_equal>, RandomGentor>;

             case inplacePlusDistributivity:
                 if( itl::is_interval_container<Type>::value && itl::is_interval_splitter<Type>::value)
@@ -525,8 +525,8 @@
             inplaceSetBaseLaws,
             inplaceSymmetricDifference,
             inplaceFlip,
- inplaceSelfRemovability,
- inplaceInverseRemovability,
+ inplaceNaturalInversion,
+ inplaceInverseExistence,
             sectionAbsorbtion,
             Laws_size
         };
@@ -543,28 +543,28 @@
                 _lawChoice[inplaceSetBaseLaws] = 95;
                 _lawChoice[inplaceSymmetricDifference] = 0; // Is validated in base class
                 _lawChoice[inplaceFlip] = 0; // Is validated in base class
- _lawChoice[inplaceSelfRemovability] = 0; // Is validated in base class
- _lawChoice[inplaceInverseRemovability] = 0; // Is not valid for sets
+ _lawChoice[inplaceNaturalInversion] = 0; // Is validated in base class
+ _lawChoice[inplaceInverseExistence] = 0; // Is not valid for sets
                 _lawChoice[sectionAbsorbtion] = 5;
                         }
- else if(!emits_neutrons<Type>::value)
+ else if(!is_total<Type>::value)
             {
                                 //JODO A map of group values that does not emit neutrons always has a symmetric difference
                                 BOOST_ASSERT(Type::has_symmetric_difference());
                 _lawChoice[inplaceSetBaseLaws] = 80;
                 _lawChoice[inplaceSymmetricDifference] = 5;
                 _lawChoice[inplaceFlip] = 5;
- _lawChoice[inplaceSelfRemovability] = 5;
- _lawChoice[inplaceInverseRemovability] = 0;
+ _lawChoice[inplaceNaturalInversion] = 5;
+ _lawChoice[inplaceInverseExistence] = 0;
                 _lawChoice[sectionAbsorbtion] = 5;
             }
- else // !is_set && emits_neutrons //JODO && is_abelian_group<Type::value>
+ else // !is_set && is_total //JODO && is_abelian_group<Type::value>
             {
                 _lawChoice[inplaceSetBaseLaws] = 80;
                 _lawChoice[inplaceSymmetricDifference] = 4;
                 _lawChoice[inplaceFlip] = 4;
- _lawChoice[inplaceSelfRemovability] = 4;
- _lawChoice[inplaceInverseRemovability] = 4;
+ _lawChoice[inplaceNaturalInversion] = 4;
+ _lawChoice[inplaceInverseExistence] = 4;
                 _lawChoice[sectionAbsorbtion] = 4;
             }
             _lawChoice.init();
@@ -582,17 +582,17 @@
             case inplaceFlip:
                 return new LawValidater<InplaceFlip<Type>, RandomGentor>;

- case inplaceSelfRemovability:
+ case inplaceNaturalInversion:
                                 if(is_map<Type>::value && !absorbs_neutrons<Type>::value)
- return new LawValidater<InplaceSelfRemovability<Type, inplace_plus, protonic_equal>, RandomGentor >;
+ return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, protonic_equal>, RandomGentor >;
                                 else
- return new LawValidater<InplaceSelfRemovability<Type, inplace_plus, std_equal>, RandomGentor >;
+ return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, std_equal>, RandomGentor >;

- case inplaceInverseRemovability:
+ case inplaceInverseExistence:
                                 if(is_map<Type>::value && !absorbs_neutrons<Type>::value)
- return new LawValidater<InplaceInverseRemovability<Type, inplace_plus, protonic_equal>, RandomGentor >;
+ return new LawValidater<InplaceInverseExistence<Type, inplace_plus, protonic_equal>, RandomGentor >;
                                 else
- return new LawValidater<InplaceInverseRemovability<Type, inplace_plus, std_equal>, RandomGentor >;
+ return new LawValidater<InplaceInverseExistence<Type, inplace_plus, std_equal>, RandomGentor >;

             case sectionAbsorbtion:
                                 if(is_map<Type>::value && !absorbs_neutrons<Type>::value)
@@ -705,8 +705,8 @@
             case cluster_erase: return new LawValidater<BinaryPushout<typename Type::atomized_type, Type, Interval::Cluster, eraser>, RandomGentor>();
             case join_plus: return new LawValidater<BinaryPushout<Type, typename Type::joint_type, Interval::Join, inplace_plus>, RandomGentor>();
             //JODO absorb_plus holds for interval_map. For split_interval_map element_equal has to be used as equality-relation.
- //case absorb_plus: return new LawValidater<BinaryPushout<Type, typename Type::neutron_absorber_type, Interval::AbsorbNeutrons, inplace_plus>, RandomGentor>();
- //JODO doc: violated: inverse required: case absorb_minus: return new LawValidater<BinaryPushout<Type, typename Type::neutron_absorber_type, Interval::AbsorbNeutrons, inplace_minus>, RandomGentor>();
+ //case absorb_plus: return new LawValidater<BinaryPushout<Type, typename Type::partial_absorber_type, Interval::AbsorbNeutrons, inplace_plus>, RandomGentor>();
+ //JODO doc: violated: inverse required: case absorb_minus: return new LawValidater<BinaryPushout<Type, typename Type::partial_absorber_type, Interval::AbsorbNeutrons, inplace_minus>, RandomGentor>();
             default: return NULL;
             }
         }

Modified: sandbox/itl/libs/itl/doc/concepts.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/concepts.qbk (original)
+++ sandbox/itl/libs/itl/doc/concepts.qbk 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -205,7 +205,7 @@
But you could instantiate an __itv_map__ to have
`insert/erase` semantics this way:
``
-interval_map<int,int,neutron_absorber,
+interval_map<int,int,partial_absorber,
              std::less,
              inplace_identity //Combine parameter specified
> m;
@@ -228,7 +228,7 @@
section became ['kind of nuclear] at least in wording.
But rest assured `itl::Maps` won't contaminate your software.

-[h4 Remarks on Neutral Elements or Neutrons]
+[h4 Remarks on Neutral Elements]

In the itl we call ['*neutral elements*] `neutrons` and all values
that [*are not] `neutrons` we call `protons`.
@@ -250,8 +250,9 @@
                 In addition, associated neutrons that emerge from aggregations are stored.]]
]

-Note, that a neutron is defined in relation to a combiner operation. In many cases
-this relation is provided by the default parameters of itl `Maps`.
+Note, that a neutron is defined in relation to a combiner operation.
+[/ In most cases
+this relation is provided by the default parameters of itl `Maps`.]

[table
[[type] [operation] [neutron]]
@@ -260,16 +261,20 @@
[[`set<T>`] [union] [`{}`] ]
]

-In those cases the `neutron` value is delivered by the default constructor
-of a type. But there are well known exceptions like e.g. numeric multiplication:
+In these cases the `neutron` value is delivered by the default constructor
+of the maps `CodomainT` type. But there are well known exceptions
+like e.g. numeric multiplication:

[table
[[type] [operation] [neutron]]
[[`int`] [multiplication] [`1`] ]
]

-Therefore an itl functor implements a static function `neutron()` to make
-shure that the correct `neutron()` is used, which is used in the implementation
+Therefore itl functors,
+that serve as `Combiner` parameters of itl Maps
+implement a static function `neutron()` to make
+shure that the correct `neutron()` is used
+in the implementation
of ['aggregate on overlap].
``
inplace_times<int>::neutron() == 1
@@ -299,7 +304,7 @@
infinite vector.

The second trait is related to the representation of `neutrons` in
-the map. A itl map can be a neutron_absorber or a neutron_enricher.
+the map. An itl map can be a neutron absorber or a neutron enricher.

* A neutron absorber never stores value pairs `(k,0)` that carry neutrons.
* A neutron enricher stores value pairs `(k,0)`.
@@ -314,7 +319,7 @@
]

-[h4 Trait Neutron Absorber]
+[h4 Partial Neutron Absorber]

From a pragmatic perspective value pairs that carry `neutrons` as
mapped values can often be deleted. If we count, for instance,
@@ -326,20 +331,27 @@

A Map that does never insert
associated neutrons or deletes them when they emerge, is called
-__absorber__. To be a partial __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.
+neutron absorber. A partial neutron absorber (short __absorber__)
+is the default setting
+for the Trait parameter. A __absorber__ is able
+to erase a pair `(k,v)` from a map `{(k,v)}` by calling
+`subtract((k,v))` or `operator - ` .
+
+``{(k,v)} - (k,v) == {}``
+
+
+[h4 Partial Neutron Enricher]
+
+With a neutron enricher,
+on the contrary, subtraction of a
+pair `(k,v)` that is in the map results in a pair `(k,0)`.
+
+``{(k,v)} - (k,v) == {(k,0)}``
+
+Mapping pairs that carry
+`neutrons` may emerge as a result of additions or aggregations
+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`
@@ -349,8 +361,8 @@
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
+(k,v) does not exist in the map: Pair (k,v) has NOT been dealt with
+(k,0) key k carries 0 : Pair (k,v) has been dealt with resulting in y=0
]

Sometimes this subtle distiction is needed. Then a __enricher__
@@ -358,11 +370,13 @@
a common set of keys in order to, say, iterate synchronously
over both maps, we need __enrichers__.

-[h4 Neutron Emitter]
+[h4 Total Neutron Absorber]

-The third neutronic Trait is called __emitter__.
+The third neutronic Trait is a total map that does not
+store value pairs with associated neutrons `(k,0)`.
+It is called total neutron absorber (short __emitter__).
A map that is a __emitter__ is defined on every value
-of it's domain. It emits a
+of it's domain. It provides a
neutron value for every key value, that has not been set or
aggregated to a value unequal to the `neutron` value.

@@ -382,7 +396,7 @@
and carry `neutron` values are actually stored. All value pairs,
that are not represented carry `neutrons` via default but are not stored.

-['Neutronic traits] can be summarized as follows
+The traits for itl Maps can be summarized as follows

[table
[[] [] [absorbs neutrons] []]

Modified: sandbox/itl/libs/itl/doc/itl.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/itl.qbk (original)
+++ sandbox/itl/libs/itl/doc/itl.qbk 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -82,11 +82,11 @@
[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 __enrichers__ [classref boost::itl::neutron_enricher neutron_enrichers]]
-[def __emitter__ [classref boost::itl::neutron_emitter neutron_emitter]]
-[def __polluter__ [classref boost::itl::neutron_emitter neutron_polluter]]
+[def __absorber__ [classref boost::itl::partial_absorber partial_absorber]]
+[def __enricher__ [classref boost::itl::partial_enricher partial_enricher]]
+[def __enrichers__ [classref boost::itl::partial_enricher partial_enrichers]]
+[def __emitter__ [classref boost::itl::total_absorber total_absorber]]
+[def __polluter__ [classref boost::itl::total_absorber total_enricher]]

[def __itv_bse_set__ [classref boost::itl::interval_base_set interval_base_set]]
[def __e [link element_type *e*]]

Modified: sandbox/itl/libs/itl/doc/semantics.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/semantics.qbk (original)
+++ sandbox/itl/libs/itl/doc/semantics.qbk 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -9,7 +9,7 @@
[section Semantics]

In the *itl* we follow the notion, that the semantics of a ['*concept*] or an
-['*abstract data type*] can be expressed by ['*laws*]. In the *itl* we formulate
+['*abstract data type*] can be expressed by ['*laws*]. We formulate
laws over interval containers that can be evaluated for a given
instantiation of the variables contained in the law. The following
pseudocode gives a shorthand notation of such a law.
@@ -53,7 +53,7 @@

`Operator <` depends on the itl::container's template parameter
`Compare` that implements a ['strict weak ordering] for the container's
-`key_type`.
+`domain_type`.
For a given `Compare` ordering, `operator <` implements a
lexicographical comparison on itl::containers, that uses the
`Compare` order to establish a unique sequence of values in
@@ -99,18 +99,18 @@
is_element_equal(w1,w2); //true: Same elements contained
``

-So for a constant `Compare` order on key elements,
-memberfuntion `contained_in` that is defined for all
+For a constant `Compare` order on key elements,
+memberfunktion `contained_in` that is defined for all
itl::containers implements a
[@http://en.wikipedia.org/wiki/Partially_ordered_set partial order]
on itl::containers.

``
with <= for contained_in,
- = for is_element_equal:
-Reflexivity<T,<= > : T a; a<=a
-Antisymmetry<T,<=,=> : T a,b; a<=b && b<=a implies a=b
-Transitivity<T,<= > : T a,b,c; a<=b && b<=c implies a<c
+ =e= for is_element_equal:
+Reflexivity<T,<= > : T a; a <= a
+Antisymmetry<T,<=,=e=> : T a,b; a <= b && b <= a implies a =e= b
+Transitivity<T,<= > : T a,b,c; a <= b && b <= c implies a <= c
``

The induced equivalence is the equality of elements that
@@ -171,7 +171,7 @@

``
RightNeutrality<S,-,== > : S a; a-S() == a
-SelfRemovability<S,-,== >: S a; a - a == S()
+Inversion<S,-,== >: S a; a - a == S()
``

Summarized in the next table are laws that use `+`, `&` and `-`
@@ -181,11 +181,11 @@
of the table.

``
- + * -
+ + & -
Associativity == ==
-Neutrality == ==
+Neutrality == == ==
Commutativity == ==
-SelfRemovability ==
+Inversion ==
``

[h5 Distributivity Laws]
@@ -200,10 +200,10 @@
Therefore they are denoted using a /variable/ equality `=v=` below.

``
- Distributivity<S,+,&,=v= > : S a,b,c; a + (b & c) =v= (a + b) * (a + c)
- Distributivity<S,&,+,=v= > : S a,b,c; a * (b + c) =v= (a * b) + (a * c)
+ Distributivity<S,+,&,=v= > : S a,b,c; a + (b & c) =v= (a + b) & (a + c)
+ Distributivity<S,&,+,=v= > : S a,b,c; a & (b + c) =v= (a & b) + (a & c)
RightDistributivity<S,+,-,=v= > : S a,b,c; (a + b) - c =v= (a - c) + (b - c)
-RightDistributivity<S,&,-,=v= > : S a,b,c; (a * b) - c =v= (a - c) * (b - c)
+RightDistributivity<S,&,-,=v= > : S a,b,c; (a & b) - c =v= (a - c) & (b - c)
``

The next table shows the relationship between
@@ -407,11 +407,11 @@
   accounts for value pairs that that carry values unequal to the `neutron` value.

Solution (1) led to the introduction of map traits, particularly trait
-neutron_absorber trait which is the default setting in all itl's map
+partial_absorber trait which is the default setting in all itl's map
templates.

Solution (2), is applied to check the semantics of itl::Maps for the
-neutron_enricher trait that does not delete value pairs that carry
+partial_enricher trait that does not delete value pairs that carry
neutrons. Protonic equality is implemented by a non member function
called `is_protonic_equal`. Througout this chapter
protonic equality in pseudocode and law denotations is denoted
@@ -435,43 +435,43 @@
Associativity<C,*,== >: C a,b,c; a&(b&c) ==(a&b)&c
Commutativity<C,*,== >: C a,b; a&b == b&a

-RightNeutrality<C,-,== > : C a; a-C() == a
-SelfRemovability<C,-,=v= >: C a; a - a =v= C()
+RightNeutrality<C,-,== >: C a; a-C() == a
+Inversion<C,-,=v= > : C a; a - a =v= C()
``

All the fundamental laws could be validated for all
itl Maps in their instantiation as Maps of Sets or Collectors.
-As expected SelfRmovability only holds for protonic equality,
-if the map is not a `neutron_absorber`.
+As expected Inversion only holds for protonic equality,
+if the map is not a `partial_absorber`.

``
- + & -
-Associativity == ==
-Neutrality == ==
-Commutativity == ==
-SelfRemovability neutron_absorber ==
- neutron_enricher =p=
+ + & -
+Associativity == ==
+Neutrality == == ==
+Commutativity == ==
+Inversion partial_absorber ==
+ partial_enricher =p=
``

[h5 Distributivity Laws]

``
- Distributivity<C,+,&,=v= > : C a,b,c; a + (b & c) =v= (a + b) * (a + c)
- Distributivity<C,&,+,=v= > : C a,b,c; a * (b + c) =v= (a * b) + (a * c)
+ Distributivity<C,+,&,=v= > : C a,b,c; a + (b & c) =v= (a + b) & (a + c)
+ Distributivity<C,&,+,=v= > : C a,b,c; a & (b + c) =v= (a & b) + (a & c)
RightDistributivity<C,+,-,=v= > : C a,b,c; (a + b) - c =v= (a - c) + (b - c)
-RightDistributivity<C,&,-,=v= > : C a,b,c; (a * b) - c =v= (a - c) * (b - c)
+RightDistributivity<C,&,-,=v= > : C a,b,c; (a & b) - c =v= (a - c) & (b - c)
``

Results for the distributivity laws are almost identical to
the validation of sets except that
-for a `neutron_enricher map` the law `(a * b) - c == (a - c) * (b - c)`
+for a `partial_enricher map` the law `(a & b) - c == (a - c) & (b - c)`
holds for lexicographical equality.

``
                                                    +,& &,+
      Distributivity joining == ==
- splitting neutron_absorber =e= =e=
- neutron_enricher =e= ==
+ splitting partial_absorber =e= =e=
+ partial_enricher =e= ==

                                                    +,- &,-
RightDistributivity joining == ==
@@ -481,7 +481,7 @@
[h5 DeMorgan's Law and Symmetric Difference]

``
-DeMorgan<C,+,&,=v= > : C a,b,c; a - (b + c) =v= (a - b) * (a - c)
+DeMorgan<C,+,&,=v= > : C a,b,c; a - (b + c) =v= (a - b) & (a - c)
DeMorgan<C,&,+,=v= > : C a,b,c; a - (b & c) =v= (a - b) + (a - c)
``

@@ -565,8 +565,8 @@

[table
[[Trait] [CodomainT as number] [CodomainT more abstract] [Concept for Quanifier Map]]
-[[emits_neutrons] [signed number] [commutative group] [InfiniteVector]]
-[[!emits_neutrons] [unsigned number] [commutative monoid] [hybrid type]]
+[[is_total] [signed number] [commutative group] [InfiniteVector]]
+[[!is_total] [unsigned number] [commutative monoid] [hybrid type]]
]

[h5 Intersection on Quantifiers]
@@ -631,26 +631,26 @@
Commutativity<Q,*,== >: Q a,b; a&b == b&a

RightNeutrality<Q,-,== > : Q a; a-Q() == a
-SelfRemovability<Q,-,=v= >: Q a; a - a =v= Q()
+Inversion<Q,-,=v= >: Q a; a - a =v= Q()
``

For a `Quantifier` the same basic laws apply that are
valid for `Collectors`:

``
- + & -
-Associativity == ==
-Neutrality == ==
-Commutativity == ==
-SelfRemovability absorbs_neutrons ==
- enriches_neutrons =p=
+ + & -
+Associativity == ==
+Neutrality == ==
+Commutativity == ==
+Inversion absorbs_neutrons ==
+ enriches_neutrons =p=
``

In addition also symmetrical difference is valid for
-`Qunatifiers` and the
+`Quantifiers` and the
modified `operator &`.
``
-SymmetricDifference<Q,== > : Q a,b,c; (a + b) - (a * b) == (a - b) + (b - a)
+SymmetricDifference<Q,== > : Q a,b,c; (a + b) - (a & b) == (a - b) + (b - a)
``
For a `TotalQuantifier` `Qt` symmetrical difference degenerates to
a trivial form since `operator &` and `operator +` become identical
@@ -703,7 +703,7 @@
[[`Map<D,Monoid>`] [`Modoid`] [] [`interval_map<int,string>`]]
[[`Map<D,Set,Trait>`] [`Set`] [`Trait::absorbs_neutrons`][`interval_map<int,itl::set<int> >`]]
[[`Map<D,CommutativeMonoid>`][`CommutativeMonoid`][] [`interval_map<int,unsigned int>`]]
-[[`Map<D,CommutativeGroup>`] [`CommutativeGroup`] [`Trait::emits_neutrons`] [`interval_map<int,int,neutron_emitter>`]]
+[[`Map<D,CommutativeGroup>`] [`CommutativeGroup`] [`Trait::is_total`] [`interval_map<int,int,total_absorber>`]]
]

[endsect][/ Concept Induction]

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 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -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, less, inplace_max > BoostPartyHeightHistoryT;
+typedef interval_map<ptime, int, partial_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 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -9,7 +9,7 @@
#define __test_itl_interval_map_shared_h_JOFA_081005__

template <template<class T, class U,
- class Traits = neutron_absorber,
+ class Traits = partial_absorber,
                    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_et, U),
@@ -158,7 +158,7 @@
}

template <template<class T, class U,
- class Traits = neutron_absorber,
+ class Traits = partial_absorber,
                    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_et, U),
@@ -221,7 +221,7 @@

template <template<class T, class U,
- class Traits = neutron_absorber,
+ class Traits = partial_absorber,
                    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_et, U),
@@ -276,7 +276,7 @@
}

template <template<class T, class U,
- class Traits = neutron_absorber,
+ class Traits = partial_absorber,
                    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_et, U),
@@ -309,7 +309,7 @@
}

template <template<class T, class U,
- class Traits = neutron_absorber,
+ class Traits = partial_absorber,
                    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_et, U),
@@ -360,7 +360,7 @@
}

template <template<class T, class U,
- class Traits = neutron_absorber,
+ class Traits = partial_absorber,
                    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_et, U),
@@ -413,7 +413,7 @@

template <template<class T, class U,
- class Traits = neutron_absorber,
+ class Traits = partial_absorber,
                    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_et, U),
@@ -457,7 +457,7 @@
}

template <template<class T, class U,
- class Traits = neutron_absorber,
+ class Traits = partial_absorber,
                    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_et, U),
@@ -498,7 +498,7 @@

// Test for nontrivial intersection of interval maps with intervals and values
template <template<class T, class U,
- class Traits = neutron_absorber,
+ class Traits = partial_absorber,
                    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_et, U),
@@ -605,7 +605,7 @@

// Test for nontrivial erasure of interval maps with intervals and interval sets
template <template<class T, class U,
- class Traits = neutron_absorber,
+ class Traits = partial_absorber,
                    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_et, U),
@@ -722,7 +722,7 @@

// Test first_collision
template <template<class T, class U,
- class Traits = neutron_absorber,
+ class Traits = partial_absorber,
                    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_et, U),
@@ -794,7 +794,7 @@
}

template <template<class T, class U,
- class Traits = neutron_absorber,
+ class Traits = partial_absorber,
                    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_et, U),
@@ -818,7 +818,7 @@
}

template <template<class T, class U,
- class Traits = neutron_absorber,
+ class Traits = partial_absorber,
                    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_et, U),
@@ -845,7 +845,7 @@
}

template <template<class T, class U,
- class Traits = neutron_absorber,
+ class Traits = partial_absorber,
                    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_et, U),
@@ -874,7 +874,7 @@

template <template<class T, class U,
- class Traits = neutron_absorber,
+ class Traits = partial_absorber,
                    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_et, U),
@@ -926,7 +926,7 @@

template <template<class T, class U,
- class Traits = neutron_absorber,
+ class Traits = partial_absorber,
                    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_et, U),
@@ -975,7 +975,7 @@

template <template<class T, class U,
- class Traits = neutron_absorber,
+ class Traits = partial_absorber,
                    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_et, U),

Modified: sandbox/itl/libs/itl/test/test_laws.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_laws.hpp (original)
+++ sandbox/itl/libs/itl/test/test_laws.hpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -145,7 +145,7 @@
DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(caret, ^ );

//------------------------------------------------------------------------------
-// Inversion
+// InplaceNaturalInversion
//------------------------------------------------------------------------------

#define DEFINE_INVERSION_CHECK_WRT_EQUAL(plus_tag, plus_sign) \

Modified: sandbox/itl/libs/itl/test/test_quantifier_map/test_quantifier_map_shared.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_quantifier_map/test_quantifier_map_shared.cpp (original)
+++ sandbox/itl/libs/itl/test/test_quantifier_map/test_quantifier_map_shared.cpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -11,19 +11,19 @@
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_quantifier_map_check_monoid_plus_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_monoid_plus_4_bicremental_types<T, std::string, neutron_absorber, interval_map>();}
+{ quantifier_map_check_monoid_plus_4_bicremental_types<T, std::string, partial_absorber, interval_map>();}

BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_quantifier_map_check_monoid_et_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_monoid_et_4_bicremental_types<T, int, neutron_absorber, interval_map>();}
+{ quantifier_map_check_monoid_et_4_bicremental_types<T, int, partial_absorber, interval_map>();}

BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_quantifier_map_check_abelian_monoid_plus_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_abelian_monoid_plus_4_bicremental_types<T, std::string, neutron_absorber, interval_map>();}
+{ quantifier_map_check_abelian_monoid_plus_4_bicremental_types<T, std::string, partial_absorber, interval_map>();}

BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_quantifier_map_check_abelian_monoid_et_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<T, int, neutron_absorber, interval_map>();}
+{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<T, int, partial_absorber, interval_map>();}

//------------------------------------------------------------------------------
@@ -31,21 +31,21 @@
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_quantifier_map_check_monoid_plus_4_bicremental_types_ta, T, bicremental_types)
-{ quantifier_map_check_monoid_plus_4_bicremental_types<T, std::string, neutron_emitter, interval_map>();}
+{ quantifier_map_check_monoid_plus_4_bicremental_types<T, std::string, total_absorber, interval_map>();}

BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_quantifier_map_check_monoid_et_4_bicremental_types_ta, T, bicremental_types)
-{ quantifier_map_check_monoid_et_4_bicremental_types<T, int, neutron_emitter, interval_map>();}
+{ quantifier_map_check_monoid_et_4_bicremental_types<T, int, total_absorber, interval_map>();}

BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_quantifier_map_check_abelian_monoid_plus_4_bicremental_types_ta, T, bicremental_types)
-{ quantifier_map_check_abelian_monoid_plus_4_bicremental_types<T, std::string, neutron_emitter, interval_map>();}
+{ quantifier_map_check_abelian_monoid_plus_4_bicremental_types<T, std::string, total_absorber, interval_map>();}

BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_quantifier_map_check_abelian_monoid_et_4_bicremental_types_ta, T, bicremental_types)
-{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<T, int, neutron_emitter, interval_map>();}
+{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<T, int, total_absorber, interval_map>();}

BOOST_AUTO_TEST_CASE_TEMPLATE
(test_itl_quantifier_map_check_abelian_group_plus_4_bicremental_types_ta, T, bicremental_types)
-{ quantifier_map_check_abelian_group_plus_4_bicremental_types<T, int, neutron_emitter, interval_map>();}
+{ quantifier_map_check_abelian_group_plus_4_bicremental_types<T, int, total_absorber, interval_map>();}

Modified: sandbox/itl/libs/itl_xt/test/meta_functors/meta_functors.cpp
==============================================================================
--- sandbox/itl/libs/itl_xt/test/meta_functors/meta_functors.cpp (original)
+++ sandbox/itl/libs/itl_xt/test/meta_functors/meta_functors.cpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -252,7 +252,7 @@

void misc_test()
{
- typedef interval_map<int,int,neutron_enricher> MapT;
+ typedef interval_map<int,int,partial_enricher> MapT;
         MapT m;
         m += MapT::value_type(interval<int>::rightopen(1,3), 1);
         cout << m << endl;

Modified: sandbox/itl/libs/validate/example/labat_single/labat_single.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_single/labat_single.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_single/labat_single.cpp 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -47,45 +47,45 @@
     //map_cluster_star_pushout.setTrialsCount(1000);
     //map_cluster_star_pushout.run();

- //typedef InplaceSymmetricDifference<split_interval_map<int, int, neutron_emitter >, std_equal> TestLawT;
+ //typedef InplaceSymmetricDifference<split_interval_map<int, int, total_absorber >, std_equal> TestLawT;
         //LawValidater<TestLawT, RandomGentor> test_law;
         //test_law.setTrialsCount(1000);
         //test_law.run();

         //typedef InplaceDistributivity
- // <split_interval_map<int, itl::set<int>, neutron_absorber >,
+ // <split_interval_map<int, itl::set<int>, partial_absorber >,
         // inplace_et, inplace_plus, itl::std_equal> TestLawT;
         //LawValidater<TestLawT, RandomGentor> test_law;
         //test_law.setTrialsCount(1000);

- //typedef InplaceSelfRemovability
- // <split_interval_map<int, itl::set<int>, neutron_emitter >,
+ //typedef InplaceNaturalInversion
+ // <split_interval_map<int, itl::set<int>, total_absorber >,
         // itl::inplace_plus, itl::protonic_equal> TestLawT;
         //LawValidater<TestLawT, RandomGentor> test_law;
         //test_law.setTrialsCount(1000);

         //typedef InplaceAssociativity
- // <split_interval_map<int, int, neutron_emitter >, inplace_et> TestLawT;
+ // <split_interval_map<int, int, total_absorber >, inplace_et> TestLawT;
         //LawValidater<TestLawT, RandomGentor> test_law;
         //test_law.setTrialsCount(1000);

         //typedef InplaceCommutativity
- // <split_interval_map<int, int, neutron_emitter>, inplace_plus> TestLawT;
+ // <split_interval_map<int, int, total_absorber>, inplace_plus> TestLawT;
         //LawValidater<TestLawT, RandomGentor> test_law;
         //test_law.setTrialsCount(1000);

         //typedef ProtonicEquality
- // <split_interval_map<int, int, neutron_enricher > > TestLawT;
+ // <split_interval_map<int, int, partial_enricher > > TestLawT;
         //LawValidater<TestLawT, RandomGentor> test_law;
         //test_law.setTrialsCount(1000);

- //typedef InplaceInverseRemovability
- // <split_interval_map<int, int, neutron_emitter>, inplace_plus> TestLawT;
+ //typedef InplaceInverseExistence
+ // <split_interval_map<int, int, total_absorber>, inplace_plus> TestLawT;
         //LawValidater<TestLawT, RandomGentor> test_law;
         //test_law.setTrialsCount(1000);

         typedef InplaceFlip
- <split_interval_map<int, int, neutron_polluter > > TestLawT;
+ <split_interval_map<int, int, total_enricher > > TestLawT;
         LawValidater<TestLawT, RandomGentor> test_law;
         test_law.setTrialsCount(10000);

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 2009-01-29 03:47:23 EST (Thu, 29 Jan 2009)
@@ -57,35 +57,35 @@
     //map_cluster_star_pushout.setTrialsCount(1000);
     //map_cluster_star_pushout.run();

- //typedef InplaceSymmetricDifference<interval_map<int, itl::set<int>, neutron_emitter_and_enricher >, std_equal> TestLawT;
+ //typedef InplaceSymmetricDifference<interval_map<int, itl::set<int>, total_enricher >, std_equal> TestLawT;
         //LawValidater<TestLawT, RandomGentor> test_law;
         //test_law.setTrialsCount(1000);
         //test_law.run();

         //typedef InplaceDistributivity
- // <split_interval_map<int, itl::set<int>, neutron_absorber >,
+ // <split_interval_map<int, itl::set<int>, partial_absorber >,
         // inplace_et, inplace_plus, itl::std_equal> TestLawT;
         //LawValidater<TestLawT, RandomGentor> test_law;
         //test_law.setTrialsCount(1000);

- typedef InplaceSelfRemovability
- <split_interval_map<int, itl::set<int>, neutron_emitter >,
+ typedef InplaceNaturalInversion
+ <split_interval_map<int, itl::set<int>, total_absorber >,
                 itl::inplace_plus, itl::protonic_equal> TestLawT;
         LawValidater<TestLawT, RandomGentor> test_law;
         test_law.setTrialsCount(1000);

         //typedef InplaceAssociativity
- // <interval_map<int, int, neutron_absorber >, inplace_plus> TestLawT;
+ // <interval_map<int, int, partial_absorber >, inplace_plus> TestLawT;
         //LawValidater<TestLawT, RandomGentor> test_law;
         //test_law.setTrialsCount(1000);

         //typedef InplaceCommutativity
- // <split_interval_map<int, int, neutron_emitter>, inplace_plus> TestLawT;
+ // <split_interval_map<int, int, total_absorber>, inplace_plus> TestLawT;
         //LawValidater<TestLawT, RandomGentor> test_law;
         //test_law.setTrialsCount(1000);

         //typedef ProtonicEquality
- // <split_interval_map<int, int, neutron_enricher > > TestLawT;
+ // <split_interval_map<int, int, partial_enricher > > TestLawT;
         //LawValidater<TestLawT, RandomGentor> test_law;
         //test_law.setTrialsCount(1000);

Next message: ockham_at_[hidden]: "[Boost-commit] svn:boost r50865 - sandbox/SOC/2006/tree/trunk/libs/tree/test"
Previous message: dave_at_[hidden]: "[Boost-commit] svn:boost r50863 - in trunk/libs/parameter: doc doc/html test test/literate"

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