|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r65826 - in sandbox/itl: boost/itl boost/itl/concept boost/itl/detail boost/itl/type_traits boost/itl_xt/detail boost/validate/laws boost/validate/validater libs/itl/test
From: afojgo_at_[hidden]
Date: 2010-10-08 06:56:49
Author: jofaber
Date: 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
New Revision: 65826
URL: http://svn.boost.org/trac/boost/changeset/65826
Log:
Refactoring: Renaming unon, neutron etc. 4. Renaming long combined identifiers. Medium test. Stable{msvc-9.0,10.0, gcc-3.4.4}
Added:
sandbox/itl/boost/itl/type_traits/absorbs_identities.hpp (contents, props changed)
sandbox/itl/boost/itl/type_traits/identity_element.hpp (contents, props changed)
sandbox/itl/boost/itl/type_traits/unit_element.hpp (contents, props changed)
Text files modified:
sandbox/itl/boost/itl/concept/element_map.hpp | 30 ++++++++++++------------
sandbox/itl/boost/itl/concept/interval_associator.hpp | 4 +-
sandbox/itl/boost/itl/concept/interval_map.hpp | 14 +++++-----
sandbox/itl/boost/itl/detail/interval_morphism.hpp | 6 ++--
sandbox/itl/boost/itl/detail/map_algo.hpp | 2
sandbox/itl/boost/itl/detail/on_absorbtion.hpp | 2
sandbox/itl/boost/itl/functors.hpp | 38 +++++++++++++++---------------
sandbox/itl/boost/itl/interval_base_map.hpp | 26 ++++++++++----------
sandbox/itl/boost/itl/interval_map.hpp | 16 ++++++------
sandbox/itl/boost/itl/map.hpp | 48 ++++++++++++++++++++--------------------
sandbox/itl/boost/itl/predicates.hpp | 6 ++--
sandbox/itl/boost/itl/split_interval_map.hpp | 16 ++++++------
sandbox/itl/boost/itl/type_traits/absorbs_neutrons.hpp | 4 +-
sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp | 4 +-
sandbox/itl/boost/validate/laws/map_laws.hpp | 36 +++++++++++++++---------------
sandbox/itl/boost/validate/validater/bit_collector_validater.hpp | 4 +-
sandbox/itl/boost/validate/validater/collector_validater.hpp | 4 +-
sandbox/itl/boost/validate/validater/interval_morphic_validater.hpp | 2
sandbox/itl/boost/validate/validater/signed_quantifier_validater.hpp | 18 +++++++-------
sandbox/itl/boost/validate/validater/unsigned_quantifier_validater.hpp | 10 ++++----
sandbox/itl/libs/itl/test/test_icl_quantifier_shared.hpp | 8 +++---
sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp | 8 +++---
sandbox/itl/libs/itl/test/test_interval_set_laws_shared.hpp | 8 +++---
sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp | 8 +++---
sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp | 8 +++---
25 files changed, 165 insertions(+), 165 deletions(-)
Modified: sandbox/itl/boost/itl/concept/element_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/element_map.hpp (original)
+++ sandbox/itl/boost/itl/concept/element_map.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/mpl/not.hpp>
#include <boost/itl/detail/on_absorbtion.hpp>
#include <boost/itl/type_traits/is_total.hpp>
-#include <boost/itl/type_traits/absorbs_neutrons.hpp>
+#include <boost/itl/type_traits/absorbs_identities.hpp>
#include <boost/itl/type_traits/is_associative_element_container.hpp>
#include <boost/itl/type_traits/is_combinable.hpp>
@@ -62,9 +62,9 @@
/** Protonic equality is equality on all elements that do not carry an identity element as content. */
template<class Type>
inline typename enable_if<is_element_map<Type>, bool>::type
-is_protonic_equal(const Type& lhs, const Type& rhs)
+is_distinct_equal(const Type& lhs, const Type& rhs)
{
- return Map::lexicographical_protonic_equal(lhs, rhs);
+ return Map::lexicographical_distinct_equal(lhs, rhs);
}
//==============================================================================
@@ -103,9 +103,9 @@
{
typedef typename Type::size_type size_type;
typedef typename Type::iterator iterator;
- typedef typename Type::on_neutron_absorbtion on_neutron_absorbtion;
+ typedef typename Type::on_identity_absorbtion on_identity_absorbtion;
- if(on_neutron_absorbtion::is_absorbable(value_pair.second))
+ if(on_identity_absorbtion::is_absorbable(value_pair.second))
return neutron<size_type>::value();
iterator it_ = object.find(value_pair.first);
@@ -195,10 +195,10 @@
{
typedef typename Type::iterator iterator;
typedef typename Type::codomain_combine codomain_combine;
- typedef on_absorbtion<Type,codomain_combine,absorbs_neutrons<Type>::value>
- on_neutron_absorbtion;
+ typedef on_absorbtion<Type,codomain_combine,absorbs_identities<Type>::value>
+ on_identity_absorbtion;
- if(!on_neutron_absorbtion::is_absorbable(operand.second))
+ if(!on_identity_absorbtion::is_absorbable(operand.second))
{
std::pair<iterator,bool> insertion = object.insert(operand);
if(!insertion.second)
@@ -372,7 +372,7 @@
template<class Type, class CoType>
inline typename enable_if< mpl::and_< is_element_map<Type>
, is_total<Type>
- , absorbs_neutrons<Type> >
+ , absorbs_identities<Type> >
, Type>::type&
operator ^= (Type& object, const CoType&)
{
@@ -383,7 +383,7 @@
template<class Type>
inline typename enable_if< mpl::and_< is_element_map<Type>
, is_total<Type>
- , mpl::not_<absorbs_neutrons<Type> > >
+ , mpl::not_<absorbs_identities<Type> > >
, Type>::type&
operator ^= (Type& object, const typename Type::element_type& operand)
{
@@ -393,7 +393,7 @@
template<class Type>
inline typename enable_if< mpl::and_< is_element_map<Type>
, is_total<Type>
- , mpl::not_<absorbs_neutrons<Type> > >
+ , mpl::not_<absorbs_identities<Type> > >
, Type>::type&
operator ^= (Type& object, const Type& operand)
{
@@ -452,8 +452,8 @@
//==============================================================================
template<class Type>
inline typename enable_if<mpl::and_< is_element_map<Type>
- , absorbs_neutrons<Type> >, Type>::type&
-absorb_neutrons(Type& object)
+ , absorbs_identities<Type> >, Type>::type&
+absorb_identities(Type& object)
{
typedef typename Type::element_type element_type;
return itl::erase_if(content_is_neutron<element_type>(), object);
@@ -461,9 +461,9 @@
template<class Type>
inline typename enable_if<mpl::and_< is_element_map<Type>
- , mpl::not_<absorbs_neutrons<Type> > >
+ , mpl::not_<absorbs_identities<Type> > >
, Type>::type&
-absorb_neutrons(Type&){}
+absorb_identities(Type&){}
//==============================================================================
//= Streaming<ElementMap>
Modified: sandbox/itl/boost/itl/concept/interval_associator.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/interval_associator.hpp (original)
+++ sandbox/itl/boost/itl/concept/interval_associator.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -97,9 +97,9 @@
template<class LeftT, class RightT>
typename enable_if< is_concept_compatible<is_interval_map, LeftT, RightT>,
bool >::type
-is_protonic_equal(const LeftT& left, const RightT& right)
+is_distinct_equal(const LeftT& left, const RightT& right)
{
- return Map::lexicographical_protonic_equal(left, right);
+ return Map::lexicographical_distinct_equal(left, right);
}
//==============================================================================
Modified: sandbox/itl/boost/itl/concept/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/concept/interval_map.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/itl/type_traits/element_type_of.hpp>
#include <boost/itl/type_traits/segment_type_of.hpp>
-#include <boost/itl/type_traits/absorbs_neutrons.hpp>
+#include <boost/itl/type_traits/absorbs_identities.hpp>
#include <boost/itl/type_traits/is_combinable.hpp>
#include <boost/itl/concept/map_value.hpp>
@@ -475,7 +475,7 @@
//------------------------------------------------------------------------------
template<class Type, class OperandT>
typename enable_if< mpl::and_< is_total<Type>
- , absorbs_neutrons<Type>
+ , absorbs_identities<Type>
, is_concept_compatible<is_interval_map,
Type, OperandT >
>
@@ -495,7 +495,7 @@
#endif
template<class Type, class OperandT>
typename enable_if< mpl::and_< is_total<Type>
- , mpl::not_<absorbs_neutrons<Type> >
+ , mpl::not_<absorbs_identities<Type> >
, is_concept_compatible<is_interval_map,
Type, OperandT >
>
@@ -608,16 +608,16 @@
//==============================================================================
template<class Type>
typename enable_if<mpl::and_< is_interval_map<Type>
- , absorbs_neutrons<Type> >, Type>::type&
-absorb_neutrons(Type& object)
+ , absorbs_identities<Type> >, Type>::type&
+absorb_identities(Type& object)
{
return object;
}
template<class Type>
typename enable_if<mpl::and_< is_interval_map<Type>
- , mpl::not_<absorbs_neutrons<Type> > >, Type>::type&
-absorb_neutrons(Type& object)
+ , mpl::not_<absorbs_identities<Type> > >, Type>::type&
+absorb_identities(Type& object)
{
typedef typename Type::segment_type segment_type;
return itl::erase_if(content_is_neutron<segment_type>(), object);
Modified: sandbox/itl/boost/itl/detail/interval_morphism.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/interval_morphism.hpp (original)
+++ sandbox/itl/boost/itl/detail/interval_morphism.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -74,11 +74,11 @@
};
template <typename AbsorberType, typename EnricherType>
- struct neutron_absorber
+ struct identity_absorber
{
void operator()(AbsorberType& absorber, EnricherType& enricher)
{
- itl::absorb_neutrons(enricher);
+ itl::absorb_identities(enricher);
ITL_FORALL(typename EnricherType, enricher_, enricher)
absorber.insert(*enricher_);
}
@@ -94,7 +94,7 @@
template<>
inline std::string binary_template_to_string<segmental::joiner>::apply() { return "j"; }
template<>
- inline std::string binary_template_to_string<segmental::neutron_absorber>::apply() { return "a0"; }
+ inline std::string binary_template_to_string<segmental::identity_absorber>::apply() { return "a0"; }
}} // namespace boost itl
#endif // BOOST_ITL_DETAIL_INTERVAL_MORPHISM_HPP_JOFA_080315
Modified: sandbox/itl/boost/itl/detail/map_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/map_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/map_algo.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -54,7 +54,7 @@
/** Function template <tt>lexicographical_equal</tt> implements
lexicographical equality except for neutronic content values. */
template<class MapT>
-bool lexicographical_protonic_equal(const MapT& left, const MapT& right)
+bool lexicographical_distinct_equal(const MapT& left, const MapT& right)
{
if(&left == &right)
return true;
Modified: sandbox/itl/boost/itl/detail/on_absorbtion.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/on_absorbtion.hpp (original)
+++ sandbox/itl/boost/itl/detail/on_absorbtion.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -11,7 +11,7 @@
namespace boost{ namespace itl
{
-template<class Type, class Combiner, bool absorbs_neutrons>
+template<class Type, class Combiner, bool absorbs_identities>
struct on_absorbtion;
template<class Type, class Combiner>
Modified: sandbox/itl/boost/itl/functors.hpp
==============================================================================
--- sandbox/itl/boost/itl/functors.hpp (original)
+++ sandbox/itl/boost/itl/functors.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -19,7 +19,7 @@
namespace boost{namespace itl
{
// ------------------------------------------------------------------------
- template <typename Type> struct neutron_based_inplace_combine
+ template <typename Type> struct identity_based_inplace_combine
: public std::binary_function<Type&, const Type&, void>
{
static Type neutron() { return boost::itl::neutron<Type>::value(); }
@@ -34,7 +34,7 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_identity
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef inplace_identity<Type> type;
void operator()(Type& object, const Type& operand)const{}
@@ -46,7 +46,7 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_erasure
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef inplace_erasure<Type> type;
@@ -63,7 +63,7 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_plus
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef inplace_plus<Type> type;
@@ -78,7 +78,7 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_minus
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef inplace_minus<Type> type;
@@ -91,7 +91,7 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_bit_add
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef inplace_bit_add<Type> type;
@@ -106,7 +106,7 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_bit_subtract
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef inplace_bit_subtract<Type> type;
@@ -121,7 +121,7 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_bit_and
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef inplace_bit_and<Type> type;
@@ -134,7 +134,7 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_bit_xor
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef inplace_bit_xor<Type> type;
@@ -146,7 +146,7 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_et
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef inplace_et<Type> type;
@@ -159,7 +159,7 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_caret
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef inplace_caret<Type> type;
@@ -174,7 +174,7 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_insert
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef inplace_insert<Type> type;
@@ -189,7 +189,7 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_erase
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef inplace_erase<Type> type;
@@ -204,7 +204,7 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_star
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef inplace_star<Type> type;
@@ -219,7 +219,7 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_slash
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef inplace_slash<Type> type;
@@ -234,7 +234,7 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_max
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef inplace_max<Type> type;
@@ -252,7 +252,7 @@
// ------------------------------------------------------------------------
template <typename Type> struct inplace_min
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef inplace_min<Type> type;
@@ -272,7 +272,7 @@
// Inter_section functor
//--------------------------------------------------------------------------
template<class Type> struct inter_section
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef typename boost::mpl::
if_<has_set_semantics<Type>,
@@ -346,7 +346,7 @@
//--------------------------------------------------------------------------
template<class Type>
struct inverse<itl::inter_section<Type> >
- : public neutron_based_inplace_combine<Type>
+ : public identity_based_inplace_combine<Type>
{
typedef typename boost::mpl::
if_<has_set_semantics<Type>,
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 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -189,7 +189,7 @@
typedef boost::itl::element_iterator<const_reverse_iterator> element_const_reverse_iterator;
typedef typename on_absorbtion<type, codomain_combine,
- Traits::absorbs_neutrons>::type on_codomain_absorbtion;
+ Traits::absorbs_identities>::type on_codomain_absorbtion;
public:
BOOST_STATIC_CONSTANT(bool,
@@ -408,7 +408,7 @@
/** If \c *this map contains \c interval_value_pair it is erased, otherwise it is added. */
SubType& flip(const segment_type& interval_value_pair)
{
- on_total_absorbable<SubType, Traits::is_total, Traits::absorbs_neutrons>
+ on_total_absorbable<SubType, Traits::is_total, Traits::absorbs_identities>
::flip(*that(), interval_value_pair);
return *that();
}
@@ -526,7 +526,7 @@
{
// inter_val is not conained in this map. Insertion will be successful
BOOST_ASSERT(this->_map.find(inter_val) == this->_map.end());
- BOOST_ASSERT((!on_absorbtion<type,Combiner,Traits::absorbs_neutrons>::is_absorbable(co_val)));
+ BOOST_ASSERT((!on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(co_val)));
return this->_map.insert(prior_, value_type(inter_val, version<Combiner>()(co_val)));
}
@@ -536,7 +536,7 @@
const codomain_type& co_val )
{
// Never try to insert an identity element into an identity element absorber here:
- BOOST_ASSERT((!(on_absorbtion<type,Combiner,Traits::absorbs_neutrons>::is_absorbable(co_val))));
+ BOOST_ASSERT((!(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(co_val))));
iterator inserted_
= this->_map.insert(prior_, value_type(inter_val, Combiner::neutron()));
@@ -673,7 +673,7 @@
//--------------------------------------------------------------------------
- template<class Type, bool is_total, bool absorbs_neutrons>
+ template<class Type, bool is_total, bool absorbs_identities>
struct on_total_absorbable;
template<class Type>
@@ -700,8 +700,8 @@
}
};
- template<class Type, bool absorbs_neutrons>
- struct on_total_absorbable<Type, false, absorbs_neutrons>
+ template<class Type, bool absorbs_identities>
+ struct on_total_absorbable<Type, false, absorbs_identities>
{
typedef typename Type::segment_type segment_type;
typedef typename Type::codomain_type codomain_type;
@@ -902,7 +902,7 @@
::_add(const segment_type& addend)
{
typedef typename on_absorbtion<type,Combiner,
- absorbs_neutrons<type>::value>::type on_absorbtion_;
+ absorbs_identities<type>::value>::type on_absorbtion_;
const interval_type& inter_val = addend.first;
if(itl::is_empty(inter_val))
@@ -940,7 +940,7 @@
::_add(iterator prior_, const segment_type& addend)
{
typedef typename on_absorbtion<type,Combiner,
- absorbs_neutrons<type>::value>::type on_absorbtion_;
+ absorbs_identities<type>::value>::type on_absorbtion_;
const interval_type& inter_val = addend.first;
if(itl::is_empty(inter_val))
@@ -1037,7 +1037,7 @@
return;
const codomain_type& co_val = minuend.second;
- if(on_absorbtion<type,Combiner,Traits::absorbs_neutrons>::is_absorbable(co_val))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(co_val))
return;
std::pair<iterator, iterator> exterior = this->_map.equal_range(inter_val);
@@ -1328,10 +1328,10 @@
class SubType,
class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc
>
-struct absorbs_neutrons<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct absorbs_identities<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef absorbs_neutrons<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_neutrons));
+ typedef absorbs_identities<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities));
};
template
Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -132,7 +132,7 @@
template<class Combiner>
void handle_left_combined(iterator it_)
{
- if(on_absorbtion<type,Combiner,Traits::absorbs_neutrons>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
this->_map.erase(it_);
else
segmental::join_left(*this, it_);
@@ -141,7 +141,7 @@
template<class Combiner>
void handle_combined(iterator it_)
{
- if(on_absorbtion<type,Combiner,Traits::absorbs_neutrons>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
this->_map.erase(it_);
else
segmental::join_neighbours(*this, it_);
@@ -150,7 +150,7 @@
template<class Combiner>
void handle_preceeded_combined(iterator prior_, iterator& it_)
{
- if(on_absorbtion<type,Combiner,Traits::absorbs_neutrons>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
{
this->_map.erase(it_);
it_ = prior_;
@@ -162,7 +162,7 @@
template<class Combiner>
void handle_succeeded_combined(iterator it_, iterator next_)
{
- if(on_absorbtion<type,Combiner,Traits::absorbs_neutrons>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
{
this->_map.erase(it_);
segmental::join_right(*this, next_);
@@ -186,7 +186,7 @@
void gap_insert_at(iterator& it_, iterator prior_,
const interval_type& end_gap, const codomain_type& co_val)
{
- if(on_absorbtion<type,Combiner,Traits::absorbs_neutrons>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
{
this->_map.erase(it_);
it_ = this->template gap_insert<Combiner>(prior_, end_gap, co_val);
@@ -229,10 +229,10 @@
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct absorbs_neutrons<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct absorbs_identities<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef absorbs_neutrons<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_neutrons));
+ typedef absorbs_identities<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities));
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -26,7 +26,7 @@
#include <boost/itl/detail/concept_check.hpp>
#include <boost/itl/detail/on_absorbtion.hpp>
#include <boost/itl/type_traits/is_map.hpp>
-#include <boost/itl/type_traits/absorbs_neutrons.hpp>
+#include <boost/itl/type_traits/absorbs_identities.hpp>
#include <boost/itl/type_traits/is_total.hpp>
#include <boost/itl/type_traits/is_element_container.hpp>
#include <boost/itl/type_traits/has_inverse.hpp>
@@ -45,7 +45,7 @@
struct partial_absorber
{
- enum { absorbs_neutrons = true };
+ enum { absorbs_identities = true };
enum { is_total = false };
};
@@ -54,7 +54,7 @@
struct partial_enricher
{
- enum { absorbs_neutrons = false };
+ enum { absorbs_identities = false };
enum { is_total = false };
};
@@ -63,7 +63,7 @@
struct total_absorber
{
- enum { absorbs_neutrons = true };
+ enum { absorbs_identities = true };
enum { is_total = true };
};
@@ -72,7 +72,7 @@
struct total_enricher
{
- enum { absorbs_neutrons = false };
+ enum { absorbs_identities = false };
enum { is_total = true };
};
@@ -129,12 +129,12 @@
typedef typename base_type::value_compare value_compare;
BOOST_STATIC_CONSTANT(bool, _total = (Traits::is_total));
- BOOST_STATIC_CONSTANT(bool, _absorbs = (Traits::absorbs_neutrons));
+ BOOST_STATIC_CONSTANT(bool, _absorbs = (Traits::absorbs_identities));
BOOST_STATIC_CONSTANT(bool,
total_invertible = (mpl::and_<is_total<type>, has_inverse<codomain_type> >::value));
- typedef on_absorbtion<type,codomain_combine,Traits::absorbs_neutrons>
- on_neutron_absorbtion;
+ typedef on_absorbtion<type,codomain_combine,Traits::absorbs_identities>
+ on_identity_absorbtion;
public:
typedef typename base_type::pointer pointer;
@@ -294,7 +294,7 @@
//==========================================================================
std::pair<iterator,bool> insert(const value_type& value_pair)
{
- if(on_neutron_absorbtion::is_absorbable(value_pair.second))
+ if(on_identity_absorbtion::is_absorbable(value_pair.second))
return std::pair<iterator,bool>(end(),true);
else
return base_type::insert(value_pair);
@@ -302,7 +302,7 @@
iterator insert(iterator prior, const value_type& value_pair)
{
- if(on_neutron_absorbtion::is_absorbable(value_pair.second))
+ if(on_identity_absorbtion::is_absorbable(value_pair.second))
return end();
else
return base_type::insert(prior, value_pair);
@@ -423,12 +423,12 @@
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
- template<class Type, bool has_set_semantics, bool absorbs_neutrons>
+ template<class Type, bool has_set_semantics, bool absorbs_identities>
struct on_codomain_model;
template<class Type>
struct on_codomain_model<Type, false, false>
- { // !codomain_is_set, !absorbs_neutrons
+ { // !codomain_is_set, !absorbs_identities
static void subtract(Type&, typename Type::iterator it_,
const typename Type::codomain_type& )
{ it_->second = neutron<typename Type::codomain_type>::value(); }
@@ -436,7 +436,7 @@
template<class Type>
struct on_codomain_model<Type, false, true>
- { // !codomain_is_set, absorbs_neutrons
+ { // !codomain_is_set, absorbs_identities
static void subtract(Type& object, typename Type::iterator it_,
const typename Type::codomain_type& )
{ object.erase(it_); }
@@ -444,7 +444,7 @@
template<class Type>
struct on_codomain_model<Type, true, false>
- { // !codomain_is_set, !absorbs_neutrons
+ { // !codomain_is_set, !absorbs_identities
typedef typename Type::inverse_codomain_intersect inverse_codomain_intersect;
static void subtract(Type&, typename Type::iterator it_,
const typename Type::codomain_type& co_value)
@@ -455,7 +455,7 @@
template<class Type>
struct on_codomain_model<Type, true, true>
- { // !codomain_is_set, absorbs_neutrons
+ { // !codomain_is_set, absorbs_identities
typedef typename Type::inverse_codomain_intersect inverse_codomain_intersect;
static void subtract(Type& object, typename Type::iterator it_,
const typename Type::codomain_type& co_value)
@@ -468,7 +468,7 @@
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
- template<class Type, bool is_total, bool absorbs_neutrons>
+ template<class Type, bool is_total, bool absorbs_identities>
struct on_total_absorbable;
template<class Type>
@@ -495,7 +495,7 @@
template<class Type>
struct on_total_absorbable<Type, false, true>
- { // !is_total, absorbs_neutrons
+ { // !is_total, absorbs_identities
typedef typename Type::element_type element_type;
typedef typename Type::codomain_type codomain_type;
typedef typename Type::iterator iterator;
@@ -512,7 +512,7 @@
template<class Type>
struct on_total_absorbable<Type, false, false>
- { // !is_total !absorbs_neutrons
+ { // !is_total !absorbs_identities
typedef typename Type::element_type element_type;
typedef typename Type::codomain_type codomain_type;
typedef typename Type::iterator iterator;
@@ -546,7 +546,7 @@
::_add(const element_type& addend)
{
typedef typename on_absorbtion
- <type,Combiner,absorbs_neutrons<type>::value>::type on_absorbtion_;
+ <type,Combiner,absorbs_identities<type>::value>::type on_absorbtion_;
const codomain_type& co_val = addend.second;
if(on_absorbtion_::is_absorbable(co_val))
@@ -574,7 +574,7 @@
::_add(iterator prior_, const value_type& addend)
{
typedef typename on_absorbtion
- <type,Combiner,absorbs_neutrons<type>::value>::type on_absorbtion_;
+ <type,Combiner,absorbs_identities<type>::value>::type on_absorbtion_;
const codomain_type& co_val = addend.second;
if(on_absorbtion_::is_absorbable(co_val))
@@ -604,7 +604,7 @@
map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::_subtract(const value_type& minuend)
{
typedef typename on_absorbtion
- <type,Combiner,absorbs_neutrons<type>::value>::type on_absorbtion_;
+ <type,Combiner,absorbs_identities<type>::value>::type on_absorbtion_;
iterator it_ = find(minuend.first);
if(it_ != end())
@@ -635,10 +635,10 @@
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-struct absorbs_neutrons<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
+struct absorbs_identities<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
{
- typedef absorbs_neutrons type;
- BOOST_STATIC_CONSTANT(int, value = Traits::absorbs_neutrons);
+ typedef absorbs_identities type;
+ BOOST_STATIC_CONSTANT(int, value = Traits::absorbs_identities);
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
Modified: sandbox/itl/boost/itl/predicates.hpp
==============================================================================
--- sandbox/itl/boost/itl/predicates.hpp (original)
+++ sandbox/itl/boost/itl/predicates.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -83,16 +83,16 @@
{ return "="; }
template <class Type>
- struct protonic_equal : public relation<Type,Type>
+ struct distinct_equal : public relation<Type,Type>
{
bool operator()(const Type& lhs, const Type& rhs)const
{
- return is_protonic_equal(lhs, rhs);
+ return is_distinct_equal(lhs, rhs);
}
};
template<>
- inline std::string unary_template_to_string<itl::protonic_equal>::apply()
+ inline std::string unary_template_to_string<itl::distinct_equal>::apply()
{ return "==/0"; }
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 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -105,21 +105,21 @@
template<class Combiner>
void handle_left_combined(iterator it_)
{
- if(on_absorbtion<type,Combiner,Traits::absorbs_neutrons>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
this->_map.erase(it_);
}
template<class Combiner>
void handle_combined(iterator it_)
{
- if(on_absorbtion<type,Combiner,Traits::absorbs_neutrons>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
this->_map.erase(it_);
}
template<class Combiner>
void handle_preceeded_combined(iterator prior_, iterator& it_)
{
- if(on_absorbtion<type,Combiner,Traits::absorbs_neutrons>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
{
this->_map.erase(it_);
it_ = prior_;
@@ -129,7 +129,7 @@
template<class Combiner>
void handle_succeeded_combined(iterator it_, iterator)
{
- if(on_absorbtion<type,Combiner,Traits::absorbs_neutrons>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
this->_map.erase(it_);
}
@@ -139,7 +139,7 @@
void gap_insert_at(iterator& it_, iterator prior_,
const interval_type& end_gap, const codomain_type& co_val)
{
- if(on_absorbtion<type,Combiner,Traits::absorbs_neutrons>::is_absorbable(it_->second))
+ if(on_absorbtion<type,Combiner,Traits::absorbs_identities>::is_absorbable(it_->second))
{
this->_map.erase(it_);
it_ = this->template gap_insert<Combiner>(prior_, end_gap, co_val);
@@ -181,10 +181,10 @@
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-struct absorbs_neutrons<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
+struct absorbs_identities<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
- typedef absorbs_neutrons<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_neutrons));
+ typedef absorbs_identities<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
+ BOOST_STATIC_CONSTANT(bool, value = (Traits::absorbs_identities));
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
Added: sandbox/itl/boost/itl/type_traits/absorbs_identities.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl/type_traits/absorbs_identities.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -0,0 +1,23 @@
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2010: 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 BOOST_ITL_TYPE_TRAITS_ABSORBS_IDENTITIES_HPP_JOFA_081004
+#define BOOST_ITL_TYPE_TRAITS_ABSORBS_IDENTITIES_HPP_JOFA_081004
+
+namespace boost{ namespace itl
+{
+ template <class Type> struct absorbs_identities
+ {
+ typedef absorbs_identities<Type> type;
+ BOOST_STATIC_CONSTANT(bool, value = false);
+ };
+
+}} // namespace boost itl
+
+#endif
+
+
Modified: sandbox/itl/boost/itl/type_traits/absorbs_neutrons.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/absorbs_neutrons.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/absorbs_neutrons.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -10,9 +10,9 @@
namespace boost{ namespace itl
{
- template <class Type> struct absorbs_neutrons
+ template <class Type> struct absorbs_identities
{
- typedef absorbs_neutrons<Type> type;
+ typedef absorbs_identities<Type> type;
BOOST_STATIC_CONSTANT(bool, value = false);
};
Added: sandbox/itl/boost/itl/type_traits/identity_element.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl/type_traits/identity_element.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -0,0 +1,34 @@
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2009: 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 BOOST_ITL_TYPE_TRAITS_IDENTITY_ELEMENT_HPP_JOFA_080912
+#define BOOST_ITL_TYPE_TRAITS_IDENTITY_ELEMENT_HPP_JOFA_080912
+
+#include <boost/itl/type_traits/type_to_string.hpp>
+
+namespace boost{ namespace itl
+{
+ template <class Type> struct identity_element
+ {
+ static Type value();
+ Type operator()()const { return value(); }
+ };
+
+ template <class Type>
+ inline Type identity_element<Type>::value()
+ {
+ return Type();
+ }
+
+ template<>
+ inline std::string unary_template_to_string<identity_element>::apply() { return "0"; }
+
+}} // namespace boost itl
+
+#endif
+
+
Added: sandbox/itl/boost/itl/type_traits/unit_element.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl/type_traits/unit_element.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -0,0 +1,38 @@
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2008-2010: 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 BOOST_ITL_TYPE_TRAITS_UNIT_ELEMENT_HPP_JOFA_080912
+#define BOOST_ITL_TYPE_TRAITS_UNIT_ELEMENT_HPP_JOFA_080912
+
+#include <string>
+#include <boost/itl/type_traits/identity_element.hpp>
+#include <boost/itl/type_traits/succ_pred.hpp>
+
+namespace boost{ namespace itl
+{
+ template <class Type> struct unit_element{ static Type value(); };
+
+ template<> inline bool unit_element<bool>::value() { return true;}
+ template<> inline float unit_element<float>::value() { return 1.0; }
+ template<> inline double unit_element<double>::value() { return 1.0; }
+ template<> inline long double unit_element<long double>::value()
+ { return 1.0; }
+
+ // Smallest 'visible' string that is greater than the empty string.
+ template <>
+ inline std::string unit_element<std::string>::value()
+ { return std::string(" "); }
+
+ template <class Type>
+ inline Type unit_element<Type>::value()
+ { return itl::succ(identity_element<Type>::value()); }
+
+}} // namespace boost itl
+
+#endif
+
+
Modified: sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp (original)
+++ sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -176,13 +176,13 @@
void first_bit()const
{
- // Because interval_bitsets are neutron absorbers, _saltator->second.word() is not an identity element
+ // Because interval_bitsets are identity absorbers, _saltator->second.word() is not an identity element
_on_bit = Proceed::first_bit(_saltator->second.word());
}
void last_bit()const
{
- // Because interval_bitsets are neutron absorbers, _saltator->second.word() is not an identity element
+ // Because interval_bitsets are identity absorbers, _saltator->second.word() is not an identity element
_on_bit = Proceed::last_bit(_saltator->second.word());
}
Modified: sandbox/itl/boost/validate/laws/map_laws.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/map_laws.hpp (original)
+++ sandbox/itl/boost/validate/laws/map_laws.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -77,13 +77,13 @@
: public Law<ProtonicEquality<MapT>,
LOKI_TYPELIST_2(MapT,MapT), LOKI_TYPELIST_2(bool,bool)>
{
- /** (a.absorb_neutrons() == b.absorb_neutrons()) == is_protonic_equal(a, b)
+ /** (a.absorb_identities() == b.absorb_identities()) == is_distinct_equal(a, b)
Input = (a := inVal1, b := inVal2)
Output = (lhs_result, rhs_result)
*/
public:
std::string name()const { return "ProtonicEquality"; }
- std::string formula()const { return "(a.absorb_neutrons() == b.absorb_neutrons()) == is_protonic_equal(a, b)"; }
+ std::string formula()const { return "(a.absorb_identities() == b.absorb_identities()) == is_distinct_equal(a, b)"; }
std::string typeString()const
{
@@ -94,21 +94,21 @@
bool holds()
{
- // (a.absorb_neutrons() == b.absorb_neutrons()) == is_protonic_equal(a, b)
+ // (a.absorb_identities() == b.absorb_identities()) == is_distinct_equal(a, b)
// --- left hand side ------------------------
- // lhs := (a.absorb_neutrons() == b.absorb_neutrons())
+ // lhs := (a.absorb_identities() == b.absorb_identities())
MapT a = this->template getInputValue<operand_a>();
MapT a_protonic = a;
- a_protonic.absorb_neutrons();
+ a_protonic.absorb_identities();
MapT b = this->template getInputValue<operand_b>();
MapT b_protonic = b;
- b_protonic.absorb_neutrons();
+ b_protonic.absorb_identities();
bool lhs = a_protonic == b_protonic;
// --- right hand side -----------------------
- // rhs := is_protonic_equal(a, b)
- bool rhs = is_protonic_equal(a, b);
+ // rhs := is_distinct_equal(a, b)
+ bool rhs = is_distinct_equal(a, b);
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
@@ -118,9 +118,9 @@
bool debug_holds()
{
- // (a.absorb_neutrons() == b.absorb_neutrons()) == is_protonic_equal(a, b)
+ // (a.absorb_identities() == b.absorb_identities()) == is_distinct_equal(a, b)
// --- left hand side ------------------------
- // lhs := (a.absorb_neutrons() == b.absorb_neutrons())
+ // lhs := (a.absorb_identities() == b.absorb_identities())
std::cout << name() << "::debug_holds():" << std::endl;
std::cout << "Instance: " << typeString() << std::endl;
@@ -133,22 +133,22 @@
std::cout << "b: " << b.as_string() << std::endl;
MapT a_protonic = a;
- a_protonic.absorb_neutrons();
+ a_protonic.absorb_identities();
MapT b_protonic = b;
- b_protonic.absorb_neutrons();
+ b_protonic.absorb_identities();
- std::cout << "a.absorb_neutrons(): " << a_protonic.as_string() << std::endl;
- std::cout << "b.absorb_neutrons(): " << b_protonic.as_string() << std::endl;
+ std::cout << "a.absorb_identities(): " << a_protonic.as_string() << std::endl;
+ std::cout << "b.absorb_identities(): " << b_protonic.as_string() << std::endl;
bool lhs = a_protonic == b_protonic;
- std::cout << "lhs := (a.absorb_neutrons() == b.absorb_neutrons()): " << lhs << std::endl;
+ std::cout << "lhs := (a.absorb_identities() == b.absorb_identities()): " << lhs << std::endl;
// --- right hand side -----------------------
- // rhs := is_protonic_equal(a, b)
- bool rhs = is_protonic_equal(a, b);
+ // rhs := is_distinct_equal(a, b)
+ bool rhs = is_distinct_equal(a, b);
- std::cout << "rhs := is_protonic_equal(a, b): " << rhs << std::endl;
+ std::cout << "rhs := is_distinct_equal(a, b): " << rhs << std::endl;
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
Modified: sandbox/itl/boost/validate/validater/bit_collector_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/bit_collector_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/bit_collector_validater.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -85,11 +85,11 @@
case inplaceSymmetricDifference:return new LawValidater<InplaceSymmetricDifference<Type, inplace_bit_add, inplace_bit_subtract, inplace_bit_and> >;
case inplaceFlip: return new LawValidater<InplaceFlip<Type> >;
case inplaceEtDistributivity:
- if(itl::is_interval_splitter<Type>::value && absorbs_neutrons<Type>::value && !is_total<Type>::value)
+ if(itl::is_interval_splitter<Type>::value && absorbs_identities<Type>::value && !is_total<Type>::value)
return new LawValidater<InplaceDistributivity<Type, inplace_bit_and, inplace_bit_add, element_equal> >;
else return new LawValidater<InplaceDistributivity<Type, inplace_bit_and, inplace_bit_add, std_equal> >;
case inplacePlusDashRightDistrib:
- if(itl::is_interval_splitter<Type>::value && absorbs_neutrons<Type>::value && !is_total<Type>::value)
+ if(itl::is_interval_splitter<Type>::value && absorbs_identities<Type>::value && !is_total<Type>::value)
return new LawValidater<InplaceRightDistributivity<Type, inplace_bit_add, inplace_bit_subtract, element_equal> >;
else return new LawValidater<InplaceRightDistributivity<Type, inplace_bit_add, inplace_bit_subtract, std_equal> >;
case inplaceEtDashRightDistrib: return new LawValidater<InplaceRightDistributivity<Type, inplace_bit_and, inplace_bit_subtract> >;
Modified: sandbox/itl/boost/validate/validater/collector_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/collector_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/collector_validater.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -90,11 +90,11 @@
case inplaceSymmetricDifference:return new LawValidater<InplaceSymmetricDifference<Type> >;
case inplaceFlip: return new LawValidater<InplaceFlip<Type> >;
case inplaceEtDistributivity:
- if(itl::is_interval_splitter<Type>::value && absorbs_neutrons<Type>::value && !is_total<Type>::value)
+ if(itl::is_interval_splitter<Type>::value && absorbs_identities<Type>::value && !is_total<Type>::value)
return new LawValidater<InplaceDistributivity<Type, inplace_et, inplace_plus, element_equal> >;
else return new LawValidater<InplaceDistributivity<Type, inplace_et, inplace_plus, std_equal> >;
case inplacePlusDashRightDistrib:
- if(itl::is_interval_splitter<Type>::value && absorbs_neutrons<Type>::value && !is_total<Type>::value)
+ if(itl::is_interval_splitter<Type>::value && absorbs_identities<Type>::value && !is_total<Type>::value)
return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, element_equal> >;
else return new LawValidater<InplaceRightDistributivity<Type, inplace_plus, inplace_minus, std_equal> >;
case inplaceEtDashRightDistrib: return new LawValidater<InplaceRightDistributivity<Type, inplace_et, inplace_minus> >;
Modified: sandbox/itl/boost/validate/validater/interval_morphic_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/interval_morphic_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/interval_morphic_validater.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -89,7 +89,7 @@
case cluster_erase: return new LawValidater<BinaryPushout<typename Type::atomized_type, Type, segmental::clusterer, inplace_erase>, RandomGentor>();
case join_plus: return new LawValidater<BinaryPushout<Type, typename Type::joint_type, segmental::joiner, 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::partial_absorber_type, segmental::neutron_absorber, inplace_plus>, RandomGentor>();
+ //case absorb_plus: return new LawValidater<BinaryPushout<Type, typename Type::partial_absorber_type, segmental::identity_absorber, 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/boost/validate/validater/signed_quantifier_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/signed_quantifier_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/signed_quantifier_validater.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/itl/functors.hpp>
#include <boost/itl/type_traits/is_interval_splitter.hpp>
-#include <boost/itl/type_traits/absorbs_neutrons.hpp>
+#include <boost/itl/type_traits/absorbs_identities.hpp>
#include <boost/itl/type_traits/is_total.hpp>
#include <boost/validate/laws/monoid.hpp>
#include <boost/validate/laws/inversion_laws.hpp>
@@ -62,7 +62,7 @@
_lawChoice.setMaxWeights(sum_of_shares);
//NOTE: Associativity is not valid for partial_absorber signed quantifier maps
- if(!is_total<Type>::value && absorbs_neutrons<Type>::value)
+ if(!is_total<Type>::value && absorbs_identities<Type>::value)
et_assoc_share = 0;
//NOTE: An Inverse exists only for a total signed quantifier
if(!is_total<Type>::value || !has_inverse<typename Type::codomain_type>::value)
@@ -97,24 +97,24 @@
case inplacePlusNeutrality: return new LawValidater<InplaceNeutrality <Type> >;
case inplacePlusCommutativity: return new LawValidater<InplaceCommutativity<Type> >;
case inplaceEtAssociativity:
- if(absorbs_neutrons<Type>::value && is_total<Type>::value)
+ if(absorbs_identities<Type>::value && is_total<Type>::value)
return new LawValidater<InplaceAssociativity<Type, inplace_et, element_equal> >;
else return new LawValidater<InplaceAssociativity<Type, inplace_et> >;
case inplaceEtCommutativity: return new LawValidater<InplaceCommutativity<Type, inplace_et> >;
case inplaceNaturalInversion:
- if(absorbs_neutrons<Type>::value)
+ if(absorbs_identities<Type>::value)
return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, std_equal> >;
- else return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, protonic_equal> >;
+ else return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, distinct_equal> >;
case inplaceSymmetricDifference:return new LawValidater<InplaceSymmetricDifference<Type> >;
case inplaceFlip: return new LawValidater<InplaceFlip<Type> >;
case sectionAbsorbtion:
- if(absorbs_neutrons<Type>::value)
+ if(absorbs_identities<Type>::value)
return new LawValidater<SectionAbsorbtion<Type,std_equal> >;
- else return new LawValidater<SectionAbsorbtion<Type,protonic_equal> >;
+ else return new LawValidater<SectionAbsorbtion<Type,distinct_equal> >;
case inplaceInverseExistence:
- if(absorbs_neutrons<Type>::value)
+ if(absorbs_identities<Type>::value)
return new LawValidater<InplaceInverseExistence<Type, inplace_plus, std_equal> >;
- else return new LawValidater<InplaceInverseExistence<Type, inplace_plus, protonic_equal> >;
+ else return new LawValidater<InplaceInverseExistence<Type, inplace_plus, distinct_equal> >;
default: return NULL;
}
}
Modified: sandbox/itl/boost/validate/validater/unsigned_quantifier_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/unsigned_quantifier_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/unsigned_quantifier_validater.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -11,7 +11,7 @@
#define BOOST_ITL_VALIDATE_VALIDATER_UNSIGNED_QUANTIFIER_VALIDATER_HPP_JOFA_090314
#include <boost/itl/functors.hpp>
-#include <boost/itl/type_traits/absorbs_neutrons.hpp>
+#include <boost/itl/type_traits/absorbs_identities.hpp>
#include <boost/itl/type_traits/is_total.hpp>
#include <boost/validate/laws/monoid.hpp>
#include <boost/validate/laws/map_laws.hpp>
@@ -75,13 +75,13 @@
case inplaceEtAssociativity: return new LawValidater<InplaceAssociativity<Type, inplace_et> >;
case inplaceEtCommutativity: return new LawValidater<InplaceCommutativity<Type, inplace_et> >;
case inplaceNaturalInversion:
- if(absorbs_neutrons<Type>::value)
+ if(absorbs_identities<Type>::value)
return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, std_equal> >;
- else return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, protonic_equal> >;
+ else return new LawValidater<InplaceNaturalInversion<Type, inplace_plus, distinct_equal> >;
case sectionAbsorbtion:
- if(absorbs_neutrons<Type>::value)
+ if(absorbs_identities<Type>::value)
return new LawValidater<SectionAbsorbtion<Type,std_equal> >;
- else return new LawValidater<SectionAbsorbtion<Type,protonic_equal> >;
+ else return new LawValidater<SectionAbsorbtion<Type,distinct_equal> >;
default: return NULL;
}
}
Modified: sandbox/itl/libs/itl/test/test_icl_quantifier_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_icl_quantifier_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_icl_quantifier_shared.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -216,8 +216,8 @@
CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(map_a, map_b, map_c, map_pair_a, map_pair_b);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(map_a, map_b, map_c, map_pair_a, map_pair_b);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_protonic_equal, map_a, map_b, map_c, map_pair_a, map_pair_b);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_protonic_equal, map_a, map_b, map_c, map_pair_a, map_pair_b);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_distinct_equal, map_a, map_b, map_c, map_pair_a, map_pair_b);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_distinct_equal, map_a, map_b, map_c, map_pair_a, map_pair_b);
}
@@ -275,8 +275,8 @@
CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair_a, map_pair_b);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair_a, map_pair_b);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_protonic_equal, map_a, map_b, map_c, map_pair_a, map_pair_b);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_protonic_equal, map_a, map_b, map_c, map_pair_a, map_pair_b);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_distinct_equal, map_a, map_b, map_c, map_pair_a, map_pair_b);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_distinct_equal, map_a, map_b, map_c, map_pair_a, map_pair_b);
}
//------------------------------------------------------------------------------
Modified: sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -184,8 +184,8 @@
CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(map_a, map_b, map_c, val_pair, map_pair);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(map_a, map_b, map_c, val_pair, map_pair);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_protonic_equal, map_a, map_b, map_c, val_pair, map_pair);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_protonic_equal, map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_distinct_equal, map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_distinct_equal, map_a, map_b, map_c, val_pair, map_pair);
}
@@ -241,8 +241,8 @@
CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_protonic_equal, map_a, map_b, map_c, val_pair, map_pair);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_protonic_equal, map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_distinct_equal, map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_distinct_equal, map_a, map_b, map_c, val_pair, map_pair);
}
Modified: sandbox/itl/libs/itl/test/test_interval_set_laws_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_laws_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_laws_shared.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -162,8 +162,8 @@
CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(set_a, set_b, set_c, segm, elem);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(set_a, set_b, set_c, segm, elem);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_protonic_equal, set_a, set_b, set_c, segm, elem);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_protonic_equal, set_a, set_b, set_c, segm, elem);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_distinct_equal, set_a, set_b, set_c, segm, elem);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_distinct_equal, set_a, set_b, set_c, segm, elem);
}
@@ -218,8 +218,8 @@
CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (set_a, set_b, set_c, segm, elem);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, segm, elem);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_protonic_equal, set_a, set_b, set_c, segm, elem);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_protonic_equal, set_a, set_b, set_c, segm, elem);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_distinct_equal, set_a, set_b, set_c, segm, elem);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_distinct_equal, set_a, set_b, set_c, segm, elem);
}
#endif // __test_itl_interval_set_laws_shared_h_JOFA_090201__
Modified: sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp (original)
+++ sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -216,8 +216,8 @@
CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(map_a, map_b, map_c, map_pair1, map_pair2);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(map_a, map_b, map_c, map_pair1, map_pair2);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_protonic_equal, map_a, map_b, map_c, map_pair1, map_pair2);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_protonic_equal, map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_distinct_equal, map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_distinct_equal, map_a, map_b, map_c, map_pair1, map_pair2);
}
@@ -290,8 +290,8 @@
CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair1, map_pair2);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair1, map_pair2);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_protonic_equal, map_a, map_b, map_c, map_pair1, map_pair2);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_protonic_equal, map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_distinct_equal, map_a, map_b, map_c, map_pair1, map_pair2);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_distinct_equal, map_a, map_b, map_c, map_pair1, map_pair2);
}
#endif // __test_itl_quantifier_itl_map_h_JOFA_090119__
Modified: sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp 2010-10-08 06:56:31 EDT (Fri, 08 Oct 2010)
@@ -180,8 +180,8 @@
CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(map_a, map_b, map_c, val_pair, map_pair);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(map_a, map_b, map_c, val_pair, map_pair);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_protonic_equal, map_a, map_b, map_c, val_pair, map_pair);
- CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_protonic_equal, map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(plus)(is_distinct_equal, map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(pipe)(is_distinct_equal, map_a, map_b, map_c, val_pair, map_pair);
}
@@ -242,8 +242,8 @@
CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_protonic_equal, map_a, map_b, map_c, val_pair, map_pair);
- CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_protonic_equal, map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(plus) (is_distinct_equal, map_a, map_b, map_c, val_pair, map_pair);
+ CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_distinct_equal, map_a, map_b, map_c, val_pair, map_pair);
}
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