Subject: [Boost-commit] svn:boost r65827 - in sandbox/itl: boost/itl boost/itl/concept boost/itl/detail boost/itl/type_traits boost/itl_xt boost/itl_xt/detail boost/validate/laws boost/validate/std/algorithm libs/itl/test
From: afojgo_at_[hidden]
Date: 2010-10-08 07:43:33
Author: jofaber
Date: 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
New Revision: 65827
URL: http://svn.boost.org/trac/boost/changeset/65827
Log:
Refactoring: Renaming unon, neutron etc. 5. Renaming core identifiers. Full test. Stable{msvc-9.0,10.0, gcc-3.4.4}
Text files modified:
sandbox/itl/boost/itl/closed_interval.hpp | 2
sandbox/itl/boost/itl/concept/element_associator.hpp | 4
sandbox/itl/boost/itl/concept/element_map.hpp | 10 +-
sandbox/itl/boost/itl/concept/interval.hpp | 56 +++++++-------
sandbox/itl/boost/itl/concept/interval_associator.hpp | 8 +-
sandbox/itl/boost/itl/concept/interval_map.hpp | 4
sandbox/itl/boost/itl/continuous_interval.hpp | 2
sandbox/itl/boost/itl/detail/element_comparer.hpp | 2
sandbox/itl/boost/itl/detail/element_iterator.hpp | 10 +-
sandbox/itl/boost/itl/detail/interval_map_algo.hpp | 2
sandbox/itl/boost/itl/detail/interval_set_algo.hpp | 2
sandbox/itl/boost/itl/detail/interval_subset_comparer.hpp | 2
sandbox/itl/boost/itl/detail/map_algo.hpp | 4
sandbox/itl/boost/itl/detail/on_absorbtion.hpp | 2
sandbox/itl/boost/itl/detail/subset_comparer.hpp | 2
sandbox/itl/boost/itl/discrete_interval.hpp | 2
sandbox/itl/boost/itl/functors.hpp | 32 ++++----
sandbox/itl/boost/itl/gregorian.hpp | 6
sandbox/itl/boost/itl/interval.hpp | 28 +++---
sandbox/itl/boost/itl/interval_base_map.hpp | 10 +-
sandbox/itl/boost/itl/leftopen_interval.hpp | 2
sandbox/itl/boost/itl/map.hpp | 10 +-
sandbox/itl/boost/itl/open_interval.hpp | 2
sandbox/itl/boost/itl/predicates.hpp | 4
sandbox/itl/boost/itl/ptime.hpp | 6
sandbox/itl/boost/itl/rightopen_interval.hpp | 2
sandbox/itl/boost/itl/type_traits/given.hpp | 8 +-
sandbox/itl/boost/itl/type_traits/infinity.hpp | 2
sandbox/itl/boost/itl/type_traits/neutron.hpp | 6
sandbox/itl/boost/itl/type_traits/unon.hpp | 16 ++--
sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp | 16 ++--
sandbox/itl/boost/itl_xt/numbergentor.hpp | 4
sandbox/itl/boost/validate/laws/inversion_laws.hpp | 6
sandbox/itl/boost/validate/laws/monoid.hpp | 4
sandbox/itl/boost/validate/std/algorithm/copy.hpp | 8 +-
sandbox/itl/boost/validate/std/algorithm/find.hpp | 24 +++---
sandbox/itl/libs/itl/test/test_functions.hpp | 2
sandbox/itl/libs/itl/test/test_icl_continuous_interval.hpp | 4
sandbox/itl/libs/itl/test/test_icl_dynamic_interval.hpp | 14 +-
sandbox/itl/libs/itl/test/test_icl_interval.hpp | 18 ++--
sandbox/itl/libs/itl/test/test_icl_static_interval.hpp | 4
sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp | 14 +-
sandbox/itl/libs/itl/test/test_interval_map_shared.hpp | 32 ++++----
sandbox/itl/libs/itl/test/test_interval_set_mixed.hpp | 8 +-
sandbox/itl/libs/itl/test/test_interval_set_shared.hpp | 24 +++---
sandbox/itl/libs/itl/test/test_itl_interval.hpp | 32 ++++----
sandbox/itl/libs/itl/test/test_itl_interval_shared.hpp | 22 ++--
sandbox/itl/libs/itl/test/test_laws.hpp | 154 +++++++++++++++++++-------------------
sandbox/itl/libs/itl/test/test_value_maker.hpp | 10 +-
49 files changed, 324 insertions(+), 324 deletions(-)
Modified: sandbox/itl/boost/itl/closed_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/closed_interval.hpp (original)
+++ sandbox/itl/boost/itl/closed_interval.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -29,7 +29,7 @@
//==========================================================================
/** Default constructor; yields an empty interval <tt>[0,0)</tt>. */
closed_interval()
- : _lwb(unon<DomainT>::value()), _upb(neutron<DomainT>::value())
+ : _lwb(unit_element<DomainT>::value()), _upb(identity_element<DomainT>::value())
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
Modified: sandbox/itl/boost/itl/concept/element_associator.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/element_associator.hpp (original)
+++ sandbox/itl/boost/itl/concept/element_associator.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -295,9 +295,9 @@
if(it_ != object.end())
{
object.erase(it_);
- return unon<size_type>::value();
+ return unit_element<size_type>::value();
}
- return neutron<size_type>::value();
+ return identity_element<size_type>::value();
}
template<class Type>
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 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -106,16 +106,16 @@
typedef typename Type::on_identity_absorbtion on_identity_absorbtion;
if(on_identity_absorbtion::is_absorbable(value_pair.second))
- return neutron<size_type>::value();
+ return identity_element<size_type>::value();
iterator it_ = object.find(value_pair.first);
if(it_ != object.end() && value_pair.second == it_->second)
{
object.erase(it_);
- return unon<size_type>::value();
+ return unit_element<size_type>::value();
}
- return neutron<size_type>::value();
+ return identity_element<size_type>::value();
}
template<class Type>
@@ -401,7 +401,7 @@
itl::flip(object, *it_);
ITL_FORALL(typename Type, it2_, object)
- it2_->second = neutron<typename Type::codomain_type>::value();
+ it2_->second = identity_element<typename Type::codomain_type>::value();
return object;
}
@@ -456,7 +456,7 @@
absorb_identities(Type& object)
{
typedef typename Type::element_type element_type;
- return itl::erase_if(content_is_neutron<element_type>(), object);
+ return itl::erase_if(content_is_identity_element<element_type>(), object);
}
template<class Type>
Modified: sandbox/itl/boost/itl/concept/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/interval.hpp (original)
+++ sandbox/itl/boost/itl/concept/interval.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -16,8 +16,8 @@
#include <boost/detail/is_incrementable.hpp>
#include <boost/itl/detail/design_config.hpp>
#include <boost/itl/type_traits/given.hpp>
-#include <boost/itl/type_traits/unon.hpp>
-#include <boost/itl/type_traits/neutron.hpp>
+#include <boost/itl/type_traits/unit_element.hpp>
+#include <boost/itl/type_traits/identity_element.hpp>
#include <boost/itl/type_traits/infinity.hpp>
#include <boost/itl/type_traits/succ_pred.hpp>
#include <boost/itl/type_traits/is_numeric.hpp>
@@ -856,10 +856,10 @@
{
typedef typename size_type_of<interval_traits<Type> >::type SizeT;
if(itl::is_empty(object))
- return itl::neutron<SizeT>::value();
+ return itl::identity_element<SizeT>::value();
else if( object.bounds() == interval_bounds::closed()
&& domain_equal<Type>(lower(object), upper(object)))
- return itl::unon<SizeT>::value();
+ return itl::unit_element<SizeT>::value();
else
return infinity<SizeT>::value();
}
@@ -870,7 +870,7 @@
cardinality(const Type& object)
{
typedef typename size_type_of<interval_traits<Type> >::type SizeT;
- return itl::is_empty(object) ? neutron<SizeT>::value()
+ return itl::is_empty(object) ? identity_element<SizeT>::value()
: static_cast<SizeT>(last_next(object) - first(object));
}
@@ -881,7 +881,7 @@
{
typedef typename size_type_of<interval_traits<Type> >::type SizeT;
if(itl::is_empty(object))
- return itl::neutron<SizeT>::value();
+ return itl::identity_element<SizeT>::value();
else
return infinity<SizeT>::value();
}
@@ -892,7 +892,7 @@
cardinality(const Type& object)
{
typedef typename size_type_of<interval_traits<Type> >::type SizeT;
- return itl::is_empty(object) ? neutron<SizeT>::value()
+ return itl::is_empty(object) ? identity_element<SizeT>::value()
: static_cast<SizeT>(last_next(object) - first(object));
}
@@ -902,7 +902,7 @@
cardinality(const Type& object)
{
typedef typename size_type_of<interval_traits<Type> >::type SizeT;
- return itl::is_empty(object) ? neutron<SizeT>::value()
+ return itl::is_empty(object) ? identity_element<SizeT>::value()
: static_cast<SizeT>(last_next(object) - first(object));
}
@@ -924,7 +924,7 @@
length(const Type& object)
{
typedef typename difference_type_of<interval_traits<Type> >::type DiffT;
- return itl::is_empty(object) ? neutron<DiffT>::value()
+ return itl::is_empty(object) ? identity_element<DiffT>::value()
: upper(object) - lower(object);
}
@@ -934,7 +934,7 @@
length(const Type& object)
{
typedef typename difference_type_of<interval_traits<Type> >::type DiffT;
- return itl::is_empty(object) ? neutron<DiffT>::value()
+ return itl::is_empty(object) ? identity_element<DiffT>::value()
: last_next(object) - first(object);
}
@@ -944,7 +944,7 @@
length(const Type& object)
{
typedef typename difference_type_of<interval_traits<Type> >::type DiffT;
- return itl::is_empty(object) ? neutron<DiffT>::value()
+ return itl::is_empty(object) ? identity_element<DiffT>::value()
: upper(object) - lower(object);
}
@@ -954,7 +954,7 @@
length(const Type& object)
{
typedef typename difference_type_of<interval_traits<Type> >::type DiffT;
- return itl::is_empty(object) ? neutron<DiffT>::value()
+ return itl::is_empty(object) ? identity_element<DiffT>::value()
: last_next(object) - first(object);
}
@@ -1092,7 +1092,7 @@
if(exclusive_less(left, right_minuend))
return left;
else if(lower_less_equal(right_minuend, left))
- return neutron<Type>::value();
+ return identity_element<Type>::value();
return construct<Type>(lower(left), pred(lower(right_minuend)));
}
@@ -1137,7 +1137,7 @@
typedef typename interval_traits<Type>::domain_compare domain_compare;
if(itl::is_empty(left) || itl::is_empty(right))
- return neutron<Type>::value();
+ return identity_element<Type>::value();
else
return
construct<Type>
@@ -1154,7 +1154,7 @@
typedef typename interval_traits<Type>::domain_compare domain_compare;
if(itl::is_empty(left) || itl::is_empty(right))
- return neutron<Type>::value();
+ return identity_element<Type>::value();
else
return
construct<Type>
@@ -1176,7 +1176,7 @@
operator & (Type left, const Type& right)
{
if(itl::is_empty(left) || itl::is_empty(right))
- return neutron<Type>::value();
+ return identity_element<Type>::value();
else
return dynamic_interval_traits<Type>::construct_bounded
(
@@ -1213,13 +1213,13 @@
inner_complement(const Type& left, const Type& right)
{
if(itl::is_empty(left) || itl::is_empty(right))
- return neutron<Type>::value();
+ return identity_element<Type>::value();
else if(exclusive_less(left, right))
return construct<Type>(upper(left), lower(right));
else if(exclusive_less(right, left))
return construct<Type>(upper(right), lower(left));
else
- return neutron<Type>::value();
+ return identity_element<Type>::value();
}
template<class Type>
@@ -1227,13 +1227,13 @@
inner_complement(const Type& left, const Type& right)
{
if(itl::is_empty(left) || itl::is_empty(right))
- return neutron<Type>::value();
+ return identity_element<Type>::value();
else if(exclusive_less(left, right))
return construct<Type>(succ(upper(left)), pred(lower(right)));
else if(exclusive_less(right, left))
return construct<Type>(succ(upper(right)), pred(lower(left)));
else
- return neutron<Type>::value();
+ return identity_element<Type>::value();
}
template<class Type>
@@ -1241,13 +1241,13 @@
inner_complement(const Type& left, const Type& right)
{
if(itl::is_empty(left) || itl::is_empty(right))
- return neutron<Type>::value();
+ return identity_element<Type>::value();
else if(exclusive_less(left, right))
return construct<Type>(last(left), first(right));
else if(exclusive_less(right, left))
return construct<Type>(last(right), first(left));
else
- return neutron<Type>::value();
+ return identity_element<Type>::value();
}
template<class Type>
@@ -1255,13 +1255,13 @@
inner_complement(const Type& left, const Type& right)
{
if(itl::is_empty(left) || itl::is_empty(right))
- return neutron<Type>::value();
+ return identity_element<Type>::value();
else if(exclusive_less(left, right))
return right_subtract(left_subtract(hull(left, right), left), right);
else if(exclusive_less(right, left))
return right_subtract(left_subtract(hull(right, left), right), left);
else
- return neutron<Type>::value();
+ return identity_element<Type>::value();
}
//==============================================================================
@@ -1279,13 +1279,13 @@
typedef typename difference_type_of<interval_traits<Type> >::type difference_type;
if(itl::is_empty(x1) || itl::is_empty(x2))
- return itl::neutron<difference_type>::value();
+ return itl::identity_element<difference_type>::value();
else if(domain_less<Type>(last(x1), first(x2)))
return static_cast<difference_type>(pred(first(x2) - last(x1)));
else if(domain_less<Type>(last(x2), first(x1)))
return static_cast<difference_type>(pred(first(x1) - last(x2)));
else
- return itl::neutron<difference_type>::value();
+ return itl::identity_element<difference_type>::value();
}
template<class Type>
@@ -1300,13 +1300,13 @@
typedef typename difference_type_of<interval_traits<Type> >::type DiffT;
if(itl::is_empty(x1) || itl::is_empty(x2))
- return itl::neutron<DiffT>::value();
+ return itl::identity_element<DiffT>::value();
else if(domain_less<Type>(upper(x1), lower(x2)))
return x2.lower() - x1.upper();
else if(domain_less<Type>(upper(x2), lower(x1)))
return lower(x1) - upper(x2);
else
- return itl::neutron<DiffT>::value();
+ return itl::identity_element<DiffT>::value();
}
//==============================================================================
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 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -123,7 +123,7 @@
typedef typename Type::size_type size_type;
typedef typename Type::interval_type interval_type;
- size_type size = neutron<size_type>::value();
+ size_type size = identity_element<size_type>::value();
ITL_const_FORALL(typename Type, it, object)
size += itl::cardinality(key_value<Type>(it));
return size;
@@ -141,7 +141,7 @@
typedef typename Type::size_type size_type;
typedef typename Type::interval_type interval_type;
- size_type size = neutron<size_type>::value();
+ size_type size = identity_element<size_type>::value();
size_type interval_size;
ITL_const_FORALL(typename Type, it, object)
{
@@ -167,7 +167,7 @@
{
typedef typename Type::difference_type difference_type;
typedef typename Type::const_iterator const_iterator;
- difference_type length = neutron<difference_type>::value();
+ difference_type length = identity_element<difference_type>::value();
const_iterator it_ = object.begin();
while(it_ != object.end())
@@ -191,7 +191,7 @@
hull(const ObjectT& object)
{
return
- itl::is_empty(object) ? neutron<typename ObjectT::interval_type>::value()
+ itl::is_empty(object) ? identity_element<typename ObjectT::interval_type>::value()
: hull((key_value<ObjectT>(object.begin())), key_value<ObjectT>(object.rbegin()));
}
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 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -506,7 +506,7 @@
object += operand;
ITL_FORALL(typename Type, it_, object)
- it_->second = neutron<codomain_type>::value();
+ it_->second = identity_element<codomain_type>::value();
if(mpl::not_<is_interval_splitter<Type> >::value)
itl::join(object);
@@ -620,7 +620,7 @@
absorb_identities(Type& object)
{
typedef typename Type::segment_type segment_type;
- return itl::erase_if(content_is_neutron<segment_type>(), object);
+ return itl::erase_if(content_is_identity_element<segment_type>(), object);
}
//==============================================================================
Modified: sandbox/itl/boost/itl/continuous_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/continuous_interval.hpp (original)
+++ sandbox/itl/boost/itl/continuous_interval.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -38,7 +38,7 @@
//==========================================================================
/** Default constructor; yields an empty interval <tt>[0,0)</tt>. */
continuous_interval()
- : _lwb(neutron<DomainT>::value()), _upb(neutron<DomainT>::value())
+ : _lwb(identity_element<DomainT>::value()), _upb(identity_element<DomainT>::value())
, _bounds(interval_bounds::right_open())
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
Modified: sandbox/itl/boost/itl/detail/element_comparer.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/element_comparer.hpp (original)
+++ sandbox/itl/boost/itl/detail/element_comparer.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -11,7 +11,7 @@
#include <boost/mpl/and.hpp>
#include <boost/itl/type_traits/is_map.hpp>
#include <boost/itl/detail/notate.hpp>
-#include <boost/itl/type_traits/neutron.hpp>
+#include <boost/itl/type_traits/identity_element.hpp>
namespace boost{namespace itl
{
Modified: sandbox/itl/boost/itl/detail/element_iterator.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/element_iterator.hpp (original)
+++ sandbox/itl/boost/itl/detail/element_iterator.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -268,11 +268,11 @@
public:
element_iterator()
- : _saltator(neutron<segment_iterator>::value())
- , _reptator(neutron<domain_difference_type>::value()){}
+ : _saltator(identity_element<segment_iterator>::value())
+ , _reptator(identity_element<domain_difference_type>::value()){}
explicit element_iterator(segment_iterator jumper)
- : _saltator(jumper), _reptator(neutron<domain_difference_type>::value()) {}
+ : _saltator(jumper), _reptator(identity_element<domain_difference_type>::value()) {}
template <class SaltatorT>
element_iterator
@@ -298,13 +298,13 @@
else
{
++_saltator;
- _reptator = neutron<domain_difference_type>::value();
+ _reptator = identity_element<domain_difference_type>::value();
}
}
void decrement()
{
- if(neutron<domain_difference_type>::value() < _reptator)
+ if(identity_element<domain_difference_type>::value() < _reptator)
--_reptator;
else
{
Modified: sandbox/itl/boost/itl/detail/interval_map_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/interval_map_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/interval_map_algo.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -15,7 +15,7 @@
#include <boost/itl/type_traits/is_map.hpp>
#include <boost/itl/detail/notate.hpp>
#include <boost/itl/detail/relation_state.hpp>
-#include <boost/itl/type_traits/neutron.hpp>
+#include <boost/itl/type_traits/identity_element.hpp>
#include <boost/itl/interval_combining_style.hpp>
#include <boost/itl/detail/element_comparer.hpp>
#include <boost/itl/detail/interval_subset_comparer.hpp>
Modified: sandbox/itl/boost/itl/detail/interval_set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/interval_set_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/interval_set_algo.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -10,7 +10,7 @@
#include <boost/itl/detail/notate.hpp>
#include <boost/itl/detail/relation_state.hpp>
-#include <boost/itl/type_traits/neutron.hpp>
+#include <boost/itl/type_traits/identity_element.hpp>
#include <boost/itl/type_traits/is_map.hpp>
#include <boost/itl/type_traits/is_total.hpp>
#include <boost/itl/type_traits/is_combinable.hpp>
Modified: sandbox/itl/boost/itl/detail/interval_subset_comparer.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/interval_subset_comparer.hpp (original)
+++ sandbox/itl/boost/itl/detail/interval_subset_comparer.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -11,7 +11,7 @@
#include <boost/itl/type_traits/is_map.hpp>
#include <boost/itl/detail/notate.hpp>
#include <boost/itl/detail/relation_state.hpp>
-#include <boost/itl/type_traits/neutron.hpp>
+#include <boost/itl/type_traits/identity_element.hpp>
#include <boost/itl/type_traits/is_concept_equivalent.hpp>
#include <boost/itl/type_traits/is_interval_container.hpp>
#include <boost/itl/type_traits/is_set.hpp>
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 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -45,14 +45,14 @@
typename MapT::const_iterator next_proton(typename MapT::const_iterator& iter_, const MapT& object)
{
while( iter_ != object.end()
- && iter_->second == neutron<typename MapT::codomain_type>::value())
+ && iter_->second == identity_element<typename MapT::codomain_type>::value())
++iter_;
return iter_;
}
/** Function template <tt>lexicographical_equal</tt> implements
-lexicographical equality except for neutronic content values. */
+lexicographical equality except for identity_elementic content values. */
template<class MapT>
bool lexicographical_distinct_equal(const MapT& left, const MapT& right)
{
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 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -32,7 +32,7 @@
static bool is_absorbable(const codomain_type& co_value)
{
- return co_value == Combiner::neutron();
+ return co_value == Combiner::identity_element();
}
};
Modified: sandbox/itl/boost/itl/detail/subset_comparer.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/subset_comparer.hpp (original)
+++ sandbox/itl/boost/itl/detail/subset_comparer.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -12,7 +12,7 @@
#include <boost/itl/type_traits/is_map.hpp>
#include <boost/itl/detail/notate.hpp>
#include <boost/itl/detail/relation_state.hpp>
-#include <boost/itl/type_traits/neutron.hpp>
+#include <boost/itl/type_traits/identity_element.hpp>
#include <boost/itl/type_traits/codomain_type_of.hpp>
#include <boost/itl/type_traits/is_concept_equivalent.hpp>
#include <boost/itl/type_traits/is_element_container.hpp>
Modified: sandbox/itl/boost/itl/discrete_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/discrete_interval.hpp (original)
+++ sandbox/itl/boost/itl/discrete_interval.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -37,7 +37,7 @@
//==========================================================================
/** Default constructor; yields an empty interval <tt>[0,0)</tt>. */
discrete_interval()
- : _lwb(neutron<DomainT>::value()), _upb(neutron<DomainT>::value())
+ : _lwb(identity_element<DomainT>::value()), _upb(identity_element<DomainT>::value())
, _bounds(interval_bounds::right_open())
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
Modified: sandbox/itl/boost/itl/functors.hpp
==============================================================================
--- sandbox/itl/boost/itl/functors.hpp (original)
+++ sandbox/itl/boost/itl/functors.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -11,8 +11,8 @@
#include <functional>
#include <boost/type_traits.hpp>
#include <boost/mpl/if.hpp>
-#include <boost/itl/type_traits/neutron.hpp>
-#include <boost/itl/type_traits/unon.hpp>
+#include <boost/itl/type_traits/identity_element.hpp>
+#include <boost/itl/type_traits/unit_element.hpp>
#include <boost/itl/type_traits/is_set.hpp>
#include <boost/itl/type_traits/has_set_semantics.hpp>
@@ -22,14 +22,14 @@
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(); }
+ static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
};
// ------------------------------------------------------------------------
- template <typename Type> struct unon_based_inplace_combine
+ template <typename Type> struct unit_element_based_inplace_combine
: public std::binary_function<Type&, const Type&, void>
{
- static Type neutron() { return boost::itl::unon<Type>::value(); }
+ static Type identity_element() { return boost::itl::unit_element<Type>::value(); }
};
// ------------------------------------------------------------------------
@@ -113,7 +113,7 @@
void operator()(Type& object, const Type& operand)const
{ object &= ~operand; }
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
};
template<>
@@ -141,7 +141,7 @@
void operator()(Type& object, const Type& operand)const
{ object ^= operand; }
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
};
// ------------------------------------------------------------------------
@@ -166,7 +166,7 @@
void operator()(Type& object, const Type& operand)const
{ object ^= operand; }
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
};
template<>
@@ -181,7 +181,7 @@
void operator()(Type& object, const Type& operand)const
{ insert(object,operand); }
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
};
template<>
@@ -196,7 +196,7 @@
void operator()(Type& object, const Type& operand)const
{ erase(object,operand); }
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
};
template<>
@@ -211,7 +211,7 @@
void operator()(Type& object, const Type& operand)const
{ object *= operand; }
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
};
template<>
@@ -226,7 +226,7 @@
void operator()(Type& object, const Type& operand)const
{ object /= operand; }
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
};
template<>
@@ -244,7 +244,7 @@
object = operand;
}
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
};
template<>
@@ -262,7 +262,7 @@
object = operand;
}
- static Type neutron() { return boost::itl::neutron<Type>::value(); }
+ static Type identity_element() { return boost::itl::identity_element<Type>::value(); }
};
template<>
@@ -374,7 +374,7 @@
// equivalent to
//
// T x = ..., y;
- // y = Functor::neutron();
+ // y = Functor::identity_element();
// Functor()(y, x); // y == inverse_of(x)
template<class Functor> struct is_negative;
@@ -429,7 +429,7 @@
// Example -= : (0 -= x) == -x
static argument_type inversion(const argument_type& value)
{
- argument_type inverse = Combiner::neutron();
+ argument_type inverse = Combiner::identity_element();
Combiner()(inverse, value);
return inverse;
}
Modified: sandbox/itl/boost/itl/gregorian.hpp
==============================================================================
--- sandbox/itl/boost/itl/gregorian.hpp (original)
+++ sandbox/itl/boost/itl/gregorian.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -24,7 +24,7 @@
#pragma warning(pop)
#endif
-#include <boost/itl/type_traits/neutron.hpp>
+#include <boost/itl/type_traits/identity_element.hpp>
#include <boost/itl/type_traits/is_discrete.hpp>
#include <boost/itl/type_traits/difference_type_of.hpp>
#include <boost/itl/type_traits/size_type_of.hpp>
@@ -38,13 +38,13 @@
};
template<>
- inline boost::gregorian::date neutron<boost::gregorian::date>::value()
+ inline boost::gregorian::date identity_element<boost::gregorian::date>::value()
{
return boost::gregorian::date(boost::gregorian::min_date_time);
}
template<>
- struct neutron<boost::gregorian::date_duration>
+ struct identity_element<boost::gregorian::date_duration>
{
static boost::gregorian::date_duration value()
{
Modified: sandbox/itl/boost/itl/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval.hpp (original)
+++ sandbox/itl/boost/itl/interval.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -24,8 +24,8 @@
#include <boost/itl/detail/notate.hpp>
#include <boost/itl/detail/design_config.hpp>
#include <boost/itl/detail/exclusive_less_than.hpp>
-#include <boost/itl/type_traits/neutron.hpp>
-#include <boost/itl/type_traits/unon.hpp>
+#include <boost/itl/type_traits/identity_element.hpp>
+#include <boost/itl/type_traits/unit_element.hpp>
#include <boost/itl/type_traits/infinity.hpp>
#include <boost/itl/type_traits/is_continuous.hpp>
#include <boost/itl/type_traits/difference_type_of.hpp>
@@ -147,7 +147,7 @@
//= Construct, copy, destruct
//==========================================================================
/** Default constructor; yields an empty interval <tt>[1,0]</tt> */
- interval() : _lwb(unon<DomainT>::value()), _upb(neutron<DomainT>::value()),
+ interval() : _lwb(unit_element<DomainT>::value()), _upb(identity_element<DomainT>::value()),
_boundtype(itl::closed_bounded)
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
@@ -198,7 +198,7 @@
/** Set the interval empty */
void clear()
- { set_lwb(unon<DomainT>::value()); set_upb(neutron<DomainT>::value());
+ { set_lwb(unit_element<DomainT>::value()); set_upb(identity_element<DomainT>::value());
_boundtype=itl::closed_bounded; }
/** Does the interval contain <tt>x</tt>? */
@@ -516,9 +516,9 @@
{
typedef typename IntervalT::size_type SizeT;
if(itl::is_empty(x))
- return itl::neutron<SizeT>::value();
+ return itl::identity_element<SizeT>::value();
else if(x.is(itl::closed_bounded) && IntervalT::domain_equal(x.lower(), x.upper()))
- return itl::unon<SizeT>::value();
+ return itl::unit_element<SizeT>::value();
else
return infinity<SizeT>::value();
}
@@ -526,7 +526,7 @@
static typename IntervalT::difference_type
length(const IntervalT& x)
{
- return x.empty() ? itl::neutron<typename IntervalT::difference_type>::value()
+ return x.empty() ? itl::identity_element<typename IntervalT::difference_type>::value()
: x.upper() - x.lower();
}
@@ -534,13 +534,13 @@
distance(const IntervalT& x1, const IntervalT& x2)
{
if(x1.empty() || x2.empty())
- return itl::neutron<typename IntervalT::difference_type>::value();
+ return itl::identity_element<typename IntervalT::difference_type>::value();
else if(IntervalT::domain_less(x1.upper(), x2.lower()))
return x2.lower() - x1.upper();
else if(IntervalT::domain_less(x2.upper(), x1.lower()))
return x1.lower() - x2.upper();
else
- return itl::neutron<typename IntervalT::difference_type>::value();
+ return itl::identity_element<typename IntervalT::difference_type>::value();
}
static bool unaligned_lwb_equal(const IntervalT&, const IntervalT&)
@@ -561,13 +561,13 @@
static typename IntervalT::size_type
cardinality(const IntervalT& x)
{
- return itl::is_empty(x)? itl::neutron<typename IntervalT::size_type>::value()
+ return itl::is_empty(x)? itl::identity_element<typename IntervalT::size_type>::value()
: static_cast<typename IntervalT::size_type>(succ(last(x) - first(x)));
}
static typename IntervalT::difference_type length(const IntervalT& x)
{
- return itl::is_empty(x) ? itl::neutron<typename IntervalT::difference_type>::value()
+ return itl::is_empty(x) ? itl::identity_element<typename IntervalT::difference_type>::value()
: static_cast<typename IntervalT::difference_type>(succ(last(x) - first(x)));
}
@@ -575,13 +575,13 @@
distance(const IntervalT& x1, const IntervalT& x2)
{
if(itl::is_empty(x1) || itl::is_empty(x2))
- return itl::neutron<typename IntervalT::difference_type>::value();
+ return itl::identity_element<typename IntervalT::difference_type>::value();
else if(IntervalT::domain_less(x1.last(), x2.first()))
return static_cast<typename IntervalT::difference_type>(pred(x2.first() - x1.last()));
else if(IntervalT::domain_less(x2.last(), x1.first()))
return static_cast<typename IntervalT::difference_type>(pred(x1.first() - x2.last()));
else
- return itl::neutron<typename IntervalT::difference_type>::value();
+ return itl::identity_element<typename IntervalT::difference_type>::value();
}
static bool unaligned_lwb_equal(const IntervalT& x1, const IntervalT& x2)
@@ -1086,7 +1086,7 @@
else if(right.exclusive_less(left))
return hull(right, left).left_subtract(right).right_subtract(left);
else
- return neutron<ITL_INTERVAL_TYPE(Interval,DomainT,Compare) >::value();
+ return identity_element<ITL_INTERVAL_TYPE(Interval,DomainT,Compare) >::value();
}
//==============================================================================
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 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -273,7 +273,7 @@
codomain_type operator()(const domain_type& key)const
{
const_iterator it_ = _map.find(interval_type(key));
- return it_==end() ? neutron<codomain_type>::value()
+ return it_==end() ? identity_element<codomain_type>::value()
: it_->second;
}
@@ -539,9 +539,9 @@
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()));
+ = this->_map.insert(prior_, value_type(inter_val, Combiner::identity_element()));
- if(inserted_->first == inter_val && inserted_->second == Combiner::neutron())
+ if(inserted_->first == inter_val && inserted_->second == Combiner::identity_element())
{
Combiner()(inserted_->second, co_val);
return std::pair<iterator,bool>(inserted_, true);
@@ -663,7 +663,7 @@
{
intersection.template
_add<codomain_combine>(segment_type(common_interval,
- neutron<codomain_type>::value()));
+ identity_element<codomain_type>::value()));
}
};
@@ -693,7 +693,7 @@
{
object += operand;
ITL_FORALL(typename Type, it_, object)
- it_->second = neutron<codomain_type>::value();
+ it_->second = identity_element<codomain_type>::value();
if(mpl::not_<is_interval_splitter<Type> >::value)
itl::join(object);
Modified: sandbox/itl/boost/itl/leftopen_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/leftopen_interval.hpp (original)
+++ sandbox/itl/boost/itl/leftopen_interval.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -31,7 +31,7 @@
//==========================================================================
/** Default constructor; yields an empty interval <tt>(0,0]</tt>. */
leftopen_interval()
- : _lwb(neutron<DomainT>::value()), _upb(neutron<DomainT>::value())
+ : _lwb(identity_element<DomainT>::value()), _upb(identity_element<DomainT>::value())
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -248,7 +248,7 @@
codomain_type operator()(const domain_type& key)const
{
const_iterator it = find(key);
- return it==end() ? neutron<codomain_type>::value()
+ return it==end() ? identity_element<codomain_type>::value()
: it->second;
}
@@ -431,7 +431,7 @@
{ // !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(); }
+ { it_->second = identity_element<typename Type::codomain_type>::value(); }
};
template<class Type>
@@ -461,7 +461,7 @@
const typename Type::codomain_type& co_value)
{
inverse_codomain_intersect()(it_->second, co_value);
- if(it_->second == neutron<codomain_type>::value())
+ if(it_->second == identity_element<codomain_type>::value())
object.erase(it_);
}
};
@@ -489,7 +489,7 @@
{
object.add(operand);
ITL_FORALL(typename Type, it_, object)
- it_->second = neutron<codomain_type>::value();
+ it_->second = identity_element<codomain_type>::value();
}
};
@@ -582,7 +582,7 @@
iterator inserted_
= base_type::insert(prior_,
- value_type(addend.first, Combiner::neutron()));
+ value_type(addend.first, Combiner::identity_element()));
Combiner()(inserted_->second, addend.second);
if(on_absorbtion_::is_absorbable(inserted_->second))
Modified: sandbox/itl/boost/itl/open_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/open_interval.hpp (original)
+++ sandbox/itl/boost/itl/open_interval.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -31,7 +31,7 @@
//==========================================================================
/** Default constructor; yields an empty interval <tt>(0,0)</tt>. */
open_interval()
- : _lwb(neutron<DomainT>::value()), _upb(neutron<DomainT>::value())
+ : _lwb(identity_element<DomainT>::value()), _upb(identity_element<DomainT>::value())
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
Modified: sandbox/itl/boost/itl/predicates.hpp
==============================================================================
--- sandbox/itl/boost/itl/predicates.hpp (original)
+++ sandbox/itl/boost/itl/predicates.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -36,13 +36,13 @@
} ;
template <class Type>
- struct is_neutron: public property<Type>
+ struct is_identity_element: public property<Type>
{
bool operator() (const Type& x)const { return x == Type(); }
} ;
template <class Type>
- class content_is_neutron: public property<Type>
+ class content_is_identity_element: public property<Type>
{
public:
bool operator() (const Type& x)const
Modified: sandbox/itl/boost/itl/ptime.hpp
==============================================================================
--- sandbox/itl/boost/itl/ptime.hpp (original)
+++ sandbox/itl/boost/itl/ptime.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -9,7 +9,7 @@
/*------------------------------------------------------------------------------
itl_ptime provides adapter code for boost::posix_time::ptime.
It implements incrementation (++) decrementation (--) and a neutral element
-w.r.t. addition (neutron()).
+w.r.t. addition (identity_element()).
------------------------------------------------------------------------------*/
#ifndef BOOST_ITL_PTIME_HPP_JOFA_080416
@@ -32,7 +32,7 @@
#pragma warning(pop)
#endif
-#include <boost/itl/type_traits/neutron.hpp>
+#include <boost/itl/type_traits/identity_element.hpp>
#include <boost/itl/type_traits/difference_type_of.hpp>
#include <boost/itl/type_traits/size_type_of.hpp>
#include <boost/itl/type_traits/is_discrete.hpp>
@@ -46,7 +46,7 @@
};
template<>
- inline boost::posix_time::ptime neutron<boost::posix_time::ptime>::value()
+ inline boost::posix_time::ptime identity_element<boost::posix_time::ptime>::value()
{
return boost::posix_time::ptime(boost::posix_time::min_date_time);
}
Modified: sandbox/itl/boost/itl/rightopen_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/rightopen_interval.hpp (original)
+++ sandbox/itl/boost/itl/rightopen_interval.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -31,7 +31,7 @@
//==========================================================================
/** Default constructor; yields an empty interval <tt>[0,0)</tt>. */
rightopen_interval()
- : _lwb(neutron<DomainT>::value()), _upb(neutron<DomainT>::value())
+ : _lwb(identity_element<DomainT>::value()), _upb(identity_element<DomainT>::value())
{
BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));
Modified: sandbox/itl/boost/itl/type_traits/given.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/given.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/given.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -8,7 +8,7 @@
#ifndef BOOST_ITL_TYPE_TRAITS_GIVEN_HPP_JOFA_100929
#define BOOST_ITL_TYPE_TRAITS_GIVEN_HPP_JOFA_100929
-#include <boost/itl/type_traits/unon.hpp>
+#include <boost/itl/type_traits/unit_element.hpp>
namespace boost{ namespace itl
{
@@ -16,7 +16,7 @@
template<class Fact, class Type = bool> struct given
{
- static Type then(const Type& success, const Type& fail = unon<Type>::value())
+ static Type then(const Type& success, const Type& fail = unit_element<Type>::value())
{
return given_<Fact::value, Type>::then(success, fail);
}
@@ -26,14 +26,14 @@
template<class Type>
struct given_<false, Type>
{
- static Type then(const Type& success, const Type& fail = unon<Type>::value())
+ static Type then(const Type& success, const Type& fail = unit_element<Type>::value())
{ return fail; }
};
template<class Type>
struct given_<true, Type>
{
- static Type then(const Type& success, const Type& fail = unon<Type>::value())
+ static Type then(const Type& success, const Type& fail = unit_element<Type>::value())
{ return success; }
};
Modified: sandbox/itl/boost/itl/type_traits/infinity.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/infinity.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/infinity.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -48,7 +48,7 @@
return
mpl::if_<is_numeric<Type>,
numeric_infinity<Type>,
- neutron<Type> >::type::value();
+ identity_element<Type> >::type::value();
}
};
Modified: sandbox/itl/boost/itl/type_traits/neutron.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/neutron.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/neutron.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -12,20 +12,20 @@
namespace boost{ namespace itl
{
- template <class Type> struct neutron
+ template <class Type> struct identity_element
{
static Type value();
Type operator()()const { return value(); }
};
template <class Type>
- inline Type neutron<Type>::value()
+ inline Type identity_element<Type>::value()
{
return Type();
}
template<>
- inline std::string unary_template_to_string<neutron>::apply() { return "0"; }
+ inline std::string unary_template_to_string<identity_element>::apply() { return "0"; }
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/unon.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/unon.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/unon.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -9,25 +9,25 @@
#define BOOST_ITL_TYPE_TRAITS_UNON_HPP_JOFA_080912
#include <string>
-#include <boost/itl/type_traits/neutron.hpp>
+#include <boost/itl/type_traits/identity_element.hpp>
#include <boost/itl/type_traits/succ_pred.hpp>
namespace boost{ namespace itl
{
- template <class Type> struct unon{ static Type value(); };
+ template <class Type> struct unit_element{ static Type value(); };
- template<> inline bool unon<bool>::value() { return true; }
- template<> inline float unon<float>::value() { return 1.0; }
- template<> inline double unon<double>::value() { return 1.0; }
- template<> inline long double unon<long double>::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 unon<std::string>::value(){ return std::string(" "); }
+ inline std::string unit_element<std::string>::value(){ return std::string(" "); }
template <class Type>
- inline Type unon<Type>::value(){ return succ(neutron<Type>::value()); }
+ inline Type unit_element<Type>::value(){ return succ(identity_element<Type>::value()); }
}} // namespace boost itl
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 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -76,14 +76,14 @@
public:
bit_element_iterator()
- : _saltator(neutron<segment_iterator>::value())
- , _reptator(neutron<domain_difference_type>::value())
+ : _saltator(identity_element<segment_iterator>::value())
+ , _reptator(identity_element<domain_difference_type>::value())
, _on_bit(before)
{}
bit_element_iterator(segment_iterator jumper, bit_range_type start_pos)
: _saltator(jumper)
- , _reptator(neutron<domain_difference_type>::value())
+ , _reptator(identity_element<domain_difference_type>::value())
, _on_bit(start_pos)
{}
@@ -135,7 +135,7 @@
++_saltator;
// NOTE: increment and dereference are unsecure now, because
// _saltator can (finally) be end here. decrement is secure.
- _reptator = neutron<domain_difference_type>::value();
+ _reptator = identity_element<domain_difference_type>::value();
_on_bit = ante;
}
}
@@ -146,7 +146,7 @@
prev_bit();
if(_on_bit == ante)
{ // The current bitset passed the beginning
- if(neutron<domain_difference_type>::value() < _reptator)
+ if(identity_element<domain_difference_type>::value() < _reptator)
{
--_reptator;
_on_bit = past;
@@ -191,7 +191,7 @@
if(_on_bit == before)
{
++_saltator;
- _reptator = neutron<domain_difference_type>::value();
+ _reptator = identity_element<domain_difference_type>::value();
_on_bit = Proceed::first_bit(_saltator->second.word());
}
else
@@ -217,7 +217,7 @@
bool is_segment_begin()const
{
- return _reptator == neutron<domain_difference_type>::value()
+ return _reptator == identity_element<domain_difference_type>::value()
&& 0 <= _on_bit && _on_bit < digits
&& _on_bit == Proceed::first_bit(_saltator->second.word());
}
@@ -466,7 +466,7 @@
{ return first(inter_val) + reptator; }
static difference_type inter_base(const iterator& iter)
- { return neutron<difference_type>::value(); }
+ { return identity_element<difference_type>::value(); }
static difference_type inter_ceil(const iterator& iter)
{ return iter->first.length(); }
Modified: sandbox/itl/boost/itl_xt/numbergentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/numbergentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/numbergentor.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -15,7 +15,7 @@
#include <stdlib.h>
#include <vector>
#include <boost/validate/type/nat.hpp>
-#include <boost/itl/type_traits/unon.hpp>
+#include <boost/itl/type_traits/unit_element.hpp>
#include <boost/itl_xt/gentorit.hpp>
using namespace boost::itl;
@@ -64,7 +64,7 @@
{
public:
NumberGentorT():
- m_valueRange( NumTV(), unon<NumTV>::value(), right_open ) {}
+ m_valueRange( NumTV(), unit_element<NumTV>::value(), right_open ) {}
NumTV operator() (NumTV upb) { return rnd_0_to_excl<NumTV>(upb); }
NumTV operator() (NumTV lwb, NumTV upb) { return rnd_within_exUpb<NumTV>(lwb,upb); }
Modified: sandbox/itl/boost/validate/laws/inversion_laws.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/inversion_laws.hpp (original)
+++ sandbox/itl/boost/validate/laws/inversion_laws.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -50,7 +50,7 @@
Type lhs = this->template getInputValue<operand_a>();
InverseCombinerT()(lhs, this->template getInputValue<operand_a>());
- Type rhs = Combiner<Type>::neutron();
+ Type rhs = Combiner<Type>::identity_element();
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
@@ -97,14 +97,14 @@
bool holds()
{
- Type lhs = Combiner<Type>::neutron();
+ Type lhs = Combiner<Type>::identity_element();
Type value_a = this->template getInputValue<operand_a>();
// lhs = (0 - a)
InverseCombinerT()(lhs, value_a);
// lhs = (0 - a) + a
Combiner<Type>()(lhs, value_a);
- Type rhs = Combiner<Type>::neutron();
+ Type rhs = Combiner<Type>::identity_element();
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
Modified: sandbox/itl/boost/validate/laws/monoid.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/monoid.hpp (original)
+++ sandbox/itl/boost/validate/laws/monoid.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -159,7 +159,7 @@
// ---------------------------------------------------------------------------
// Inplace variant of laws for operator o=
// ---------------------------------------------------------------------------
- template <typename Type, template<class>class Accumulator = inplace_plus, template<class>class IdentityElement = neutron>
+ template <typename Type, template<class>class Accumulator = inplace_plus, template<class>class IdentityElement = identity_element>
class InplaceNeutrality
: public Law<InplaceNeutrality<Type,Accumulator,IdentityElement>,
LOKI_TYPELIST_1(Type), LOKI_TYPELIST_1(Type)>
@@ -185,7 +185,7 @@
bool holds()
{
Type lhs = this->template getInputValue<operand_a>();
- Accumulator<Type>()(lhs, neutron<Type>()());
+ Accumulator<Type>()(lhs, identity_element<Type>()());
this->template setOutputValue<lhs_result>(lhs);
return lhs == this->template getInputValue<operand_a>();
}
Modified: sandbox/itl/boost/validate/std/algorithm/copy.hpp
==============================================================================
--- sandbox/itl/boost/validate/std/algorithm/copy.hpp (original)
+++ sandbox/itl/boost/validate/std/algorithm/copy.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -110,13 +110,13 @@
void operator()(const AtomicT& source, TargetT& target)
{
- fill_n(InsertIterator<TargetT>(target, target.end()), source.size(), neutron<value_type>::value());
+ fill_n(InsertIterator<TargetT>(target, target.end()), source.size(), identity_element<value_type>::value());
std::copy_backward(source.begin(), source.end(), target.end());
}
void operator()(const SourceT& source, TargetT& target)
{
- fill_n(InsertIterator<TargetT>(target, target.end()), source.size(), neutron<value_type>::value());
+ fill_n(InsertIterator<TargetT>(target, target.end()), source.size(), identity_element<value_type>::value());
std::copy_backward(elements_begin(source), elements_end(source), target.end());
}
@@ -131,13 +131,13 @@
void operator()(const AtomicT& source, TargetT& target)
{
- fill_n(InsertIterator<TargetT>(target, target.end()), source.size(), neutron<value_type>::value());
+ fill_n(InsertIterator<TargetT>(target, target.end()), source.size(), identity_element<value_type>::value());
std::copy_backward(source.rbegin(), source.rend(), target.end());
}
void operator()(const SourceT& source, TargetT& target)
{
- fill_n(InsertIterator<TargetT>(target, target.end()), source.size(), neutron<value_type>::value());
+ fill_n(InsertIterator<TargetT>(target, target.end()), source.size(), identity_element<value_type>::value());
std::copy_backward(elements_rbegin(source), elements_rend(source), target.end());
}
Modified: sandbox/itl/boost/validate/std/algorithm/find.hpp
==============================================================================
--- sandbox/itl/boost/validate/std/algorithm/find.hpp (original)
+++ sandbox/itl/boost/validate/std/algorithm/find.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -34,7 +34,7 @@
typename AtomicT::const_iterator found
= std::find(source.begin(), source.end(), _comparand);
if(found == source.end())
- return neutron<TargetT>::value();
+ return identity_element<TargetT>::value();
else
return *found;
}
@@ -44,7 +44,7 @@
typename SegmentalT::element_const_iterator found
= std::find(elements_begin(source), elements_end(source), _comparand);
if(found == elements_end(source))
- return neutron<TargetT>::value();
+ return identity_element<TargetT>::value();
else
return *found;
}
@@ -73,7 +73,7 @@
typename AtomicT::const_reverse_iterator found
= std::find(source.rbegin(), source.rend(), _comparand);
if(found == source.rend())
- return neutron<TargetT>::value();
+ return identity_element<TargetT>::value();
else
return *found;
}
@@ -83,7 +83,7 @@
typename SegmentalT::element_const_reverse_iterator found
= std::find(elements_rbegin(source), elements_rend(source), _comparand);
if(found == elements_rend(source))
- return neutron<TargetT>::value();
+ return identity_element<TargetT>::value();
else
return *found;
}
@@ -114,7 +114,7 @@
typename AtomicT::const_iterator found
= std::lower_bound(source.begin(), source.end(), _comparand);
if(found == source.end())
- return neutron<TargetT>::value();
+ return identity_element<TargetT>::value();
else
return *found;
}
@@ -124,7 +124,7 @@
typename SegmentalT::element_const_iterator found
= std::lower_bound(elements_begin(source), elements_end(source), _comparand);
if(found == elements_end(source))
- return neutron<TargetT>::value();
+ return identity_element<TargetT>::value();
else
return *found;
}
@@ -153,7 +153,7 @@
typename AtomicT::const_reverse_iterator found
= std::lower_bound(source.rbegin(), source.rend(), _comparand);
if(found == source.rend())
- return neutron<TargetT>::value();
+ return identity_element<TargetT>::value();
else
return *found;
}
@@ -163,7 +163,7 @@
typename SegmentalT::element_const_reverse_iterator found
= std::lower_bound(elements_rbegin(source), elements_rend(source), _comparand);
if(found == elements_rend(source))
- return neutron<TargetT>::value();
+ return identity_element<TargetT>::value();
else
return *found;
}
@@ -194,7 +194,7 @@
typename AtomicT::const_iterator found
= std::upper_bound(source.begin(), source.end(), _comparand);
if(found == source.end())
- return neutron<TargetT>::value();
+ return identity_element<TargetT>::value();
else
return *found;
}
@@ -204,7 +204,7 @@
typename SegmentalT::element_const_iterator found
= std::upper_bound(elements_begin(source), elements_end(source), _comparand);
if(found == elements_end(source))
- return neutron<TargetT>::value();
+ return identity_element<TargetT>::value();
else
return *found;
}
@@ -233,7 +233,7 @@
typename AtomicT::const_reverse_iterator found
= std::upper_bound(source.rbegin(), source.rend(), _comparand);
if(found == source.rend())
- return neutron<TargetT>::value();
+ return identity_element<TargetT>::value();
else
return *found;
}
@@ -243,7 +243,7 @@
typename SegmentalT::element_const_reverse_iterator found
= std::upper_bound(elements_rbegin(source), elements_rend(source), _comparand);
if(found == elements_rend(source))
- return neutron<TargetT>::value();
+ return identity_element<TargetT>::value();
else
return *found;
}
Modified: sandbox/itl/libs/itl/test/test_functions.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_functions.hpp (original)
+++ sandbox/itl/libs/itl/test/test_functions.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -16,7 +16,7 @@
#include <boost/itl/type_traits/interval_type_default.hpp>
#include <boost/itl/discrete_interval.hpp>
-#include <boost/itl/type_traits/neutron.hpp>
+#include <boost/itl/type_traits/identity_element.hpp>
#include <boost/itl/functors.hpp>
namespace boost{namespace itl
Modified: sandbox/itl/libs/itl/test/test_icl_continuous_interval.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_icl_continuous_interval.hpp (original)
+++ sandbox/itl/libs/itl/test/test_icl_continuous_interval.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -12,8 +12,8 @@
void interval_ctor_4_ordered_types()
{
BOOST_CHECK_EQUAL(itl::is_empty(IntervalT()), true);
- BOOST_CHECK_EQUAL(itl::cardinality(IntervalT()), itl::neutron<typename itl::size_type_of<T>::type>::value());
- BOOST_CHECK_EQUAL(itl::size(IntervalT()), itl::neutron<typename itl::size_type_of<T>::type>::value());
+ BOOST_CHECK_EQUAL(itl::cardinality(IntervalT()), itl::identity_element<typename itl::size_type_of<T>::type>::value());
+ BOOST_CHECK_EQUAL(itl::size(IntervalT()), itl::identity_element<typename itl::size_type_of<T>::type>::value());
BOOST_CHECK_EQUAL( IntervalT(), IntervalT() );
BOOST_CHECK_EQUAL( IntervalT(), IntervalT(IntervalT().lower(), IntervalT().upper()) );
Modified: sandbox/itl/libs/itl/test/test_icl_dynamic_interval.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_icl_dynamic_interval.hpp (original)
+++ sandbox/itl/libs/itl/test/test_icl_dynamic_interval.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -13,14 +13,14 @@
{
typedef typename domain_type_of<interval_traits<IntervalT> >::type T;
- BOOST_CHECK_EQUAL(IntervalT().lower(), itl::neutron<T>::value());
- BOOST_CHECK_EQUAL(IntervalT().upper(), itl::neutron<T>::value());
- BOOST_CHECK_EQUAL(itl::lower(IntervalT()), itl::neutron<T>::value());
- BOOST_CHECK_EQUAL(itl::upper(IntervalT()), itl::neutron<T>::value());
+ BOOST_CHECK_EQUAL(IntervalT().lower(), itl::identity_element<T>::value());
+ BOOST_CHECK_EQUAL(IntervalT().upper(), itl::identity_element<T>::value());
+ BOOST_CHECK_EQUAL(itl::lower(IntervalT()), itl::identity_element<T>::value());
+ BOOST_CHECK_EQUAL(itl::upper(IntervalT()), itl::identity_element<T>::value());
- IntervalT itv = IntervalT(itl::neutron<T>::value(), itl::neutron<T>::value());
- BOOST_CHECK_EQUAL(IntervalT(), IntervalT(itl::neutron<T>::value(), itl::neutron<T>::value()));
- BOOST_CHECK_EQUAL(IntervalT(), IntervalT(itl::neutron<T>::value(), itl::neutron<T>::value(), interval_bounds::right_open()));
+ IntervalT itv = IntervalT(itl::identity_element<T>::value(), itl::identity_element<T>::value());
+ BOOST_CHECK_EQUAL(IntervalT(), IntervalT(itl::identity_element<T>::value(), itl::identity_element<T>::value()));
+ BOOST_CHECK_EQUAL(IntervalT(), IntervalT(itl::identity_element<T>::value(), itl::identity_element<T>::value(), interval_bounds::right_open()));
}
Modified: sandbox/itl/libs/itl/test/test_icl_interval.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_icl_interval.hpp (original)
+++ sandbox/itl/libs/itl/test/test_icl_interval.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -19,10 +19,10 @@
{
typedef typename domain_type_of<interval_traits<IntervalT> >::type T;
typedef typename itl::size_type_of<T>::type SizeT;
- T t_0 = itl::neutron<T>::value();
- T t_1 = itl::unon<T>::value();
- SizeT s_0 = itl::neutron<SizeT>::value();
- SizeT s_1 = itl::unon<SizeT>::value();
+ T t_0 = itl::identity_element<T>::value();
+ T t_1 = itl::unit_element<T>::value();
+ SizeT s_0 = itl::identity_element<SizeT>::value();
+ SizeT s_1 = itl::unit_element<SizeT>::value();
// Default ctor and emptieness
BOOST_CHECK_EQUAL( itl::is_empty(IntervalT()), true );
@@ -53,9 +53,9 @@
// LAW: No singletons can be constructed for static continuous rightopen and leftopen intervals
typedef typename domain_type_of<interval_traits<IntervalT> >::type T;
typedef typename itl::size_type_of<T>::type SizeT;
- T t_0 = itl::neutron<T>::value();
- T t_1 = itl::unon<T>::value();
- SizeT s_1 = itl::unon<SizeT>::value();
+ T t_0 = itl::identity_element<T>::value();
+ T t_1 = itl::unit_element<T>::value();
+ SizeT s_1 = itl::unit_element<SizeT>::value();
#ifdef BOOST_MSVC
BOOST_CHECK_EQUAL( is_singelizable<IntervalT>::value, true );
@@ -75,8 +75,8 @@
{
typedef typename domain_type_of<interval_traits<IntervalT> >::type T;
typedef typename itl::size_type_of<T>::type SizeT;
- //T t_0 = itl::neutron<T>::value();
- SizeT s_1 = itl::unon<SizeT>::value();
+ //T t_0 = itl::identity_element<T>::value();
+ SizeT s_1 = itl::unit_element<SizeT>::value();
#ifdef BOOST_MSVC
BOOST_CHECK_EQUAL( is_singelizable<IntervalT>::value, true );
Modified: sandbox/itl/libs/itl/test/test_icl_static_interval.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_icl_static_interval.hpp (original)
+++ sandbox/itl/libs/itl/test/test_icl_static_interval.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -12,8 +12,8 @@
void static_interval_ctor_4_ordered_types()
{
BOOST_CHECK_EQUAL(itl::is_empty(IntervalT()), true);
- BOOST_CHECK_EQUAL(itl::cardinality(IntervalT()), itl::neutron<typename itl::size_type_of<T>::type>::value());
- BOOST_CHECK_EQUAL(itl::size(IntervalT()), itl::neutron<typename itl::size_type_of<T>::type>::value());
+ BOOST_CHECK_EQUAL(itl::cardinality(IntervalT()), itl::identity_element<typename itl::size_type_of<T>::type>::value());
+ BOOST_CHECK_EQUAL(itl::size(IntervalT()), itl::identity_element<typename itl::size_type_of<T>::type>::value());
BOOST_CHECK_EQUAL( IntervalT(), IntervalT() );
BOOST_CHECK_EQUAL( IntervalT(), IntervalT(IntervalT().lower(), IntervalT().upper()) );
Modified: sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -19,8 +19,8 @@
typedef interval_map<T,U> IntervalMapT;
typedef split_interval_map<T,U> SplitIntervalMapT;
- T v0 = neutron<T>::value();
- U u1 = unon<U>::value();
+ T v0 = identity_element<T>::value();
+ U u1 = unit_element<U>::value();
SplitIntervalMapT split_map(make_pair(v0,u1));
IntervalMapT join_map(split_map);
@@ -36,8 +36,8 @@
typedef split_interval_map<T,U> SplitIntervalMapT;
typedef typename IntervalMapT::interval_type IntervalT;
- T v0 = neutron<T>::value();
- U u1 = unon<U>::value();
+ T v0 = identity_element<T>::value();
+ U u1 = unit_element<U>::value();
SplitIntervalMapT split_empty, split_single(make_pair(v0,u1));
IntervalMapT join_empty, join_single(make_pair(v0,u1));
@@ -81,9 +81,9 @@
typedef split_interval_map<T,U> SplitIntervalMapT;
typedef typename IntervalMapT::interval_type IntervalT;
- T v0 = neutron<T>::value();
- T v1 = unon<T>::value();
- U u1 = unon<U>::value();
+ T v0 = identity_element<T>::value();
+ T v1 = unit_element<T>::value();
+ U u1 = unit_element<U>::value();
mapping_pair<T,U> v0_u1(v0,u1);
mapping_pair<T,U> v1_u1(v1,u1);
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 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -27,34 +27,34 @@
// ordered types is the largest set of instance types.
// Because we can not generate values via incrementation for e.g. string,
// we are able to test operations only for the most basic values
- // neutron (0, empty, T() ...) and unon.
+ // identity_element (0, empty, T() ...) and unit_element.
- //T v0 = neutron<T>();
- //T v1 = unon<T>();
- T v0 = neutron<T>::value();
- T v1 = unon<T>::value();
+ //T v0 = identity_element<T>();
+ //T v1 = unit_element<T>();
+ T v0 = identity_element<T>::value();
+ T v1 = unit_element<T>::value();
IntervalT I0_0I(v0);
IntervalT I1_1I(v1);
IntervalT I0_1I(v0, v1, interval_bounds::closed());
- U u1 = unon<U>::value();
+ U u1 = unit_element<U>::value();
//-------------------------------------------------------------------------
//empty set
//-------------------------------------------------------------------------
BOOST_CHECK_EQUAL(IntervalMapT().empty(), true);
BOOST_CHECK_EQUAL(itl::is_empty(IntervalMapT()), true);
- BOOST_CHECK_EQUAL(cardinality(IntervalMapT()), neutron<size_T>::value());
- BOOST_CHECK_EQUAL(IntervalMapT().size(), neutron<size_T>::value());
- BOOST_CHECK_EQUAL(itl::size(IntervalMapT()), neutron<size_T>::value());
+ BOOST_CHECK_EQUAL(cardinality(IntervalMapT()), identity_element<size_T>::value());
+ BOOST_CHECK_EQUAL(IntervalMapT().size(), identity_element<size_T>::value());
+ BOOST_CHECK_EQUAL(itl::size(IntervalMapT()), identity_element<size_T>::value());
BOOST_CHECK_EQUAL(interval_count(IntervalMapT()), 0);
BOOST_CHECK_EQUAL(IntervalMapT().iterative_size(), 0);
BOOST_CHECK_EQUAL(iterative_size(IntervalMapT()), 0);
BOOST_CHECK_EQUAL(IntervalMapT(), IntervalMapT());
- IntervalT mt_interval = neutron<IntervalT >::value();
+ IntervalT mt_interval = identity_element<IntervalT >::value();
BOOST_CHECK_EQUAL(mt_interval, IntervalT());
typename IntervalMapT::value_type mt_u1 = make_pair(mt_interval, u1);
- IntervalMapT mt_map = neutron<IntervalMapT >::value();
+ IntervalMapT mt_map = identity_element<IntervalMapT >::value();
BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
//adding emptieness to emptieness yields emptieness ;)
@@ -64,7 +64,7 @@
BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
(mt_map += mt_u1) += mt_u1;
BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
- BOOST_CHECK_EQUAL(hull(mt_map), neutron<IntervalT >::value());
+ BOOST_CHECK_EQUAL(hull(mt_map), identity_element<IntervalT >::value());
//subtracting emptieness
mt_map.subtract(mt_u1).subtract(mt_u1);
@@ -154,8 +154,8 @@
BOOST_CHECK_EQUAL(itl::contains(single_I0_1I_u1, single_I1_1I_u1), true);
BOOST_CHECK_EQUAL(itl::contains(single_I0_1I_u1, single_I0_1I_u1), true);
- BOOST_CHECK_EQUAL(cardinality(single_I0_0I_u1), unon<size_T>::value());
- BOOST_CHECK_EQUAL(single_I0_0I_u1.size(), unon<size_T>::value());
+ BOOST_CHECK_EQUAL(cardinality(single_I0_0I_u1), unit_element<size_T>::value());
+ BOOST_CHECK_EQUAL(single_I0_0I_u1.size(), unit_element<size_T>::value());
BOOST_CHECK_EQUAL(interval_count(single_I0_0I_u1), 1);
BOOST_CHECK_EQUAL(single_I0_0I_u1.iterative_size(), 1);
BOOST_CHECK_EQUAL(iterative_size(single_I0_0I_u1), 1);
@@ -204,8 +204,8 @@
_I4_4I_u2.insert(I4_4I_u2).insert(I4_4I_u2);
BOOST_CHECK_EQUAL( _I4_4I_u2, _I4_4I_u2_1 );
- BOOST_CHECK_EQUAL( cardinality(_I4_4I_u2), unon<typename IntervalMapT::size_type>::value() );
- BOOST_CHECK_EQUAL( _I4_4I_u2.size(), unon<typename IntervalMapT::size_type>::value() );
+ BOOST_CHECK_EQUAL( cardinality(_I4_4I_u2), unit_element<typename IntervalMapT::size_type>::value() );
+ BOOST_CHECK_EQUAL( _I4_4I_u2.size(), unit_element<typename IntervalMapT::size_type>::value() );
BOOST_CHECK_EQUAL( interval_count(_I4_4I_u2), 1 );
BOOST_CHECK_EQUAL( _I4_4I_u2.iterative_size(), 1 );
BOOST_CHECK_EQUAL( iterative_size(_I4_4I_u2), 1 );
Modified: sandbox/itl/libs/itl/test/test_interval_set_mixed.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_mixed.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_mixed.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -14,7 +14,7 @@
typedef interval_set<T> IntervalSetT;
typedef typename IntervalSetT::interval_type IntervalT;
- T v0 = neutron<T>::value();
+ T v0 = identity_element<T>::value();
split_interval_set<T> split_set(v0);
separate_interval_set<T> sep_set(split_set);
@@ -30,7 +30,7 @@
typedef interval_set<T> IntervalSetT;
typedef typename IntervalSetT::interval_type IntervalT;
- T v0 = neutron<T>::value();
+ T v0 = identity_element<T>::value();
split_interval_set<T> split_empty, split_single(v0);
separate_interval_set<T> sep_empty, sep_single(v0);
@@ -97,8 +97,8 @@
typedef interval_set<T> IntervalSetT;
typedef typename IntervalSetT::interval_type IntervalT;
- T v0 = neutron<T>::value();
- T v1 = unon<T>::value();
+ T v0 = identity_element<T>::value();
+ T v1 = unit_element<T>::value();
split_interval_set<T> split_set;
separate_interval_set<T> sep_set;
Modified: sandbox/itl/libs/itl/test/test_interval_set_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_shared.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -25,10 +25,10 @@
// ordered types is the largest set of instance types.
// Because we can not generate values via incrementation for e.g. string,
// we are able to test operations only for the most basic values
- // neutron (0, empty, T() ...) and unon.
+ // identity_element (0, empty, T() ...) and unit_element.
- T v0 = neutron<T>::value();
- T v1 = unon<T>::value();
+ T v0 = identity_element<T>::value();
+ T v1 = unit_element<T>::value();
IntervalT I0_0I(v0);
IntervalT I1_1I(v1);
IntervalT I0_1I(v0, v1, interval_bounds::closed());
@@ -38,16 +38,16 @@
//-------------------------------------------------------------------------
BOOST_CHECK_EQUAL(IntervalSet<T>().empty(), true);
BOOST_CHECK_EQUAL(itl::is_empty(IntervalSet<T>()), true);
- BOOST_CHECK_EQUAL(cardinality(IntervalSet<T>()), neutron<size_T>::value());
- BOOST_CHECK_EQUAL(IntervalSet<T>().size(), neutron<size_T>::value());
+ BOOST_CHECK_EQUAL(cardinality(IntervalSet<T>()), identity_element<size_T>::value());
+ BOOST_CHECK_EQUAL(IntervalSet<T>().size(), identity_element<size_T>::value());
BOOST_CHECK_EQUAL(interval_count(IntervalSet<T>()), 0);
BOOST_CHECK_EQUAL(IntervalSet<T>().iterative_size(), 0);
BOOST_CHECK_EQUAL(iterative_size(IntervalSet<T>()), 0);
BOOST_CHECK_EQUAL(IntervalSet<T>(), IntervalSet<T>());
- IntervalT mt_interval = neutron<IntervalT>::value();
+ IntervalT mt_interval = identity_element<IntervalT>::value();
BOOST_CHECK_EQUAL(mt_interval, IntervalT());
- IntervalSet<T> mt_set = neutron<IntervalSet<T> >::value();
+ IntervalSet<T> mt_set = identity_element<IntervalSet<T> >::value();
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
//adding emptieness to emptieness yields emptieness ;)
@@ -57,7 +57,7 @@
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
(mt_set += mt_interval) += mt_interval;
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
- BOOST_CHECK_EQUAL(hull(mt_set), neutron<IntervalT >::value());
+ BOOST_CHECK_EQUAL(hull(mt_set), identity_element<IntervalT >::value());
//subtracting emptieness
mt_set.subtract(mt_interval).subtract(mt_interval);
@@ -137,8 +137,8 @@
BOOST_CHECK_EQUAL(itl::contains(single_I0_1I, single_I1_1I), true);
BOOST_CHECK_EQUAL(itl::contains(single_I0_1I, single_I0_1I), true);
- BOOST_CHECK_EQUAL(cardinality(single_I0_0I), unon<size_T>::value());
- BOOST_CHECK_EQUAL(single_I0_0I.size(), unon<size_T>::value());
+ BOOST_CHECK_EQUAL(cardinality(single_I0_0I), unit_element<size_T>::value());
+ BOOST_CHECK_EQUAL(single_I0_0I.size(), unit_element<size_T>::value());
BOOST_CHECK_EQUAL(interval_count(single_I0_0I), 1);
BOOST_CHECK_EQUAL(single_I0_0I.iterative_size(), 1);
BOOST_CHECK_EQUAL(iterative_size(single_I0_0I), 1);
@@ -179,8 +179,8 @@
(_I4_4I_1 += v4) += I4_4I;
BOOST_CHECK_EQUAL( _I4_4I, _I4_4I_1 );
- BOOST_CHECK_EQUAL( cardinality(_I4_4I), unon<typename IntervalSet<T>::size_type>::value() );
- BOOST_CHECK_EQUAL( _I4_4I.size(), unon<typename IntervalSet<T>::size_type>::value() );
+ BOOST_CHECK_EQUAL( cardinality(_I4_4I), unit_element<typename IntervalSet<T>::size_type>::value() );
+ BOOST_CHECK_EQUAL( _I4_4I.size(), unit_element<typename IntervalSet<T>::size_type>::value() );
BOOST_CHECK_EQUAL( interval_count(_I4_4I), 1 );
BOOST_CHECK_EQUAL( _I4_4I.iterative_size(), 1 );
BOOST_CHECK_EQUAL( iterative_size(_I4_4I), 1 );
Modified: sandbox/itl/libs/itl/test/test_itl_interval.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_interval.hpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_interval.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -12,7 +12,7 @@
void interval_ctor_4_ordered_types()
{
T lower_bound = given<mpl::or_<is_static_rightopen<IntervalT>, is_static_open<IntervalT> >, T>
- ::then(neutron<T>::value(), unon<T>::value());
+ ::then(identity_element<T>::value(), unit_element<T>::value());
typedef typename domain_type_of<IntervalT>::type Dom1T;
typedef typename domain_type_of<interval_traits<IntervalT> >::type Dom2T;
@@ -21,15 +21,15 @@
// An empty interval is defined as the closed interval [1,0]
BOOST_CHECK_EQUAL(itl::is_empty(IntervalT()), true);
- BOOST_CHECK_EQUAL(itl::cardinality(IntervalT()), itl::neutron<typename itl::size_type_of<T>::type>::value());
- BOOST_CHECK_EQUAL(itl::size(IntervalT()), itl::neutron<typename itl::size_type_of<T>::type>::value());
+ BOOST_CHECK_EQUAL(itl::cardinality(IntervalT()), itl::identity_element<typename itl::size_type_of<T>::type>::value());
+ BOOST_CHECK_EQUAL(itl::size(IntervalT()), itl::identity_element<typename itl::size_type_of<T>::type>::value());
BOOST_CHECK_EQUAL(IntervalT().lower(), lower_bound);
- BOOST_CHECK_EQUAL(IntervalT().upper(), itl::neutron<T>::value());
+ BOOST_CHECK_EQUAL(IntervalT().upper(), itl::identity_element<T>::value());
BOOST_CHECK_EQUAL(itl::lower(IntervalT()), lower_bound);
- BOOST_CHECK_EQUAL(itl::upper(IntervalT()), itl::neutron<T>::value());
+ BOOST_CHECK_EQUAL(itl::upper(IntervalT()), itl::identity_element<T>::value());
BOOST_CHECK_EQUAL(IntervalT(), IntervalT());
- BOOST_CHECK_EQUAL(IntervalT(), IntervalT(lower_bound, itl::neutron<T>::value()));
+ BOOST_CHECK_EQUAL(IntervalT(), IntervalT(lower_bound, itl::identity_element<T>::value()));
}
/*JODO
@@ -37,9 +37,9 @@
void interval_ctor_4_bicremental_types()
{
BOOST_CHECK_EQUAL( T(), pred(succ(T())));
- BOOST_CHECK_EQUAL( itl::neutron<T>::value(), pred(succ(itl::neutron<T>::value())) );
- BOOST_CHECK_EQUAL( itl::unon<T>::value(), succ(itl::neutron<T>::value()) );
- BOOST_CHECK_EQUAL( interval<T>().length(), itl::neutron<typename difference_type_of<T>::type>::value() );
+ BOOST_CHECK_EQUAL( itl::identity_element<T>::value(), pred(succ(itl::identity_element<T>::value())) );
+ BOOST_CHECK_EQUAL( itl::unit_element<T>::value(), succ(itl::identity_element<T>::value()) );
+ BOOST_CHECK_EQUAL( interval<T>().length(), itl::identity_element<typename difference_type_of<T>::type>::value() );
T v4 = make<T>(4);
itl::interval<T> I4_4I(v4);
@@ -60,9 +60,9 @@
BOOST_CHECK_EQUAL( I4_4I.contained_in(I4_4I), true );
BOOST_CHECK_EQUAL( I4_4I, I4_4I );
- BOOST_CHECK_EQUAL( I4_4I.cardinality(), unon<typename interval<T>::size_type>::value() );
- BOOST_CHECK_EQUAL( I4_4I.size(), unon<typename interval<T>::size_type>::value() );
- //BOOST_CHECK_EQUAL( I4_4I.length(), neutron<typename interval<T>::difference_type>::value() );
+ BOOST_CHECK_EQUAL( I4_4I.cardinality(), unit_element<typename interval<T>::size_type>::value() );
+ BOOST_CHECK_EQUAL( I4_4I.size(), unit_element<typename interval<T>::size_type>::value() );
+ //BOOST_CHECK_EQUAL( I4_4I.length(), identity_element<typename interval<T>::difference_type>::value() );
itl::interval<T> j_4_4(I4_4I);
BOOST_CHECK_EQUAL( I4_4I, j_4_4 );
@@ -109,11 +109,11 @@
template <class T>
void interval_ctor_4_integral_types()
{
- BOOST_CHECK_EQUAL(interval<T>().first(), itl::unon<T>::value());
- BOOST_CHECK_EQUAL(interval<T>().last(), itl::neutron<T>::value());
- BOOST_CHECK_EQUAL(interval<T>().length(), itl::neutron<typename interval<T>::difference_type>::value());
+ BOOST_CHECK_EQUAL(interval<T>().first(), itl::unit_element<T>::value());
+ BOOST_CHECK_EQUAL(interval<T>().last(), itl::identity_element<T>::value());
+ BOOST_CHECK_EQUAL(interval<T>().length(), itl::identity_element<typename interval<T>::difference_type>::value());
- BOOST_CHECK_EQUAL(interval<T>(0,0).length(), itl::unon<typename interval<T>::difference_type>::value());
+ BOOST_CHECK_EQUAL(interval<T>(0,0).length(), itl::unit_element<typename interval<T>::difference_type>::value());
}
void interval_ctor_specific()//JODO
Modified: sandbox/itl/libs/itl/test/test_itl_interval_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_interval_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_interval_shared.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -18,13 +18,13 @@
typedef Interval<T,Compare> IntervalT;
// An empty interval is defined as the closed interval [1,0]
BOOST_CHECK_EQUAL(itl::is_empty(IntervalT()), true);
- BOOST_CHECK_EQUAL(cardinality(IntervalT()), itl::neutron<typename itl::size_type_of<T>::type>::value());
- BOOST_CHECK_EQUAL(itl::size(IntervalT()), itl::neutron<typename itl::size_type_of<T>::type>::value());
- BOOST_CHECK_EQUAL(IntervalT().lower(), itl::neutron<T>::value());
- BOOST_CHECK_EQUAL(IntervalT().upper(), itl::neutron<T>::value());
+ BOOST_CHECK_EQUAL(cardinality(IntervalT()), itl::identity_element<typename itl::size_type_of<T>::type>::value());
+ BOOST_CHECK_EQUAL(itl::size(IntervalT()), itl::identity_element<typename itl::size_type_of<T>::type>::value());
+ BOOST_CHECK_EQUAL(IntervalT().lower(), itl::identity_element<T>::value());
+ BOOST_CHECK_EQUAL(IntervalT().upper(), itl::identity_element<T>::value());
BOOST_CHECK_EQUAL(IntervalT(), IntervalT());
- BOOST_CHECK_EQUAL(IntervalT(), IntervalT(itl::neutron<T>::value(), itl::neutron<T>::value()));
- BOOST_CHECK_EQUAL(IntervalT(), IntervalT(itl::neutron<T>::value(), itl::neutron<T>::value(), interval_bounds::right_open()));
+ BOOST_CHECK_EQUAL(IntervalT(), IntervalT(itl::identity_element<T>::value(), itl::identity_element<T>::value()));
+ BOOST_CHECK_EQUAL(IntervalT(), IntervalT(itl::identity_element<T>::value(), itl::identity_element<T>::value(), interval_bounds::right_open()));
}
@@ -35,9 +35,9 @@
typedef Interval<T,Compare> IntervalT;
BOOST_CHECK_EQUAL( T(), pred(succ(T())));
- BOOST_CHECK_EQUAL( itl::neutron<T>::value(), pred(succ(itl::neutron<T>::value())) );
- BOOST_CHECK_EQUAL( itl::unon<T>::value(), succ(itl::neutron<T>::value()) );
- BOOST_CHECK_EQUAL( interval<T>().length(), itl::neutron<typename difference_type_of<T>::type>::value() );
+ BOOST_CHECK_EQUAL( itl::identity_element<T>::value(), pred(succ(itl::identity_element<T>::value())) );
+ BOOST_CHECK_EQUAL( itl::unit_element<T>::value(), succ(itl::identity_element<T>::value()) );
+ BOOST_CHECK_EQUAL( interval<T>().length(), itl::identity_element<typename difference_type_of<T>::type>::value() );
T v4 = make<T>(4);
IntervalT I4_4I(v4);
@@ -59,8 +59,8 @@
BOOST_CHECK_EQUAL( itl::contains(I4_4I, I4_4I), true );
BOOST_CHECK_EQUAL( within(I4_4I, I4_4I), true );
BOOST_CHECK_EQUAL( I4_4I, I4_4I );
- BOOST_CHECK_EQUAL( cardinality(I4_4I), unon<typename interval<T>::size_type>::value() );
- BOOST_CHECK_EQUAL( itl::size(I4_4I), unon<typename interval<T>::size_type>::value() );
+ BOOST_CHECK_EQUAL( cardinality(I4_4I), unit_element<typename interval<T>::size_type>::value() );
+ BOOST_CHECK_EQUAL( itl::size(I4_4I), unit_element<typename interval<T>::size_type>::value() );
IntervalT j_4_4(I4_4I);
BOOST_CHECK_EQUAL( I4_4I, j_4_4 );
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 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -8,7 +8,7 @@
#ifndef __test_itl_laws_h_JOFA_090119__
#define __test_itl_laws_h_JOFA_090119__
-#include <boost/itl/type_traits/neutron.hpp>
+#include <boost/itl/type_traits/identity_element.hpp>
namespace boost{namespace itl
{
@@ -73,40 +73,40 @@
#define DEFINE_RIGHT_NEUTRALITY_CHECK_WRT_EQUAL(op_tag, op_sign) \
template<class Type> \
void check_right_neutrality_wrt_equal_##op_tag \
-(typename equality<Type>::type* equal, const Type& a, const Type& neutron) \
+(typename equality<Type>::type* equal, const Type& a, const Type& identity_element) \
{ \
- Type left = a op_sign neutron; \
- Type right = neutron; \
+ Type left = a op_sign identity_element; \
+ Type right = identity_element; \
BOOST_CHECK_EQUAL((*equal)(left,right), true); \
}
#define DEFINE_RIGHT_NEUTRALITY_CHECK_WRT(op_tag, op_sign) \
template<class Type> \
void check_right_neutrality_wrt_##op_tag \
-(typename equality<Type>::type* equal, const Type& a, const Type& neutron) \
+(typename equality<Type>::type* equal, const Type& a, const Type& identity_element) \
{ \
- Type left = a op_sign neutron; \
- Type right = neutron; \
+ Type left = a op_sign identity_element; \
+ Type right = identity_element; \
BOOST_CHECK_EQUAL(left,right); \
}
#define DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(op_tag, op_sign) \
template<class Type> \
void check_neutrality_wrt_equal_##op_tag \
-(typename equality<Type>::type* equal, const Type& a, const Type& neutron) \
+(typename equality<Type>::type* equal, const Type& a, const Type& identity_element) \
{ \
- Type left = a op_sign neutron; \
- Type right = neutron op_sign a; \
+ Type left = a op_sign identity_element; \
+ Type right = identity_element op_sign a; \
BOOST_CHECK_EQUAL((*equal)(left,right), true); \
}
#define DEFINE_NEUTRALITY_CHECK_WRT(op_tag, op_sign) \
template<class Type> \
void check_neutrality_wrt_##op_tag \
-(const Type& a, const Type& neutron) \
+(const Type& a, const Type& identity_element) \
{ \
- Type left = a op_sign neutron; \
- Type right = neutron op_sign a; \
+ Type left = a op_sign identity_element; \
+ Type right = identity_element op_sign a; \
BOOST_CHECK_EQUAL(left,right); \
}
@@ -166,19 +166,19 @@
#define DEFINE_PARTIAL_INVERSION_CHECK_WRT_EQUAL(plus_tag, plus_sign) \
template<class Type> \
void check_partial_inversion_wrt_equal_##plus_tag \
-(typename equality<Type>::type* equal, const Type& neutron, const Type& var_a) \
+(typename equality<Type>::type* equal, const Type& identity_element, const Type& var_a) \
{ \
Type positive_difference = var_a - var_a; \
- BOOST_CHECK_EQUAL((*equal)(positive_difference, neutron), true); \
+ BOOST_CHECK_EQUAL((*equal)(positive_difference, identity_element), true); \
}
#define DEFINE_PARTIAL_INVERSION_CHECK_WRT(plus_tag, plus_sign) \
template<class Type> \
void check_partial_inversion_wrt_##plus_tag \
-(const Type& neutron, const Type& var_a) \
+(const Type& identity_element, const Type& var_a) \
{ \
Type positive_difference = var_a - var_a; \
- BOOST_CHECK_EQUAL(positive_difference, neutron); \
+ BOOST_CHECK_EQUAL(positive_difference, identity_element); \
}
#define CHECK_PARTIAL_INVERSION_WRT_EQUAL(plus_tag) check_partial_inversion_wrt_equal_##plus_tag
@@ -196,23 +196,23 @@
#define DEFINE_INVERSE_CHECK_WRT_EQUAL(plus_tag, plus_sign) \
template<class Type> \
void check_inverse_wrt_equal_##plus_tag \
-(typename equality<Type>::type* equal, const Type& neutron, const Type& var_a) \
+(typename equality<Type>::type* equal, const Type& identity_element, const Type& var_a) \
{ \
Type positive_difference = var_a - var_a; \
- BOOST_CHECK_EQUAL((*equal)(positive_difference, neutron), true); \
- Type negative_difference = (neutron - var_a) plus_sign var_a; \
- BOOST_CHECK_EQUAL((*equal)(negative_difference, neutron), true); \
+ BOOST_CHECK_EQUAL((*equal)(positive_difference, identity_element), true); \
+ Type negative_difference = (identity_element - var_a) plus_sign var_a; \
+ BOOST_CHECK_EQUAL((*equal)(negative_difference, identity_element), true); \
}
#define DEFINE_INVERSE_CHECK_WRT(plus_tag, plus_sign) \
template<class Type> \
void check_inverse_wrt_##plus_tag \
-(const Type& neutron, const Type& var_a) \
+(const Type& identity_element, const Type& var_a) \
{ \
Type positive_difference = var_a - var_a; \
- BOOST_CHECK_EQUAL(positive_difference, neutron); \
- Type negative_difference = (neutron - var_a) plus_sign var_a; \
- BOOST_CHECK_EQUAL(negative_difference, neutron); \
+ BOOST_CHECK_EQUAL(positive_difference, identity_element); \
+ Type negative_difference = (identity_element - var_a) plus_sign var_a; \
+ BOOST_CHECK_EQUAL(negative_difference, identity_element); \
}
#define CHECK_INVERSE_WRT_EQUAL(plus_tag) check_inverse_wrt_equal_##plus_tag
@@ -271,21 +271,21 @@
#define DEFINE_MONOID_CHECK_WRT_EQUAL(op_tag) \
template<class Type, class TypeB, class TypeC> \
void check_monoid_wrt_equal_##op_tag \
-(typename equality<Type>::type* equal, const Type& neutron, \
+(typename equality<Type>::type* equal, const Type& identity_element, \
const Type& a, const TypeB& b, const TypeC& c) \
{ \
CHECK_ASSOCIATIVITY_WRT_EQUAL(op_tag)(equal,a,b,c); \
- CHECK_NEUTRALITY_WRT_EQUAL(op_tag)(equal,a,neutron); \
+ CHECK_NEUTRALITY_WRT_EQUAL(op_tag)(equal,a,identity_element); \
}
#define DEFINE_MONOID_CHECK_WRT(op_tag) \
template<class Type, class TypeB, class TypeC> \
void check_monoid_wrt_##op_tag \
-(const Type& neutron, \
+(const Type& identity_element, \
const Type& a, const TypeB& b, const TypeC& c) \
{ \
CHECK_ASSOCIATIVITY_WRT(op_tag)(a,b,c); \
- CHECK_NEUTRALITY_WRT(op_tag)(a,neutron); \
+ CHECK_NEUTRALITY_WRT(op_tag)(a,identity_element); \
}
DEFINE_MONOID_CHECK_WRT(plus);
@@ -306,11 +306,11 @@
#define DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(op_tag) \
template<class Type, class TypeB, class TypeC> \
void check_abelian_monoid_wrt_equal_##op_tag \
-(typename equality<Type>::type* equal, const Type& neutron, \
+(typename equality<Type>::type* equal, const Type& identity_element, \
const Type& a, const TypeB& b, const TypeC& c) \
{ \
CHECK_ASSOCIATIVITY_WRT_EQUAL(op_tag)(equal,a,b,c); \
- CHECK_NEUTRALITY_WRT_EQUAL(op_tag)(equal,a,neutron); \
+ CHECK_NEUTRALITY_WRT_EQUAL(op_tag)(equal,a,identity_element); \
CHECK_COMMUTATIVITY_WRT_EQUAL(op_tag)(equal,a,b); \
CHECK_COMMUTATIVITY_WRT_EQUAL(op_tag)(equal,a,c); \
}
@@ -318,11 +318,11 @@
#define DEFINE_ABELIAN_MONOID_CHECK_WRT(op_tag) \
template<class Type, class TypeB, class TypeC> \
void check_abelian_monoid_wrt_##op_tag \
-(const Type& neutron, \
+(const Type& identity_element, \
const Type& a, const TypeB& b, const TypeC& c) \
{ \
CHECK_ASSOCIATIVITY_WRT(op_tag)(a,b,c); \
- CHECK_NEUTRALITY_WRT(op_tag)(a,neutron); \
+ CHECK_NEUTRALITY_WRT(op_tag)(a,identity_element); \
CHECK_COMMUTATIVITY_WRT(op_tag)(a,b); \
CHECK_COMMUTATIVITY_WRT(op_tag)(a,c); \
}
@@ -345,21 +345,21 @@
#define DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(op_tag) \
template<class Type, class TypeB, class TypeC> \
void check_partial_invertive_monoid_wrt_equal_##op_tag \
-(typename equality<Type>::type* equal, const Type& neutron, \
+(typename equality<Type>::type* equal, const Type& identity_element, \
const Type& a, const TypeB& b, const TypeC& c) \
{ \
- CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal,neutron,a,b,c); \
- CHECK_PARTIAL_INVERSION_WRT_EQUAL(op_tag)(equal,neutron,a); \
+ CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal,identity_element,a,b,c); \
+ CHECK_PARTIAL_INVERSION_WRT_EQUAL(op_tag)(equal,identity_element,a); \
}
#define DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT(op_tag) \
template<class Type, class TypeB, class TypeC> \
void check_partial_invertive_monoid_wrt_##op_tag \
-(const Type& neutron, \
+(const Type& identity_element, \
const Type& a, const TypeB& b, const TypeC& c) \
{ \
- CHECK_ABELIAN_MONOID_WRT(op_tag)(neutron,a,b,c); \
- CHECK_PARTIAL_INVERSION_WRT(op_tag)(neutron,a); \
+ CHECK_ABELIAN_MONOID_WRT(op_tag)(identity_element,a,b,c); \
+ CHECK_PARTIAL_INVERSION_WRT(op_tag)(identity_element,a); \
}
DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT(plus);
@@ -381,21 +381,21 @@
#define DEFINE_ABELIAN_GROUP_CHECK_WRT_EQUAL(op_tag) \
template<class Type, class TypeB, class TypeC> \
void check_abelian_group_wrt_equal_##op_tag \
-(typename equality<Type>::type* equal, const Type& neutron, \
+(typename equality<Type>::type* equal, const Type& identity_element, \
const Type& a, const TypeB& b, const TypeC& c) \
{ \
- CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal,neutron,a,b,c); \
- CHECK_INVERSE_WRT_EQUAL(op_tag)(equal,neutron,a); \
+ CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal,identity_element,a,b,c); \
+ CHECK_INVERSE_WRT_EQUAL(op_tag)(equal,identity_element,a); \
}
#define DEFINE_ABELIAN_GROUP_CHECK_WRT(op_tag) \
template<class Type, class TypeB, class TypeC> \
void check_abelian_group_wrt_##op_tag \
-(const Type& neutron, \
+(const Type& identity_element, \
const Type& a, const TypeB& b, const TypeC& c) \
{ \
- CHECK_ABELIAN_MONOID_WRT(op_tag)(neutron,a,b,c); \
- CHECK_INVERSE_WRT(op_tag)(neutron,a); \
+ CHECK_ABELIAN_MONOID_WRT(op_tag)(identity_element,a,b,c); \
+ CHECK_INVERSE_WRT(op_tag)(identity_element,a); \
}
@@ -416,10 +416,10 @@
void check_monoid_permuted_wrt_equal_##op_tag \
(typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
{ \
- CHECK_MONOID_WRT_EQUAL(op_tag)(equal, itl::neutron<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_MONOID_WRT_EQUAL(op_tag)(equal, itl::neutron<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_MONOID_WRT_EQUAL(op_tag)(equal, itl::neutron<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_MONOID_WRT_EQUAL(op_tag)(equal, itl::neutron<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
}
#define DEFINE_MONOID_CHECK_PERMUTED_WRT(op_tag) \
@@ -427,10 +427,10 @@
void check_monoid_permuted_wrt_##op_tag \
(const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
{ \
- CHECK_MONOID_WRT(op_tag)(itl::neutron<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_MONOID_WRT(op_tag)(itl::neutron<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_MONOID_WRT(op_tag)(itl::neutron<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_MONOID_WRT(op_tag)(itl::neutron<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_MONOID_WRT(op_tag)(itl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_MONOID_WRT(op_tag)(itl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_MONOID_WRT(op_tag)(itl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_MONOID_WRT(op_tag)(itl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
}
@@ -456,10 +456,10 @@
void check_abelian_monoid_permuted_wrt_equal_##op_tag \
(typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
{ \
- CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, itl::neutron<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, itl::neutron<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, itl::neutron<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, itl::neutron<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
}
#define DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT(op_tag) \
@@ -467,10 +467,10 @@
void check_abelian_monoid_permuted_wrt_##op_tag \
(const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
{ \
- CHECK_ABELIAN_MONOID_WRT(op_tag)(itl::neutron<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_ABELIAN_MONOID_WRT(op_tag)(itl::neutron<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_ABELIAN_MONOID_WRT(op_tag)(itl::neutron<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_ABELIAN_MONOID_WRT(op_tag)(itl::neutron<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_ABELIAN_MONOID_WRT(op_tag)(itl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_ABELIAN_MONOID_WRT(op_tag)(itl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_ABELIAN_MONOID_WRT(op_tag)(itl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_ABELIAN_MONOID_WRT(op_tag)(itl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
}
@@ -496,10 +496,10 @@
void check_partial_invertive_monoid_permuted_wrt_equal_##op_tag \
(typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
{ \
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, itl::neutron<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, itl::neutron<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, itl::neutron<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, itl::neutron<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
}
#define DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT(op_tag) \
@@ -507,10 +507,10 @@
void check_partial_invertive_monoid_permuted_wrt_##op_tag \
(const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
{ \
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(itl::neutron<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(itl::neutron<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(itl::neutron<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(itl::neutron<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(itl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(itl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(itl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag)(itl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
}
@@ -536,10 +536,10 @@
void check_abelian_group_permuted_wrt_equal_##op_tag \
(typename equality<TypeA>::type* equal, const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
{ \
- CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, itl::neutron<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, itl::neutron<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, itl::neutron<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, itl::neutron<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag)(equal, itl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
}
#define DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT(op_tag) \
@@ -547,10 +547,10 @@
void check_abelian_group_permuted_wrt_##op_tag \
(const TypeA& var_a, const TypeB& var_b, const Assoc& assoc) \
{ \
- CHECK_ABELIAN_GROUP_WRT(op_tag)(itl::neutron<TypeA>::value(), var_a, var_b, assoc);\
- CHECK_ABELIAN_GROUP_WRT(op_tag)(itl::neutron<TypeA>::value(), var_a, assoc, var_b);\
- CHECK_ABELIAN_GROUP_WRT(op_tag)(itl::neutron<TypeB>::value(), var_b, var_a, assoc);\
- CHECK_ABELIAN_GROUP_WRT(op_tag)(itl::neutron<TypeB>::value(), var_b, assoc, var_a);\
+ CHECK_ABELIAN_GROUP_WRT(op_tag)(itl::identity_element<TypeA>::value(), var_a, var_b, assoc);\
+ CHECK_ABELIAN_GROUP_WRT(op_tag)(itl::identity_element<TypeA>::value(), var_a, assoc, var_b);\
+ CHECK_ABELIAN_GROUP_WRT(op_tag)(itl::identity_element<TypeB>::value(), var_b, var_a, assoc);\
+ CHECK_ABELIAN_GROUP_WRT(op_tag)(itl::identity_element<TypeB>::value(), var_b, assoc, var_a);\
}
Modified: sandbox/itl/libs/itl/test/test_value_maker.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_value_maker.hpp (original)
+++ sandbox/itl/libs/itl/test/test_value_maker.hpp 2010-10-08 07:43:22 EDT (Fri, 08 Oct 2010)
@@ -8,7 +8,7 @@
#ifndef BOOST_ITL_TEST_VALUE_MAKER_HPP_JOFA_080916
#define BOOST_ITL_TEST_VALUE_MAKER_HPP_JOFA_080916
-#include <boost/itl/type_traits/neutron.hpp>
+#include <boost/itl/type_traits/identity_element.hpp>
#include <boost/itl/interval_bounds.hpp>
#include "test_calls.hpp"
@@ -18,7 +18,7 @@
/*FYI completion like that:
std::string make(int n)
{
- std::string value = neutron<std::string>::value();
+ std::string value = identity_element<std::string>::value();
int abs_n = n<0 ? -n : n;
for(int i=1; i<abs_n; i++)
value += i%2==1 ? "hello " : "world ";
@@ -48,7 +48,7 @@
template <class BicrementableT>
BicrementableT make(int n)
{
- BicrementableT value = neutron<BicrementableT>::value();
+ BicrementableT value = identity_element<BicrementableT>::value();
if(n>=0)
for(int i=0; i<n; i++)
++value;
@@ -68,7 +68,7 @@
{
static std::string make(int n)
{
- std::string value = neutron<std::string>::value();
+ std::string value = identity_element<std::string>::value();
int abs_n = n<0 ? -n : n;
for(int i=1; i<abs_n; i++)
value += (i%2==1 ? "hello " : "world ");
@@ -82,7 +82,7 @@
{
static Type make(int n)
{
- Type value = neutron<Type>::value();
+ Type value = identity_element<Type>::value();
if(n>=0)
for(int i=0; i<n; i++)
++value;