Subject: [Boost-commit] svn:boost r65688 - in sandbox/itl: boost/itl boost/itl/concept boost/itl/concept/interval boost/itl/detail boost/itl/type_traits boost/itl_xt/detail boost/validate/driver boost/validate/itl boost/validate/laws libs/itl/example/itvset_shell_ libs/itl/example/large_bitset_ libs/itl/example/splititvmap_shell_ libs/itl/test libs/itl/test/fastest_itl_interval_ libs/validate/example/labat_signed_quantifier_ libs/validate/example/labat_single_
From: afojgo_at_[hidden]
Date: 2010-09-29 16:04:13
Author: jofaber
Date: 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
New Revision: 65688
URL: http://svn.boost.org/trac/boost/changeset/65688
Log:
Refactoring: Cleaning up the code, renaming, removing dependencies to old interval implementation. Stable{msvc-9.0, gcc-3.4.4}
Added:
sandbox/itl/boost/itl/detail/exclusive_less_than.hpp (contents, props changed)
sandbox/itl/boost/itl/type_traits/given.hpp (contents, props changed)
Removed:
sandbox/itl/boost/itl/detail/base_interval.hpp
Text files modified:
sandbox/itl/boost/itl/closed_interval.hpp | 3
sandbox/itl/boost/itl/concept/element_associator.hpp | 20 ++--
sandbox/itl/boost/itl/concept/element_map.hpp | 68 ++++++++--------
sandbox/itl/boost/itl/concept/element_set.hpp | 4
sandbox/itl/boost/itl/concept/element_set_value.hpp | 2
sandbox/itl/boost/itl/concept/interval.hpp | 83 ++++++++++++++-----
sandbox/itl/boost/itl/concept/interval/base.hpp | 2
sandbox/itl/boost/itl/concept/interval_associator.hpp | 75 ++++++++++++-----
sandbox/itl/boost/itl/concept/interval_map.hpp | 26 ++++--
sandbox/itl/boost/itl/concept/interval_set.hpp | 14 +-
sandbox/itl/boost/itl/concept/interval_set_value.hpp | 5
sandbox/itl/boost/itl/concept/map_value.hpp | 8
sandbox/itl/boost/itl/concept/set_value.hpp | 6
sandbox/itl/boost/itl/continuous_interval.hpp | 7 +
sandbox/itl/boost/itl/detail/associated_value.hpp | 8
sandbox/itl/boost/itl/detail/element_comparer.hpp | 1
sandbox/itl/boost/itl/detail/element_iterator.hpp | 38 +++++----
sandbox/itl/boost/itl/detail/interval_map_algo.hpp | 5
sandbox/itl/boost/itl/detail/interval_morphism.hpp | 10 +-
sandbox/itl/boost/itl/detail/interval_set_algo.hpp | 55 ------------
sandbox/itl/boost/itl/detail/interval_subset_comparer.hpp | 1
sandbox/itl/boost/itl/detail/map_algo.hpp | 4
sandbox/itl/boost/itl/detail/set_algo.hpp | 12 +-
sandbox/itl/boost/itl/detail/subset_comparer.hpp | 1
sandbox/itl/boost/itl/discrete_interval.hpp | 5
sandbox/itl/boost/itl/dynamic_interval_traits.hpp | 1
sandbox/itl/boost/itl/interval.hpp | 13 --
sandbox/itl/boost/itl/interval_base_map.hpp | 4
sandbox/itl/boost/itl/interval_base_set.hpp | 21 ++++
sandbox/itl/boost/itl/interval_map.hpp | 1
sandbox/itl/boost/itl/interval_traits.hpp | 31 ++++++
sandbox/itl/boost/itl/map.hpp | 11 --
sandbox/itl/boost/itl/rightopen_interval.hpp | 5
sandbox/itl/boost/itl/set.hpp | 19 ----
sandbox/itl/boost/itl/type_traits/codomain_type_of.hpp | 16 +-
sandbox/itl/boost/itl/type_traits/domain_type_of.hpp | 16 +-
sandbox/itl/boost/itl/type_traits/element_type_of.hpp | 16 +-
sandbox/itl/boost/itl/type_traits/has_dynamic_bounds.hpp | 2
sandbox/itl/boost/itl/type_traits/has_set_semantics.hpp | 12 +-
sandbox/itl/boost/itl/type_traits/interval_type_of.hpp | 16 +-
sandbox/itl/boost/itl/type_traits/is_assoc_element_container.hpp | 2
sandbox/itl/boost/itl/type_traits/is_associative_element_container.hpp | 2
sandbox/itl/boost/itl/type_traits/is_combinable.hpp | 12 +-
sandbox/itl/boost/itl/type_traits/is_element_container.hpp | 2
sandbox/itl/boost/itl/type_traits/is_icl_container.hpp | 2
sandbox/itl/boost/itl/type_traits/is_key_container_of.hpp | 10 +-
sandbox/itl/boost/itl/type_traits/no_type.hpp | 2
sandbox/itl/boost/itl/type_traits/segment_type_of.hpp | 16 +-
sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp | 9 +
sandbox/itl/boost/validate/driver/itl_driver.hpp | 4
sandbox/itl/boost/validate/itl/functors.hpp | 4
sandbox/itl/boost/validate/laws/order.hpp | 20 ++--
sandbox/itl/libs/itl/example/itvset_shell_/itvset_shell.cpp | 2
sandbox/itl/libs/itl/example/large_bitset_/large_bitset.hpp | 4
sandbox/itl/libs/itl/example/splititvmap_shell_/splititvmap_shell.cpp | 2
sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp | 6
sandbox/itl/libs/itl/test/test_calls.hpp | 8
sandbox/itl/libs/itl/test/test_icl_quantifier_shared.hpp | 168 ++++++++++++++++++++--------------------
sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp | 8
sandbox/itl/libs/itl/test/test_interval_map_shared.hpp | 6
sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp | 8
sandbox/itl/libs/itl/test/test_interval_set_shared.hpp | 8
sandbox/itl/libs/itl/test/test_itl_interval.hpp | 26 +++--
sandbox/itl/libs/itl/test/test_itl_interval_shared.hpp | 156 ++++++++++++++++++------------------
sandbox/itl/libs/itl/test/test_itl_map.hpp | 4
sandbox/itl/libs/itl/test/test_laws.hpp | 40 ++++----
sandbox/itl/libs/itl/test/test_set_interval_set_shared.hpp | 34 ++++----
sandbox/itl/libs/itl/test/test_type_lists.hpp | 2
sandbox/itl/libs/itl/test/test_value_maker.hpp | 9 +
sandbox/itl/libs/validate/example/labat_signed_quantifier_/labat_signed_quantifier.cpp | 2
sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp | 8
71 files changed, 633 insertions(+), 600 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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -10,7 +10,6 @@
#include <boost/itl/type_traits/value_size.hpp>
#include <boost/itl/type_traits/type_to_string.hpp>
-#include <boost/itl/detail/base_interval.hpp>
#include <boost/itl/concept/interval.hpp>
namespace boost{namespace itl
@@ -18,7 +17,7 @@
template <class DomainT,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT)>
-class closed_interval : public base_interval<DomainT,Compare>
+class closed_interval
{
public:
typedef closed_interval<DomainT,Compare> type;
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -28,14 +28,14 @@
typename enable_if<is_associative_element_container<Type>, typename Type::size_type>::type
size(const Type& object)
{
- return itl::iterative_size(object);
+ return itl::iterative_size(object);
}
template<class Type>
typename enable_if<is_associative_element_container<Type>, typename Type::size_type>::type
cardinality(const Type& object)
{
- return itl::iterative_size(object);
+ return itl::iterative_size(object);
}
@@ -241,7 +241,7 @@
typename enable_if<is_associative_element_container<Type>,
typename Type::iterator>::type
insert(Type& object, typename Type::iterator prior,
- const typename Type::element_type& operand)
+ const typename Type::element_type& operand)
{
return object.insert(prior, operand);
}
@@ -270,12 +270,12 @@
typename enable_if<is_associative_element_container<Type>, typename Type::size_type>::type
erase(Type& object, const typename Type::domain_type& key_value)
{
- typedef typename Type::size_type size_type;
+ typedef typename Type::size_type size_type;
typename Type::iterator it_ = object.find(key_value);
if(it_ != object.end())
{
object.erase(it_);
- return unon<size_type>::value();
+ return unon<size_type>::value();
}
return neutron<size_type>::value();
}
@@ -336,7 +336,7 @@
template<class Type>
inline typename enable_if<is_associative_element_container<Type>, void>::type
add_intersection(Type& section, const Type& object,
- const typename Type::domain_type& operand)
+ const typename Type::domain_type& operand)
{
typedef typename Type::const_iterator const_iterator;
const_iterator it_ = object.find(operand);
@@ -350,10 +350,10 @@
template<class Type>
inline typename enable_if<is_associative_element_container<Type>, void>::type
add_intersection(Type& section, const Type& object,
- const typename Type::key_object_type& operand)
+ const typename Type::key_object_type& operand)
{
typedef typename Type::key_object_type key_object_type;
- typedef typename key_object_type::const_iterator const_iterator;
+ typedef typename key_object_type::const_iterator const_iterator;
const_iterator common_lwb_, common_upb_;
if(!Set::common_range(common_lwb_, common_upb_, operand, object))
return;
@@ -415,14 +415,14 @@
inline typename enable_if<is_associative_element_container<Type>, Type>::type
operator ^ (Type object, const typename Type::element_type& operand)
{
- return itl::flip(object, operand);
+ return itl::flip(object, operand);
}
template<class Type>
inline typename enable_if<is_associative_element_container<Type>, Type>::type
operator ^ (const typename Type::element_type& operand, Type object)
{
- return itl::flip(object, operand);
+ return itl::flip(object, operand);
}
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -101,12 +101,12 @@
typename enable_if<is_element_map<Type>, typename Type::size_type>::type
erase(Type& object, const typename Type::element_type& value_pair)
{
- typedef typename Type::size_type size_type;
- typedef typename Type::iterator iterator;
- typedef typename Type::on_neutron_absorbtion on_neutron_absorbtion;
+ typedef typename Type::size_type size_type;
+ typedef typename Type::iterator iterator;
+ typedef typename Type::on_neutron_absorbtion on_neutron_absorbtion;
- if(on_neutron_absorbtion::is_absorbable(value_pair.second))
- return neutron<size_type>::value();
+ if(on_neutron_absorbtion::is_absorbable(value_pair.second))
+ return neutron<size_type>::value();
iterator it_ = object.find(value_pair.first);
if(it_ != object.end() && value_pair.second == it_->second)
@@ -149,7 +149,7 @@
typename enable_if<is_element_map<Type>, Type>::type&
subtract(Type& object, const typename Type::domain_type& key_value)
{
- return itl::erase(object, key_value);
+ return itl::erase(object, key_value);
}
//------------------------------------------------------------------------------
@@ -179,18 +179,18 @@
inline typename enable_if<is_element_map<Type>, Type>::type&
set_at(Type& object, const typename Type::element_type& operand)
{
- typedef typename Type::iterator iterator;
- typedef typename Type::codomain_combine codomain_combine;
- typedef on_absorbtion<Type,codomain_combine,absorbs_neutrons<Type>::value>
- on_neutron_absorbtion;
+ typedef typename Type::iterator iterator;
+ typedef typename Type::codomain_combine codomain_combine;
+ typedef on_absorbtion<Type,codomain_combine,absorbs_neutrons<Type>::value>
+ on_neutron_absorbtion;
if(!on_neutron_absorbtion::is_absorbable(operand.second))
- {
- std::pair<iterator,bool> insertion = object.insert(operand);
- if(!insertion.second)
- insertion->second = operand.second;
- }
- return object;
+ {
+ std::pair<iterator,bool> insertion = object.insert(operand);
+ if(!insertion.second)
+ insertion->second = operand.second;
+ }
+ return object;
}
@@ -200,9 +200,9 @@
template<class Type>
inline typename enable_if<is_element_map<Type>, void>::type
add_intersection(Type& section, const Type& object,
- const typename Type::element_type& operand)
+ const typename Type::element_type& operand)
{
- object.add_intersection(section, operand);
+ object.add_intersection(section, operand);
}
template<class Type>
@@ -221,8 +221,8 @@
inline typename enable_if<mpl::and_<is_element_map<Type>, is_total<Type> >, Type>::type&
operator &=(Type& object, const typename Type::element_type& operand)
{
- object.add(operand);
- return object;
+ object.add(operand);
+ return object;
}
template<class Type>
@@ -255,7 +255,7 @@
operator &=(Type& object, const Type& operand)
{
object += operand;
- return object;
+ return object;
}
template<class Type>
@@ -298,7 +298,7 @@
, bool>::type
intersects(const Type&, const CoType&)
{
- return true;
+ return true;
}
template<class Type>
@@ -307,7 +307,7 @@
, bool>::type
intersects(const Type& object, const typename Type::domain_type& operand)
{
- return itl::contains(object, operand);
+ return itl::contains(object, operand);
}
template<class Type>
@@ -329,7 +329,7 @@
intersects(const Type& object, const typename Type::element_type& operand)
{
Type intersection;
- itl::add_intersection(intersection, object, operand);
+ itl::add_intersection(intersection, object, operand);
return !intersection.empty();
}
@@ -352,7 +352,7 @@
inline typename enable_if<is_element_map<Type>, Type>::type&
flip(Type& object, const typename Type::element_type& operand)
{
- return object.flip(operand);
+ return object.flip(operand);
}
template<class Type, class CoType>
@@ -362,8 +362,8 @@
, Type>::type&
operator ^= (Type& object, const CoType&)
{
- itl::clear(object);
- return object;
+ itl::clear(object);
+ return object;
}
template<class Type>
@@ -373,7 +373,7 @@
, Type>::type&
operator ^= (Type& object, const typename Type::element_type& operand)
{
- return object.flip(operand);
+ return object.flip(operand);
}
template<class Type>
@@ -383,13 +383,13 @@
, Type>::type&
operator ^= (Type& object, const Type& operand)
{
- ITL_const_FORALL(typename Type, it_, operand)
- itl::flip(object, *it_);
+ ITL_const_FORALL(typename Type, it_, operand)
+ itl::flip(object, *it_);
ITL_FORALL(typename Type, it2_, object)
it2_->second = neutron<typename Type::codomain_type>::value();
- return object;
+ return object;
}
@@ -443,14 +443,14 @@
, absorbs_neutrons<Type> >, Type>::type&
absorb_neutrons(Type& object)
{
- typedef typename Type::element_type element_type;
- return itl::erase_if(content_is_neutron<element_type>(), object);
+ typedef typename Type::element_type element_type;
+ return itl::erase_if(content_is_neutron<element_type>(), object);
}
template<class Type>
inline typename enable_if<mpl::and_< is_element_map<Type>
, mpl::not_<absorbs_neutrons<Type> > >
- , Type>::type&
+ , Type>::type&
absorb_neutrons(Type&){}
//==============================================================================
Modified: sandbox/itl/boost/itl/concept/element_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/element_set.hpp (original)
+++ sandbox/itl/boost/itl/concept/element_set.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -49,7 +49,7 @@
typename enable_if<is_element_set<Type>, Type>::type&
subtract(Type& object, const typename Type::element_type& operand)
{
- object.erase(operand);
+ object.erase(operand);
return object;
}
@@ -68,7 +68,7 @@
inline typename enable_if<is_element_set<Type>, bool>::type
intersects(const Type& object, const typename Type::domain_type& operand)
{
- return itl::contains(object, operand);
+ return itl::contains(object, operand);
}
template<class Type>
Modified: sandbox/itl/boost/itl/concept/element_set_value.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/element_set_value.hpp (original)
+++ sandbox/itl/boost/itl/concept/element_set_value.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -20,7 +20,7 @@
inline typename enable_if<is_element_set<Type>, const typename Type::key_type>::type&
co_value(Iterator it_)
{
- return *it_;
+ return *it_;
}
Modified: sandbox/itl/boost/itl/concept/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/interval.hpp (original)
+++ sandbox/itl/boost/itl/concept/interval.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -10,8 +10,16 @@
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/and.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/not.hpp>
#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/infinity.hpp>
+#include <boost/itl/type_traits/succ_pred.hpp>
+#include <boost/itl/type_traits/is_numeric.hpp>
#include <boost/itl/type_traits/is_discrete.hpp>
#include <boost/itl/type_traits/is_asymmetric_interval.hpp>
#include <boost/itl/type_traits/is_universal_interval.hpp>
@@ -80,7 +88,8 @@
construct(const typename interval_traits<Type>::domain_type& value)
{
//ASSERT: This always creates an interval with exactly one element
- BOOST_ASSERT((std::numeric_limits<Type>::min)() < value);
+ BOOST_ASSERT(given<is_numeric<Type>::value>
+ ::then((std::numeric_limits<Type>::min)() < value));
return interval_traits<Type>::construct(itl::pred(value), value);
}
@@ -94,7 +103,8 @@
construct(const typename interval_traits<Type>::domain_type& value)
{
//ASSERT: This always creates an interval with exactly one element
- BOOST_ASSERT((std::numeric_limits<Type>::min)() < value);
+ BOOST_ASSERT(given<is_numeric<Type>::value>
+ ::then((std::numeric_limits<Type>::min)() < value));
return interval_traits<Type>::construct(itl::pred(value), itl::succ(value));
}
@@ -185,14 +195,25 @@
//- first ----------------------------------------------------------------------
template<class Type>
-inline typename enable_if<is_static_rightopen<Type>,
- typename interval_traits<Type>::domain_type>::type
+inline typename
+enable_if< mpl::or_<is_static_rightopen<Type>, is_static_closed<Type> >
+ , typename interval_traits<Type>::domain_type>::type
first(const Type& object)
{
return lower(object);
}
template<class Type>
+inline typename
+enable_if< mpl::and_< mpl::or_<is_static_leftopen<Type>, is_static_open<Type> >
+ , is_discrete<typename interval_traits<Type>::domain_type> >
+ , typename interval_traits<Type>::domain_type>::type
+first(const Type& object)
+{
+ return succ(lower(object));
+}
+
+template<class Type>
inline typename enable_if<is_discrete_interval<Type>,
typename interval_traits<Type>::domain_type>::type
first(const Type& object)
@@ -204,11 +225,23 @@
//- last -----------------------------------------------------------------------
template<class Type>
-inline typename enable_if<mpl::and_<is_static_rightopen<Type>,
- is_discrete<typename interval_traits<Type>::domain_type> >,
- typename interval_traits<Type>::domain_type>::type
+inline typename
+enable_if< mpl::or_<is_static_leftopen<Type>, is_static_closed<Type> >
+ , typename interval_traits<Type>::domain_type>::type
last(const Type& object)
{
+ return upper(object);
+}
+
+template<class Type>
+inline typename
+enable_if< mpl::and_< mpl::or_<is_static_rightopen<Type>, is_static_open<Type> >
+ , is_discrete<typename interval_traits<Type>::domain_type> >
+ , typename interval_traits<Type>::domain_type>::type
+last(const Type& object)
+{
+ BOOST_ASSERT(given<is_numeric<Type>::value>
+ ::then((std::numeric_limits<Type>::min)() < upper(object)));
return pred(upper(object));
}
@@ -606,10 +639,10 @@
template<class Type>
typename boost::enable_if<is_continuous_interval<Type>,
- typename Type::size_type>::type
+ typename size_type_of<interval_traits<Type> >::type>::type
cardinality(const Type& object)
{
- typedef typename Type::size_type SizeT;
+ typedef typename size_type_of<interval_traits<Type> >::type SizeT;
if(itl::is_empty(object))
return itl::neutron<SizeT>::value();
else if( object.bounds() == interval_bounds::closed()
@@ -621,19 +654,20 @@
template<class Type>
typename boost::enable_if<is_discrete_interval<Type>,
- typename Type::size_type>::type
+ typename size_type_of<interval_traits<Type> >::type>::type
cardinality(const Type& object)
{
- return (last(object) + itl::unon<typename Type::size_type>::value()) - first(object);
+ typedef typename size_type_of<interval_traits<Type> >::type SizeT;
+ return (last(object) + itl::unon<SizeT>::value()) - first(object);
}
template<class Type>
typename boost::enable_if<is_continuous_asymmetric<Type>,
- typename Type::size_type>::type
+ typename size_type_of<interval_traits<Type> >::type>::type
cardinality(const Type& object)
{
- typedef typename Type::size_type SizeT;
+ typedef typename size_type_of<interval_traits<Type> >::type SizeT;
if(itl::is_empty(object))
return itl::neutron<SizeT>::value();
else
@@ -642,10 +676,11 @@
template<class Type>
typename boost::enable_if<is_discrete_asymmetric<Type>,
- typename Type::size_type>::type
+ typename size_type_of<interval_traits<Type> >::type>::type
cardinality(const Type& object)
{
- return (last(object) + itl::unon<typename Type::size_type>::value()) - first(object);
+ typedef typename size_type_of<interval_traits<Type> >::type SizeT;
+ return (last(object) + itl::unon<SizeT>::value()) - first(object);
}
@@ -655,7 +690,7 @@
//- size -----------------------------------------------------------------------
template<class Type>
inline typename enable_if<is_interval<Type>,
- typename Type::size_type>::type
+ typename size_type_of<interval_traits<Type> >::type>::type
size(const Type& object)
{
return cardinality(object);
@@ -663,8 +698,8 @@
//- length ---------------------------------------------------------------------
template<class Type>
-typename boost::enable_if<is_continuous_interval<Type>,
- typename Type::difference_type>::type
+inline typename boost::enable_if<is_continuous_interval<Type>,
+ typename difference_type_of<interval_traits<Type> >::type>::type
length(const Type& object)
{
return upper(object) - lower(object);
@@ -672,16 +707,17 @@
template<class Type>
inline typename boost::enable_if<is_discrete_interval<Type>,
- typename Type::difference_type>::type
+ typename difference_type_of<interval_traits<Type> >::type>::type
length(const Type& object)
{
- return (last(object) + itl::unon<typename Type::difference_type>::value())
+ typedef typename difference_type_of<interval_traits<Type> >::type DiffT;
+ return (last(object) + itl::unon<DiffT>::value())
- first(object);
}
template<class Type>
typename boost::enable_if<is_continuous_asymmetric<Type>,
- typename Type::difference_type>::type
+ typename difference_type_of<interval_traits<Type> >::type>::type
length(const Type& object)
{
return upper(object) - lower(object);
@@ -689,10 +725,11 @@
template<class Type>
inline typename boost::enable_if<is_discrete_asymmetric<Type>,
- typename Type::difference_type>::type
+ typename difference_type_of<interval_traits<Type> >::type>::type
length(const Type& object)
{
- return (last(object) + itl::unon<typename Type::difference_type>::value())
+ typedef typename difference_type_of<interval_traits<Type> >::type DiffT;
+ return (last(object) + itl::unon<DiffT>::value())
- first(object);
}
Modified: sandbox/itl/boost/itl/concept/interval/base.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/interval/base.hpp (original)
+++ sandbox/itl/boost/itl/concept/interval/base.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -19,7 +19,7 @@
{
typedef typename Type::interval_type interval_type;
typedef typename Type::segment_type segment_type;
- return segment_type(itl::construct<interval_type>(element.key), element.data);
+ return segment_type(itl::construct<interval_type>(element.key), element.data);
}
namespace segmental
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -42,7 +42,7 @@
inline typename enable_if<is_interval_container<Type>, bool>::type
operator < (const Type& left, const Type& right)
{
- typedef typename Type::segment_compare segment_compare;
+ typedef typename Type::segment_compare segment_compare;
return std::lexicographical_compare(
left.begin(), left.end(), right.begin(), right.end(),
segment_compare()
@@ -111,38 +111,65 @@
//= Size<IntervalSet|IntervalMap>
//==============================================================================
template<class Type>
-typename enable_if<is_interval_container<Type>, typename Type::size_type>::type
+typename enable_if
+< mpl::and_< is_interval_container<Type>
+ , is_discrete<typename Type::domain_type> >
+, typename Type::size_type
+>::type
cardinality(const Type& object)
{
- using namespace boost::mpl;
- typedef typename Type::domain_type domain_type;
+ typedef typename Type::size_type size_type;
+ typedef typename Type::interval_type interval_type;
- return if_<
- bool_<is_continuous<domain_type>::value>,
- continuous_interval_container,
- discrete_interval_container
- >
- ::type::cardinality(object);
+ size_type size = neutron<size_type>::value();
+ ITL_const_FORALL(typename Type, it, object)
+ size += itl::cardinality(key_value<Type>(it));
+ return size;
+
+}
+
+template<class Type>
+typename enable_if
+< mpl::and_< is_interval_container<Type>
+ , mpl::not_<is_discrete<typename Type::domain_type> > >
+, typename Type::size_type
+>::type
+cardinality(const Type& object)
+{
+ typedef typename Type::size_type size_type;
+ typedef typename Type::interval_type interval_type;
+
+ size_type size = neutron<size_type>::value();
+ size_type interval_size;
+ ITL_const_FORALL(typename Type, it, object)
+ {
+ interval_size = itl::cardinality(key_value<Type>(it));
+ if(interval_size == infinity<size_type>::value())
+ return interval_size;
+ else
+ size += interval_size;
+ }
+ return size;
}
template<class Type>
inline typename enable_if<is_interval_container<Type>, typename Type::size_type>::type
size(const Type& object)
{
- return itl::cardinality(object);
+ return itl::cardinality(object);
}
template<class Type>
typename enable_if<is_interval_container<Type>, typename Type::difference_type>::type
length(const Type& object)
{
- typedef typename Type::difference_type difference_type;
- typedef typename Type::const_iterator const_iterator;
+ typedef typename Type::difference_type difference_type;
+ typedef typename Type::const_iterator const_iterator;
difference_type length = neutron<difference_type>::value();
- const_iterator it_ = object.begin();
+ const_iterator it_ = object.begin();
- while(it_ != object.end())
- length += itl::length(key_value<Type>(it_++));
+ while(it_ != object.end())
+ length += itl::length(key_value<Type>(it_++));
return length;
}
@@ -150,7 +177,7 @@
typename enable_if<is_interval_container<Type>, std::size_t>::type
interval_count(const Type& object)
{
- return itl::iterative_size(object);
+ return itl::iterative_size(object);
}
//==============================================================================
@@ -717,7 +744,7 @@
typename Type::element_iterator>::type
elements_begin(Type& object)
{
- return typename Type::element_iterator(object.begin());
+ return typename Type::element_iterator(object.begin());
}
template<class Type>
@@ -737,7 +764,7 @@
typename Type::element_const_iterator>::type
elements_begin(const Type& object)
{
- return typename Type::element_const_iterator(object.begin());
+ return typename Type::element_const_iterator(object.begin());
}
template<class Type>
@@ -747,7 +774,7 @@
typename Type::element_const_iterator>::type
elements_end(const Type& object)
{
- return typename Type::element_const_iterator(object.end());
+ return typename Type::element_const_iterator(object.end());
}
//--------------------------------------------------------------------------
@@ -760,7 +787,7 @@
typename Type::element_reverse_iterator>::type
elements_rbegin(Type& object)
{
- return typename Type::element_reverse_iterator(object.rbegin());
+ return typename Type::element_reverse_iterator(object.rbegin());
}
template<class Type>
@@ -770,7 +797,7 @@
typename Type::element_reverse_iterator>::type
elements_rend(Type& object)
{
- return typename Type::element_reverse_iterator(object.rend());
+ return typename Type::element_reverse_iterator(object.rend());
}
template<class Type>
@@ -780,7 +807,7 @@
typename Type::element_const_reverse_iterator>::type
elements_rbegin(const Type& object)
{
- return typename Type::element_const_reverse_iterator(object.rbegin());
+ return typename Type::element_const_reverse_iterator(object.rbegin());
}
template<class Type>
@@ -790,7 +817,7 @@
typename Type::element_const_reverse_iterator>::type
elements_rend(const Type& object)
{
- return typename Type::element_const_reverse_iterator(object.rend());
+ return typename Type::element_const_reverse_iterator(object.rend());
}
//==============================================================================
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -77,7 +77,7 @@
, bool>::type
contains(const Type& super, const CoType& sub)
{
- return true;
+ return true;
}
//------------------------------------------------------------------------------
@@ -140,7 +140,7 @@
typename enable_if<is_interval_map<Type>, Type>::type&
add(Type& object, const typename Type::element_type& operand)
{
- return itl::add(object, make_segment<Type>(operand));
+ return itl::add(object, make_segment<Type>(operand));
}
//------------------------------------------------------------------------------
@@ -171,7 +171,7 @@
inline typename enable_if<is_interval_map<Type>, Type>::type&
insert(Type& object, const typename Type::element_type& operand)
{
- return itl::insert(object, make_segment<Type>(operand));
+ return itl::insert(object, make_segment<Type>(operand));
}
//------------------------------------------------------------------------------
@@ -203,8 +203,8 @@
typename enable_if<is_interval_map<Type>, Type>::type&
erase(Type& object, const typename Type::domain_type& operand)
{
- typedef typename Type::interval_type interval_type;
- return itl::erase(object, itl::construct<interval_type>(operand));
+ typedef typename Type::interval_type interval_type;
+ return itl::erase(object, itl::construct<interval_type>(operand));
}
//------------------------------------------------------------------------------
@@ -221,7 +221,7 @@
inline typename enable_if<is_interval_map<Type>, Type>::type&
erase(Type& object, const typename Type::element_type& operand)
{
- return itl::erase(object, make_segment<Type>(operand));
+ return itl::erase(object, make_segment<Type>(operand));
}
//==============================================================================
@@ -241,7 +241,7 @@
typename enable_if<is_interval_map<Type>, Type>::type&
subtract(Type& object, const typename Type::element_type& operand)
{
- return itl::subtract(object, make_segment<Type>(operand));
+ return itl::subtract(object, make_segment<Type>(operand));
}
//------------------------------------------------------------------------------
@@ -293,7 +293,7 @@
add_intersection(Type& section, const Type& object,
const typename Type::element_type& operand)
{
- typedef typename Type::segment_type segment_type;
+ typedef typename Type::segment_type segment_type;
object.add_intersection(section, make_segment<Type>(operand));
}
@@ -461,7 +461,7 @@
inline typename enable_if<is_interval_map<Type>, Type>::type&
flip(Type& object, const typename Type::element_type& operand)
{
- return itl::flip(object, make_segment<Type>(operand));
+ return itl::flip(object, make_segment<Type>(operand));
}
//------------------------------------------------------------------------------
@@ -483,6 +483,10 @@
//------------------------------------------------------------------------------
//- T& flip(T&, c P&) T:{M} P:{M'} total enricher
//------------------------------------------------------------------------------
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127) // conditional expression is constant
+#endif
template<class Type, class OperandT>
typename enable_if< mpl::and_< is_total<Type>
, mpl::not_<absorbs_neutrons<Type> >
@@ -503,6 +507,10 @@
return object;
}
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
//------------------------------------------------------------------------------
//- T& flip(T&, c P&) T:{M} P:{M'} partial
Modified: sandbox/itl/boost/itl/concept/interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/interval_set.hpp (original)
+++ sandbox/itl/boost/itl/concept/interval_set.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -65,15 +65,15 @@
typename enable_if<is_interval_set<Type>, Type>::type&
add(Type& object, const typename Type::segment_type& operand)
{
- return object.add(operand);
+ return object.add(operand);
}
template<class Type>
inline typename enable_if<is_interval_set<Type>, Type>::type&
add(Type& object, const typename Type::element_type& operand)
{
- typedef typename Type::segment_type segment_type;
- return itl::add(object, itl::construct<segment_type>(operand));
+ typedef typename Type::segment_type segment_type;
+ return itl::add(object, itl::construct<segment_type>(operand));
}
//------------------------------------------------------------------------------
@@ -84,7 +84,7 @@
add(Type& object, typename Type::iterator prior,
const typename Type::segment_type& operand)
{
- return object.add(prior, operand);
+ return object.add(prior, operand);
}
//==============================================================================
@@ -113,7 +113,7 @@
template<class Type>
typename enable_if<is_interval_set<Type>, Type>::type&
insert(Type& object, const typename Type::iterator prior,
- const typename Type::segment_type& operand)
+ const typename Type::segment_type& operand)
{
return itl::add(object, prior, operand);
}
@@ -155,8 +155,8 @@
inline typename enable_if<is_interval_set<Type>, Type>::type&
subtract(Type& object, const typename Type::element_type& operand)
{
- typedef typename Type::segment_type segment_type;
- return itl::subtract(object, itl::construct<segment_type>(operand));
+ typedef typename Type::segment_type segment_type;
+ return itl::subtract(object, itl::construct<segment_type>(operand));
}
//==============================================================================
Modified: sandbox/itl/boost/itl/concept/interval_set_value.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/interval_set_value.hpp (original)
+++ sandbox/itl/boost/itl/concept/interval_set_value.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -10,6 +10,7 @@
#include <boost/utility/enable_if.hpp>
#include <boost/itl/type_traits/is_interval_container.hpp>
+#include <boost/itl/concept/interval.hpp>
namespace boost{ namespace itl
{
@@ -21,8 +22,8 @@
inline typename enable_if<is_interval_set<Type>, typename Type::codomain_type>::type
co_value(Iterator value_)
{
- typedef typename Type::codomain_type codomain_type;
- return itl::is_empty(*value_)? codomain_type() : (*value_).lower();
+ typedef typename Type::codomain_type codomain_type;
+ return itl::is_empty(*value_)? codomain_type() : (*value_).lower();
}
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/concept/map_value.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/map_value.hpp (original)
+++ sandbox/itl/boost/itl/concept/map_value.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -20,22 +20,22 @@
inline typename enable_if<is_map<Type>, const typename Type::key_type>::type&
key_value(Iterator it_)
{
- return it_->first;
+ return it_->first;
}
template<class Type, class Iterator>
inline typename enable_if<is_map<Type>, const typename Type::codomain_type>::type&
co_value(Iterator it_)
{
- return it_->second;
+ return it_->second;
}
template<class Type>
inline typename enable_if<is_map<Type>, typename Type::value_type>::type
make_value(const typename Type:: key_type& key_val,
- const typename Type::codomain_type& co_val)
+ const typename Type::codomain_type& co_val)
{
- return typename Type::value_type(key_val, co_val);
+ return typename Type::value_type(key_val, co_val);
}
Modified: sandbox/itl/boost/itl/concept/set_value.hpp
==============================================================================
--- sandbox/itl/boost/itl/concept/set_value.hpp (original)
+++ sandbox/itl/boost/itl/concept/set_value.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -20,15 +20,15 @@
inline typename enable_if<is_set<Type>, const typename Type::key_type>::type&
key_value(Iterator it_)
{
- return *it_;
+ return *it_;
}
template<class Type>
inline typename enable_if<is_set<Type>, typename Type::value_type>::type
make_value(const typename Type:: key_type& key_val,
- const typename Type::codomain_type& )
+ const typename Type::codomain_type& )
{
- return typename Type::value_type(key_val);
+ return typename Type::value_type(key_val);
}
Modified: sandbox/itl/boost/itl/continuous_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/continuous_interval.hpp (original)
+++ sandbox/itl/boost/itl/continuous_interval.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -8,11 +8,14 @@
#ifndef BOOST_ITL_CONTINUOUS_INTERVAL_HPP_JOFA_100327
#define BOOST_ITL_CONTINUOUS_INTERVAL_HPP_JOFA_100327
+#include <functional>
+#include <boost/static_assert.hpp>
+#include <boost/concept/assert.hpp>
+#include <boost/itl/detail/concept_check.hpp>
#include <boost/itl/type_traits/value_size.hpp>
#include <boost/itl/type_traits/type_to_string.hpp>
#include <boost/itl/type_traits/is_continuous.hpp>
#include <boost/itl/type_traits/is_continuous_interval.hpp>
-#include <boost/itl/detail/base_interval.hpp>
#include <boost/itl/interval_bounds.hpp>
#include <boost/itl/concept/interval.hpp>
@@ -21,7 +24,7 @@
template <class DomainT,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT)>
-class continuous_interval : public base_interval<DomainT,Compare>
+class continuous_interval
{
public:
typedef continuous_interval<DomainT,Compare> type;
Modified: sandbox/itl/boost/itl/detail/associated_value.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/associated_value.hpp (original)
+++ sandbox/itl/boost/itl/detail/associated_value.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -21,9 +21,9 @@
, mpl::and_<is_map<Type>, is_map<CoType> > >,
bool>::type
co_equal(typename Type::const_iterator left_, typename CoType::const_iterator right_,
- const Type* = 0, const CoType* = 0)
+ const Type* = 0, const CoType* = 0)
{
- return co_value<Type>(left_) == co_value<CoType>(right_);
+ return co_value<Type>(left_) == co_value<CoType>(right_);
}
template<class Type, class CoType>
@@ -31,9 +31,9 @@
, mpl::not_<mpl::and_<is_map<Type>, is_map<CoType> > > >,
bool>::type
co_equal(typename Type::const_iterator, typename CoType::const_iterator,
- const Type* = 0, const CoType* = 0)
+ const Type* = 0, const CoType* = 0)
{
- return true;
+ return true;
}
Deleted: sandbox/itl/boost/itl/detail/base_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/base_interval.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
+++ (empty file)
@@ -1,78 +0,0 @@
-/*-----------------------------------------------------------------------------+
-Copyright (c) 2010-2010: Joachim Faulhaber
-+------------------------------------------------------------------------------+
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENCE.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt)
-+-----------------------------------------------------------------------------*/
-#ifndef BOOST_ITL_BASE_INTERVAL_HPP_JOFA_100323
-#define BOOST_ITL_BASE_INTERVAL_HPP_JOFA_100323
-
-#include <functional>
-#include <boost/call_traits.hpp>
-#include <boost/concept_check.hpp>
-#include <boost/itl/detail/design_config.hpp>
-#include <boost/itl/type_traits/difference_type_of.hpp>
-#include <boost/itl/type_traits/size_type_of.hpp>
-
-namespace boost{namespace itl
-{
-
-template <class DomainT, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT)>
-struct base_interval
-{
- //==========================================================================
- //= Associated types
- //==========================================================================
- typedef base_interval<DomainT,Compare> type;
-
- //--------------------------------------------------------------------------
- //- Associated types: Data
- //--------------------------------------------------------------------------
- /// The domain type of the interval
- typedef DomainT domain_type;
- /// The codomaintype is the same as domain_type
- typedef DomainT codomain_type;
- /// The element type of the interval
- typedef DomainT element_type;
- /// The segment type is the interval's type
- typedef type segment_type;
- /// The interval type is the interval's type
- typedef type interval_type;
-
- //--------------------------------------------------------------------------
- //- Associated types: Implementation and stl related
- //--------------------------------------------------------------------------
- typedef DomainT key_type;
- typedef DomainT data_type;
- typedef DomainT value_type;
-
- /// Compare order on the data
- typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
- typedef domain_compare key_compare;
-
- /// The difference type of an interval which is sometimes different form the domain_type
- typedef typename itl::difference_type_of<DomainT>::type difference_type;
-
- /// The size type of an interval which is mostly std::size_t
- typedef typename itl::size_type_of<DomainT>::type size_type;
-
- typedef typename boost::call_traits<DomainT>::param_type domain_param;
-
- /** Less compare of interval elements. */
- inline static bool domain_less(domain_param left, domain_param right)
- { return domain_compare()(left, right) ;}
-
- /** Less or equal compare of interval elements. */
- inline static bool domain_less_equal(domain_param left, domain_param right)
- { return !domain_compare()(right, left );}
-
- /** Equality compare of interval elements. */
- inline static bool domain_equal(domain_param left, domain_param right)
- { return !domain_compare()(left, right) && !domain_compare()(right, left);}
-};
-
-}} // namespace itl boost
-
-#endif
-
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -12,7 +12,6 @@
#include <boost/itl/type_traits/is_map.hpp>
#include <boost/itl/detail/notate.hpp>
#include <boost/itl/type_traits/neutron.hpp>
-#include <boost/itl/interval.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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -164,11 +164,12 @@
{
typedef segment_adapter type;
typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type;
- typedef typename interval_type::difference_type domain_difference_type;
typedef DomainT domain_type;
typedef std::pair<DomainT, CodomainT> element_type;
typedef CodomainT codomain_type;
typedef mapped_reference<DomainT, CodomainT> transit_type;
+ typedef typename difference_type_of<interval_traits<interval_type> >::type
+ domain_difference_type;
static domain_type first (const SegmentIteratorT& leaper){ return leaper->first.first(); }
static domain_type last (const SegmentIteratorT& leaper){ return leaper->first.last(); }
@@ -188,14 +189,15 @@
template<class SegmentIteratorT, ITL_INTERVAL(ITL_COMPARE) Interval>
struct segment_adapter
{
- typedef segment_adapter type;
+ typedef segment_adapter type;
typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) segment_type;
- typedef segment_type interval_type;
- typedef typename interval_type::difference_type domain_difference_type;
- typedef typename interval_type::domain_type domain_type;
- typedef domain_type codomain_type;
- typedef domain_type element_type;
- typedef domain_type& transit_type;
+ typedef segment_type interval_type;
+ typedef typename interval_type::domain_type domain_type;
+ typedef domain_type codomain_type;
+ typedef domain_type element_type;
+ typedef domain_type& transit_type;
+ typedef typename difference_type_of<interval_traits<interval_type> >::type
+ domain_difference_type;
static domain_type first (const SegmentIteratorT& leaper){ return leaper->first(); }
static domain_type last (const SegmentIteratorT& leaper){ return leaper->last(); }
@@ -213,13 +215,14 @@
template < class SegmentIteratorT, class CodomainT, ITL_INTERVAL(ITL_COMPARE) Interval >
struct segment_adapter<SegmentIteratorT, std::pair<ITL_INTERVAL_TYPE(Interval,DomainT,Compare)const, CodomainT> >
{
- typedef segment_adapter type;
- typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type;
- typedef typename interval_type::domain_type domain_type;
- typedef typename interval_type::difference_type domain_difference_type;
- typedef CodomainT codomain_type;
- typedef std::pair<domain_type, codomain_type> element_type;
- typedef mapped_reference<domain_type, CodomainT> transit_type;
+ typedef segment_adapter type;
+ typedef ITL_INTERVAL_TYPE(Interval,DomainT,Compare) interval_type;
+ typedef typename interval_type::domain_type domain_type;
+ typedef CodomainT codomain_type;
+ typedef std::pair<domain_type, codomain_type> element_type;
+ typedef mapped_reference<domain_type, CodomainT> transit_type;
+ typedef typename difference_type_of<interval_traits<interval_type> >::type
+ domain_difference_type;
static domain_type first (const SegmentIteratorT& leaper){ return leaper->first.first(); }
static domain_type last (const SegmentIteratorT& leaper){ return leaper->first.last(); }
@@ -246,16 +249,17 @@
>
{
public:
- typedef element_iterator type;
+ typedef element_iterator type;
typedef SegmentIteratorT segment_iterator;
typedef typename SegmentIteratorT::value_type segment_type;
typedef typename first_element<segment_type>::type interval_type;
- typedef typename interval_type::difference_type domain_difference_type;
typedef typename elemental<segment_type>::type element_type;
typedef typename elemental<segment_type>::domain_type domain_type;
typedef typename elemental<segment_type>::codomain_type codomain_type;
typedef typename elemental<segment_type>::transit_type transit_type;
typedef transit_type value_type;
+ typedef typename difference_type_of<interval_traits<interval_type> >::type
+ domain_difference_type;
private:
typedef typename segment_adapter<segment_iterator,segment_type>::type adapt;
Added: sandbox/itl/boost/itl/detail/exclusive_less_than.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl/detail/exclusive_less_than.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -0,0 +1,31 @@
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2010-2010: Joachim Faulhaber
++------------------------------------------------------------------------------+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENCE.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
++-----------------------------------------------------------------------------*/
+#ifndef BOOST_ITL_DETAIL_EXCLUSIVE_LESS_THAN_HPP_JOFA_100929
+#define BOOST_ITL_DETAIL_EXCLUSIVE_LESS_THAN_HPP_JOFA_100929
+
+#include <boost/itl/concept/interval.hpp>
+
+namespace boost{ namespace itl
+{
+
+/// Comparison functor on intervals implementing an overlap free less
+template <class IntervalT>
+struct exclusive_less_than
+{
+ /** Operator <tt>operator()</tt> implements a strict weak ordering on intervals. */
+ bool operator()(const IntervalT& left, const IntervalT& right)const
+ {
+ return itl::exclusive_less(left, right);
+ }
+};
+
+}} // namespace boost itl
+
+#endif
+
+
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -16,7 +16,6 @@
#include <boost/itl/detail/notate.hpp>
#include <boost/itl/detail/relation_state.hpp>
#include <boost/itl/type_traits/neutron.hpp>
-#include <boost/itl/interval.hpp>
#include <boost/itl/interval_combining_style.hpp>
#include <boost/itl/detail/element_comparer.hpp>
#include <boost/itl/detail/interval_subset_comparer.hpp>
@@ -41,10 +40,10 @@
++next_;
const typename IntervalMapT::codomain_type& co_value
- = itl::co_value<IntervalMapT>(first);
+ = itl::co_value<IntervalMapT>(first);
while(it_ != past)
{
- if(itl::co_value<IntervalMapT>(next_) != co_value)
+ if(itl::co_value<IntervalMapT>(next_) != co_value)
return false;
if(!itl::touches(key_value<IntervalMapT>(it_++),
key_value<IntervalMapT>(next_++)))
Modified: sandbox/itl/boost/itl/detail/interval_morphism.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/interval_morphism.hpp (original)
+++ sandbox/itl/boost/itl/detail/interval_morphism.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -23,8 +23,8 @@
{
ITL_const_FORALL(typename IntervalContainerT, itv_, src)
{
- const typename IntervalContainerT::key_type& itv = itl::key_value<IntervalContainerT>(itv_);
- typename IntervalContainerT::codomain_type coval = itl::co_value<IntervalContainerT>(itv_);
+ const typename IntervalContainerT::key_type& itv = itl::key_value<IntervalContainerT>(itv_);
+ typename IntervalContainerT::codomain_type coval = itl::co_value<IntervalContainerT>(itv_);
for(typename IntervalContainerT::domain_type element = first(itv); element <= last(itv); ++element)
insert(result, itl::make_value<ElementContainerT>(element, coval));
@@ -34,7 +34,7 @@
template <typename IntervalContainerT, typename ElementContainerT>
void cluster(IntervalContainerT& result, const ElementContainerT& src)
{
- typedef typename IntervalContainerT::key_type key_type;
+ typedef typename IntervalContainerT::key_type key_type;
ITL_const_FORALL(typename ElementContainerT, element_, src)
{
const typename ElementContainerT::key_type& key = key_value<ElementContainerT>(element_);
@@ -67,7 +67,7 @@
{
void operator()(JointType& joint, SplitType& split)
{
- itl::join(split);
+ itl::join(split);
ITL_FORALL(typename SplitType, split_, split)
joint.insert(*split_);
}
@@ -78,7 +78,7 @@
{
void operator()(AbsorberType& absorber, EnricherType& enricher)
{
- itl::absorb_neutrons(enricher);
+ itl::absorb_neutrons(enricher);
ITL_FORALL(typename EnricherType, enricher_, enricher)
absorber.insert(*enricher_);
}
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -16,7 +16,6 @@
#include <boost/itl/type_traits/is_combinable.hpp>
#include <boost/itl/concept/set_value.hpp>
#include <boost/itl/concept/map_value.hpp>
-#include <boost/itl/interval.hpp>
#include <boost/itl/interval_combining_style.hpp>
#include <boost/itl/detail/element_comparer.hpp>
#include <boost/itl/detail/interval_subset_comparer.hpp>
@@ -25,54 +24,6 @@
namespace boost{namespace itl
{
-template <class IntervalContainerT>
-typename IntervalContainerT::size_type continuous_cardinality(const IntervalContainerT& object)
-{
- typedef typename IntervalContainerT::size_type size_type;
- typedef typename IntervalContainerT::interval_type interval_type;
-
- size_type size = neutron<size_type>::value();
- size_type interval_size;
- ITL_const_FORALL(typename IntervalContainerT, it, object)
- {
- interval_size = itl::cardinality(key_value<IntervalContainerT>(it));
- if(interval_size == infinity<size_type>::value())
- return interval_size;
- else
- size += interval_size;
- }
- return size;
-}
-
-template <class IntervalContainerT>
-typename IntervalContainerT::size_type discrete_cardinality(const IntervalContainerT& object)
-{
- typedef typename IntervalContainerT::size_type size_type;
- typedef typename IntervalContainerT::interval_type interval_type;
-
- size_type size = neutron<size_type>::value();
- ITL_const_FORALL(typename IntervalContainerT, it, object)
- size += discrete_interval_<interval_type>::cardinality(key_value<IntervalContainerT>(it));
- return size;
-}
-
-struct continuous_interval_container
-{
- template<class IntervalContainerT>
- static typename IntervalContainerT::size_type
- cardinality(const IntervalContainerT& cont)
- { return continuous_cardinality(cont); }
-};
-
-struct discrete_interval_container
-{
- template<class IntervalContainerT>
- static typename IntervalContainerT::size_type
- cardinality(const IntervalContainerT& cont)
- { return discrete_cardinality(cont); }
-};
-
-
namespace Interval_Set
{
@@ -284,7 +235,7 @@
{
typedef typename Type::interval_type interval_type;
interval_type right_interval = key_value<Type>(right_);
- ((typename Type::base_type&)object).erase(right_); //JODO
+ ((typename Type::base_type&)object).erase(right_); //JODO
const_cast<interval_type&>(key_value<Type>(left_))
= hull(key_value<Type>(left_), right_interval);
}
@@ -430,14 +381,14 @@
inline static iterator add_over
(Type& object, const interval_type& addend, iterator last_)
{
- iterator joined_ = join_under(object, addend, last_);
+ iterator joined_ = join_under(object, addend, last_);
return join_neighbours(object, joined_);
}
inline static iterator add_over
(Type& object, const interval_type& addend)
{
- iterator joined_ = join_under(object, addend);
+ iterator joined_ = join_under(object, addend);
return join_neighbours(object, joined_);
}
};
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -15,7 +15,6 @@
#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>
-#include <boost/itl/interval.hpp>
#include <boost/itl/concept/interval_set_value.hpp>
namespace boost{namespace itl
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -27,14 +27,14 @@
template <class ObjectT, class CoObjectT>
bool intersects(const ObjectT& left, const CoObjectT& right)
{
- typedef typename CoObjectT::const_iterator co_iterator;
+ typedef typename CoObjectT::const_iterator co_iterator;
co_iterator right_common_lower_, right_common_upper_;
if(!Set::common_range(right_common_lower_, right_common_upper_, right, left))
return false;
co_iterator right_ = right_common_lower_;
while(right_ != right_common_upper_)
- if(itl::intersects(left, key_value<CoObjectT>(right_++)))
+ if(itl::intersects(left, key_value<CoObjectT>(right_++)))
return true;
return false;
Modified: sandbox/itl/boost/itl/detail/set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/set_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/set_algo.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -33,13 +33,13 @@
// lwb and upb are iterators of x1 marking the lower and upper bound of
// the common range of x1 and x2.
typedef typename ConstObjectT::const_iterator ConstObject_iterator;
- // ObjectT may be const or non const.
- typedef typename remove_const<ObjectT>::type PureObjectT;
+ // ObjectT may be const or non const.
+ typedef typename remove_const<ObjectT>::type PureObjectT;
lwb = x1.end();
upb = x1.end();
- if(itl::is_empty(x1) || itl::is_empty(x2))
+ if(itl::is_empty(x1) || itl::is_empty(x2))
return false;
IteratorT x1_fst_ = x1.begin();
@@ -50,10 +50,10 @@
typename ObjectT::key_compare key_less;
if(key_less(itl::key_value< PureObjectT>(x1_lst_),
- itl::key_value<ConstObjectT>(x2_fst_))) // {x1} {x2}
+ itl::key_value<ConstObjectT>(x2_fst_))) // {x1} {x2}
return false;
- if(key_less(itl::key_value<ConstObjectT>(x2_lst_),
- itl::key_value< PureObjectT>(x1_fst_))) // {x2} {x1}
+ if(key_less(itl::key_value<ConstObjectT>(x2_lst_),
+ itl::key_value< PureObjectT>(x1_fst_))) // {x2} {x1}
return false;
// We do have a common range
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -15,7 +15,6 @@
#include <boost/itl/type_traits/neutron.hpp>
#include <boost/itl/type_traits/is_concept_equivalent.hpp>
#include <boost/itl/type_traits/is_element_container.hpp>
-#include <boost/itl/interval.hpp>
#include <boost/itl/concept/interval_set_value.hpp>
#include <boost/itl/concept/map_value.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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -8,13 +8,14 @@
#ifndef BOOST_ITL_DISCRETE_INTERVAL_HPP_JOFA_100403
#define BOOST_ITL_DISCRETE_INTERVAL_HPP_JOFA_100403
+#include <functional>
#include <boost/static_assert.hpp>
+#include <boost/concept/assert.hpp>
#include <boost/itl/type_traits/succ_pred.hpp>
#include <boost/itl/type_traits/value_size.hpp>
#include <boost/itl/type_traits/type_to_string.hpp>
#include <boost/itl/type_traits/is_continuous.hpp>
#include <boost/itl/type_traits/is_discrete_interval.hpp>
-#include <boost/itl/detail/base_interval.hpp>
#include <boost/itl/interval_bounds.hpp>
#include <boost/itl/concept/interval.hpp>
@@ -23,7 +24,7 @@
template <class DomainT,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT)>
-class discrete_interval : public base_interval<DomainT,Compare>
+class discrete_interval
{
public:
typedef discrete_interval<DomainT,Compare> type;
Modified: sandbox/itl/boost/itl/dynamic_interval_traits.hpp
==============================================================================
--- sandbox/itl/boost/itl/dynamic_interval_traits.hpp (original)
+++ sandbox/itl/boost/itl/dynamic_interval_traits.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -23,7 +23,6 @@
{
typedef typename Type::domain_type domain_type;
typedef typename Type::domain_compare domain_compare;
- typedef typename boost::call_traits<domain_type>::param_type domain_param;
static Type construct(const domain_type& lo, const domain_type& up, interval_bounds bounds);
static Type construct_bounded(const bounded_value<domain_type>& lo,
Modified: sandbox/itl/boost/itl/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval.hpp (original)
+++ sandbox/itl/boost/itl/interval.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -14,6 +14,7 @@
#include <limits>
#include <string>
#include <boost/assert.hpp>
+#include <boost/call_traits.hpp>
#include <boost/static_assert.hpp>
#include <boost/concept_check.hpp>
#include <boost/next_prior.hpp>
@@ -22,7 +23,7 @@
#include <boost/mpl/assert.hpp>
#include <boost/itl/detail/notate.hpp>
#include <boost/itl/detail/design_config.hpp>
-#include <boost/itl/detail/base_interval.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/infinity.hpp>
@@ -89,7 +90,7 @@
/** \brief A class template for intervals */
template <class DomainT, ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT)>
-class interval : public base_interval<DomainT,Compare>
+class interval
{
public:
//==========================================================================
@@ -1041,14 +1042,6 @@
{ return !(lhs < rhs); }
-/// Comparison functor on intervals implementing an overlap free less
-template <class IntervalT>
-struct exclusive_less_than {
- /** Operator <tt>operator()</tt> implements a strict weak ordering on intervals. */
- bool operator()(const IntervalT& left, const IntervalT& right)const
- { return exclusive_less(left, right); }
-};
-
/** Returns true if the intersection of \c left and \c right is not empty. */
template <class DomainT, ITL_COMPARE Compare>
inline bool intersects(const itl::interval<DomainT,Compare>& left,
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -1349,10 +1349,6 @@
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
}} // namespace itl boost
#endif
Modified: sandbox/itl/boost/itl/interval_base_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_set.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -10,15 +10,17 @@
#define BOOST_ITL_INTERVAL_BASE_SET_H_JOFA_990223
#include <limits>
+#include <boost/next_prior.hpp>
#include <boost/itl/type_traits/interval_type_default.hpp>
+#include <boost/itl/type_traits/infinity.hpp>
#include <boost/itl/type_traits/is_interval_joiner.hpp>
#include <boost/itl/type_traits/is_interval_separator.hpp>
#include <boost/itl/type_traits/is_interval_splitter.hpp>
#include <boost/itl/detail/interval_set_algo.hpp>
-#include <boost/itl/set.hpp>
-#include <boost/itl/interval.hpp>
+#include <boost/itl/detail/exclusive_less_than.hpp>
#include <boost/itl/rightopen_interval.hpp>
#include <boost/itl/continuous_interval.hpp>
+#include <boost/itl/set.hpp>
#include <boost/itl/detail/notate.hpp>
#include <boost/itl/detail/element_iterator.hpp>
@@ -40,7 +42,19 @@
interval_count(const Type&);
template<class Type>
-typename enable_if<is_interval_container<Type>, typename Type::size_type>::type
+typename enable_if
+< mpl::and_< is_interval_container<Type>
+ , is_discrete<typename Type::domain_type> >
+, typename Type::size_type
+>::type
+cardinality(const Type&);
+
+template<class Type>
+typename enable_if
+< mpl::and_< is_interval_container<Type>
+ , mpl::not_<is_discrete<typename Type::domain_type> > >
+, typename Type::size_type
+>::type
cardinality(const Type&);
template<class Type>
@@ -148,7 +162,6 @@
//--------------------------------------------------------------------------
/// The domain type of the set
typedef DomainT domain_type;
- typedef typename boost::call_traits<DomainT>::param_type domain_param;
/// The codomaintype is the same as domain_type
typedef DomainT codomain_type;
Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -59,6 +59,7 @@
typedef typename base_type::interval_mapping_type interval_mapping_type;
typedef typename base_type::ImplMapT ImplMapT;
+ typedef typename base_type::size_type size_type;
typedef typename base_type::codomain_combine codomain_combine;
typedef interval_set<DomainT,Compare,Interval,Alloc> interval_set_type;
Modified: sandbox/itl/boost/itl/interval_traits.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_traits.hpp (original)
+++ sandbox/itl/boost/itl/interval_traits.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -8,18 +8,28 @@
#ifndef BOOST_ITL_INTERVAL_TRAITS_HPP_JOFA_100926
#define BOOST_ITL_INTERVAL_TRAITS_HPP_JOFA_100926
+#include <boost/itl/type_traits/domain_type_of.hpp>
+#include <boost/itl/type_traits/difference_type_of.hpp>
+#include <boost/itl/type_traits/size_type_of.hpp>
namespace boost{ namespace itl
{
+template<class Type> struct interval_traits;
+
+template<class Type>
+struct domain_type_of<interval_traits<Type> >
+{
+ typedef typename interval_traits<Type>::domain_type type;
+};
+
//------------------------------------------------------------------------------
//- Adapter class
//------------------------------------------------------------------------------
-template<class Type>
-struct interval_traits
+template<class Type> struct interval_traits
{
- typedef typename Type::domain_type domain_type;
- typedef typename Type::domain_compare domain_compare;
+ typedef interval_traits type;
+ typedef typename domain_type_of<Type>::type domain_type;
static Type construct(const domain_type& lo, const domain_type& up);
@@ -27,6 +37,19 @@
static domain_type lower(const Type& inter_val);
};
+template<class Type>
+struct difference_type_of<interval_traits<Type> >
+{
+ typedef typename interval_traits<Type>::domain_type domain_type;
+ typedef typename difference_type_of<domain_type>::type type;
+};
+
+template<class Type>
+struct size_type_of<interval_traits<Type> >
+{
+ typedef typename interval_traits<Type>::domain_type domain_type;
+ typedef typename size_type_of<domain_type>::type type;
+};
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -333,13 +333,6 @@
::add_intersection(section, *this, key_value_pair);
}
- /** Returns true, if there is an intersection of \c operand and \c *this map. */
- //CL template<class OperandT>
- //bool intersects(const OperandT& operand)const
- //{
- // return itl::intersects(*this, operand);
- //}
-
//==========================================================================
//= Symmetric difference
//==========================================================================
@@ -438,8 +431,8 @@
template<class Type>
struct on_codomain_model<Type, false, false>
{ // !codomain_is_set, !absorbs_neutrons
- static void subtract(Type& object, typename Type::iterator it_,
- const typename Type::codomain_type& )
+ static void subtract(Type&, typename Type::iterator it_,
+ const typename Type::codomain_type& )
{ it_->second = neutron<typename Type::codomain_type>::value(); }
};
Modified: sandbox/itl/boost/itl/rightopen_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/rightopen_interval.hpp (original)
+++ sandbox/itl/boost/itl/rightopen_interval.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -8,6 +8,8 @@
#ifndef BOOST_ITL_RIGHTOPEN_INTERVAL_HPP_JOFA_100323
#define BOOST_ITL_RIGHTOPEN_INTERVAL_HPP_JOFA_100323
+#include <functional>
+#include <boost/concept/assert.hpp>
#include <boost/itl/type_traits/value_size.hpp>
#include <boost/itl/type_traits/type_to_string.hpp>
#include <boost/itl/interval_bounds.hpp> //JODO CL rightopen_interval ought to be independent on this,
@@ -15,7 +17,6 @@
//dependencies here. There's also that point on generation.
//Two partitions of interval_functions
// (dependen on i_b ( independent on i_b ))
-#include <boost/itl/detail/base_interval.hpp>
#include <boost/itl/concept/interval.hpp>
namespace boost{namespace itl
@@ -23,7 +24,7 @@
template <class DomainT,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT)>
-class rightopen_interval : public base_interval<DomainT,Compare>
+class rightopen_interval
{
public:
typedef rightopen_interval<DomainT,Compare> type;
Modified: sandbox/itl/boost/itl/set.hpp
==============================================================================
--- sandbox/itl/boost/itl/set.hpp (original)
+++ sandbox/itl/boost/itl/set.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -19,7 +19,7 @@
#endif
#include <string>
-#include <boost/call_traits.hpp>
+//CL #include <boost/call_traits.hpp>
#include <boost/itl/detail/design_config.hpp>
#include <boost/itl/detail/concept_check.hpp>
#include <boost/itl/type_traits/to_string.hpp>
@@ -56,7 +56,6 @@
public:
typedef DomainT domain_type;
- typedef typename boost::call_traits<DomainT>::param_type domain_param;
typedef DomainT codomain_type;
typedef DomainT element_type;
typedef DomainT key_type;
@@ -192,22 +191,8 @@
{ return itl::subtract(*this, element); }
//==========================================================================
- //= Intersection, symmetric difference
+ //= Symmetric difference
//==========================================================================
- /** Add \c element to \c section, if \c element is in \c *this set */
- //CL . . . void add_intersection(set& section, const element_type& element)const
- //{ itl::add_intersection(section, *this, element); }
-
- /** The intersection of set \c sectant with \c *this set is added
- to \c section. */
- //void add_intersection(set& section, const set& sectant)const
- //{ itl::add_intersection(section, *this, sectant); }
-
- /** Returns true, if there is an intersection of \c element and \c *this set.
- Functions \c intersects and \c contains are identical on arguments
- of type \c element_type. Complexity: Logarithmic in container size. */
- //bool intersects(const element_type& element)const { return contains(element); }
-
/** If \c *this set contains \c element it is erased, otherwise it is added. */
set& flip(const element_type& element)
{ return itl::flip(*this, element); }
Modified: sandbox/itl/boost/itl/type_traits/codomain_type_of.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/codomain_type_of.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/codomain_type_of.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -25,25 +25,25 @@
{};
template <class Type, bool has_codomain_type>
- struct get_codomain_type;
+ struct get_codomain_type;
template <class Type>
- struct get_codomain_type<Type, false>
+ struct get_codomain_type<Type, false>
{
- typedef no_type type;
+ typedef no_type type;
};
template <class Type>
- struct get_codomain_type<Type, true>
+ struct get_codomain_type<Type, true>
{
- typedef typename Type::codomain_type type;
+ typedef typename Type::codomain_type type;
};
template <class Type>
- struct codomain_type_of
+ struct codomain_type_of
{
- typedef typename
- get_codomain_type<Type, has_codomain_type<Type>::value>::type type;
+ typedef typename
+ get_codomain_type<Type, has_codomain_type<Type>::value>::type type;
};
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/domain_type_of.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/domain_type_of.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/domain_type_of.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -25,25 +25,25 @@
{};
template <class Type, bool has_domain_type>
- struct get_domain_type;
+ struct get_domain_type;
template <class Type>
- struct get_domain_type<Type, false>
+ struct get_domain_type<Type, false>
{
- typedef no_type type;
+ typedef no_type type;
};
template <class Type>
- struct get_domain_type<Type, true>
+ struct get_domain_type<Type, true>
{
- typedef typename Type::domain_type type;
+ typedef typename Type::domain_type type;
};
template <class Type>
- struct domain_type_of
+ struct domain_type_of
{
- typedef typename
- get_domain_type<Type, has_domain_type<Type>::value>::type type;
+ typedef typename
+ get_domain_type<Type, has_domain_type<Type>::value>::type type;
};
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/element_type_of.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/element_type_of.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/element_type_of.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -25,25 +25,25 @@
{};
template <class Type, bool has_element_type>
- struct get_element_type;
+ struct get_element_type;
template <class Type>
- struct get_element_type<Type, false>
+ struct get_element_type<Type, false>
{
- typedef no_type type;
+ typedef no_type type;
};
template <class Type>
- struct get_element_type<Type, true>
+ struct get_element_type<Type, true>
{
- typedef typename Type::element_type type;
+ typedef typename Type::element_type type;
};
template <class Type>
- struct element_type_of
+ struct element_type_of
{
- typedef typename
- get_element_type<Type, has_element_type<Type>::value>::type type;
+ typedef typename
+ get_element_type<Type, has_element_type<Type>::value>::type type;
};
}} // namespace boost itl
Added: sandbox/itl/boost/itl/type_traits/given.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl/type_traits/given.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -0,0 +1,21 @@
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2010-2010: Joachim Faulhaber
++------------------------------------------------------------------------------+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENCE.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
++-----------------------------------------------------------------------------*/
+#ifndef BOOST_ITL_TYPE_TRAITS_GIVEN_HPP_JOFA_100929
+#define BOOST_ITL_TYPE_TRAITS_GIVEN_HPP_JOFA_100929
+
+namespace boost{ namespace itl
+{
+ template<bool fact> struct given;
+ template<> struct given<false>{static bool then(bool) { return true;}};
+ template<> struct given<true> {static bool then(bool fact){ return fact;}};
+
+}} // namespace boost itl
+
+#endif
+
+
Modified: sandbox/itl/boost/itl/type_traits/has_dynamic_bounds.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/has_dynamic_bounds.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/has_dynamic_bounds.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -18,7 +18,7 @@
{
typedef has_dynamic_bounds<Type> type;
BOOST_STATIC_CONSTANT(bool,
- value = (interval_bound_type<Type>::value == interval_bounds::dynamic));
+ value = (interval_bound_type<Type>::value == interval_bounds::dynamic));
};
template <class Type> struct is_dynamic_bounded //JODO rearrange for all those predicates.
Modified: sandbox/itl/boost/itl/type_traits/has_set_semantics.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/has_set_semantics.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/has_set_semantics.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -20,12 +20,12 @@
{
typedef has_set_semantics<Type> type;
BOOST_STATIC_CONSTANT(bool,
- value = (mpl::or_< is_set<Type>
- , mpl::and_< is_map<Type>
- , has_set_semantics
- <typename codomain_type_of<Type>::type >
- >
- >::value));
+ value = (mpl::or_< is_set<Type>
+ , mpl::and_< is_map<Type>
+ , has_set_semantics
+ <typename codomain_type_of<Type>::type >
+ >
+ >::value));
};
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/interval_type_of.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/interval_type_of.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/interval_type_of.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -25,25 +25,25 @@
{};
template <class Type, bool has_interval_type>
- struct get_interval_type;
+ struct get_interval_type;
template <class Type>
- struct get_interval_type<Type, false>
+ struct get_interval_type<Type, false>
{
- typedef no_type type;
+ typedef no_type type;
};
template <class Type>
- struct get_interval_type<Type, true>
+ struct get_interval_type<Type, true>
{
- typedef typename Type::interval_type type;
+ typedef typename Type::interval_type type;
};
template <class Type>
- struct interval_type_of
+ struct interval_type_of
{
- typedef typename
- get_interval_type<Type, has_interval_type<Type>::value>::type type;
+ typedef typename
+ get_interval_type<Type, has_interval_type<Type>::value>::type type;
};
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_assoc_element_container.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_assoc_element_container.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_assoc_element_container.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -21,7 +21,7 @@
{
typedef is_assoc_element_container type;
BOOST_STATIC_CONSTANT(bool, value =
- (mpl::or_<is_element_set<Type>, is_element_map<Type> >::value));
+ (mpl::or_<is_element_set<Type>, is_element_map<Type> >::value));
};
Modified: sandbox/itl/boost/itl/type_traits/is_associative_element_container.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_associative_element_container.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_associative_element_container.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -21,7 +21,7 @@
{
typedef is_associative_element_container type;
BOOST_STATIC_CONSTANT(bool, value =
- (mpl::or_<is_element_set<Type>, is_element_map<Type> >::value));
+ (mpl::or_<is_element_set<Type>, is_element_map<Type> >::value));
};
Modified: sandbox/itl/boost/itl/type_traits/is_combinable.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_combinable.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_combinable.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -136,21 +136,21 @@
template<class FragmentT, class Type>
struct is_fragment_of
{
- typedef is_fragment_of type;
+ typedef is_fragment_of type;
BOOST_STATIC_CONSTANT(bool, value = false);
};
template<class Type>
struct is_fragment_of<typename Type::element_type, Type>
{
- typedef is_fragment_of type;
+ typedef is_fragment_of type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
template<class Type>
struct is_fragment_of<typename Type::segment_type, Type>
{
- typedef is_fragment_of type;
+ typedef is_fragment_of type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
@@ -160,21 +160,21 @@
template<class KeyT, class Type>
struct is_key_of
{
- typedef is_key_of type;
+ typedef is_key_of type;
BOOST_STATIC_CONSTANT(bool, value = false);
};
template<class Type>
struct is_key_of<typename Type::domain_type, Type>
{
- typedef is_key_of type;
+ typedef is_key_of type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
template<class Type>
struct is_key_of<typename Type::interval_type, Type>
{
- typedef is_key_of type;
+ typedef is_key_of type;
BOOST_STATIC_CONSTANT(bool, value = true);
};
Modified: sandbox/itl/boost/itl/type_traits/is_element_container.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_element_container.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_element_container.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -40,7 +40,7 @@
typedef is_element_container<Type> type;
BOOST_STATIC_CONSTANT(bool, value =
(mpl::or_<is_element_set<Type>, is_element_map<Type> >::value)
- );
+ );
};
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_icl_container.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_icl_container.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_icl_container.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -23,7 +23,7 @@
typedef is_icl_container<Type> type;
BOOST_STATIC_CONSTANT(bool, value =
(mpl::or_< is_element_container<Type>
- , is_interval_container<Type> >::value));
+ , is_interval_container<Type> >::value));
};
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_key_container_of.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_key_container_of.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_key_container_of.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -19,8 +19,8 @@
{
typedef is_strict_key_container_of<KeyT, ObjectT> type;
BOOST_STATIC_CONSTANT(bool, value =
- (mpl::and_< is_map<ObjectT>
- , is_same<typename ObjectT::key_object_type, KeyT> >::value)
+ (mpl::and_< is_map<ObjectT>
+ , is_same<typename ObjectT::key_object_type, KeyT> >::value)
);
};
@@ -29,9 +29,9 @@
{
typedef is_key_container_of<KeyT, ObjectT> type;
BOOST_STATIC_CONSTANT(bool, value =
- (mpl::or_< is_strict_key_container_of<KeyT, ObjectT>
- , mpl::and_< is_container<ObjectT> //JODO is_itl_associative_container
- , is_same<ObjectT, KeyT> > >::value)
+ (mpl::or_< is_strict_key_container_of<KeyT, ObjectT>
+ , mpl::and_< is_container<ObjectT> //JODO is_itl_associative_container
+ , is_same<ObjectT, KeyT> > >::value)
);
};
Modified: sandbox/itl/boost/itl/type_traits/no_type.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/no_type.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/no_type.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -10,7 +10,7 @@
namespace boost{ namespace itl
{
- struct no_type{};
+ struct no_type{};
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/segment_type_of.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/segment_type_of.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/segment_type_of.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -25,25 +25,25 @@
{};
template <class Type, bool has_segment_type>
- struct get_segment_type;
+ struct get_segment_type;
template <class Type>
- struct get_segment_type<Type, false>
+ struct get_segment_type<Type, false>
{
- typedef no_type type;
+ typedef no_type type;
};
template <class Type>
- struct get_segment_type<Type, true>
+ struct get_segment_type<Type, true>
{
- typedef typename Type::segment_type type;
+ typedef typename Type::segment_type type;
};
template <class Type>
- struct segment_type_of
+ struct segment_type_of
{
- typedef typename
- get_segment_type<Type, has_segment_type<Type>::value>::type type;
+ typedef typename
+ get_segment_type<Type, has_segment_type<Type>::value>::type type;
};
}} // 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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -49,7 +49,6 @@
typedef SegmentIteratorT segment_iterator;
typedef typename SegmentIteratorT::value_type segment_type;
typedef typename first_element<segment_type>::type interval_type;
- typedef typename interval_type::difference_type domain_difference_type;
typedef typename bitwise<segment_type>::bitset_type bitset_type;
typedef typename bitwise<segment_type>::word_type word_type;
typedef typename bitwise<segment_type>::domain_type domain_type;
@@ -58,6 +57,8 @@
typedef element_type value_type;
typedef element_type key_type;
typedef element_type data_type;
+ typedef typename difference_type_of<interval_traits<interval_type> >::type
+ domain_difference_type;
BOOST_STATIC_CONSTANT(bit_range_type, digits = bitwise<segment_type>::digits );
BOOST_STATIC_CONSTANT(bool, is_forward = mpl::not_<is_reverse<SegmentIteratorT> >::value );
@@ -439,8 +440,9 @@
typedef IteratorT iterator;
typedef typename iterator::value_type segment_type;
typedef typename first_element<segment_type>::type interval_type;
- typedef typename interval_type::difference_type difference_type;
typedef typename bitwise<segment_type>::word_type word_type;
+ typedef typename difference_type_of<interval_traits<interval_type> >::type
+ difference_type;
BOOST_STATIC_CONSTANT(bit_range_type, digits = bitwise<segment_type>::digits );
BOOST_STATIC_CONSTANT(bit_range_type, before = -2 );
@@ -476,8 +478,9 @@
typedef IteratorT iterator;
typedef typename iterator::value_type segment_type;
typedef typename first_element<segment_type>::type interval_type;
- typedef typename interval_type::difference_type difference_type;
typedef typename bitwise<segment_type>::word_type word_type;
+ typedef typename difference_type_of<interval_traits<interval_type> >::type
+ difference_type;
BOOST_STATIC_CONSTANT(bit_range_type, digits = bitwise<segment_type>::digits );
BOOST_STATIC_CONSTANT(bit_range_type, beyond = -2 );
Modified: sandbox/itl/boost/validate/driver/itl_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/itl_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/itl_driver.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -157,7 +157,7 @@
std::cout << "------------------------------------------------------------------------------" << std::endl;
// Summary for the current cycle
- double avg_evaluation_time_per_law = avg_evaluation_time/itl::size(_frequencies);
+ double avg_evaluation_time_per_law = avg_evaluation_time/itl::size(_frequencies);
printf( " %10.3lf%-53s%7ld%7.0lf\n",
avg_evaluation_time_per_law, " total avg of atomic evaluation (micro sec)", instance_count, avg_evaluation_time_per_law);
@@ -270,7 +270,7 @@
return true;
else if(_required_law_count == 0 || _required_law_validation_count == 0)
return false; // If counts are not limited: Run for ever.
- else if(itl::size(_frequencies) < static_cast<size_t>(_required_law_count))
+ else if(itl::size(_frequencies) < static_cast<size_t>(_required_law_count))
return false; // Not yet reached all laws
else
// All laws reached. Enough validation cycles for every law?
Modified: sandbox/itl/boost/validate/itl/functors.hpp
==============================================================================
--- sandbox/itl/boost/validate/itl/functors.hpp (original)
+++ sandbox/itl/boost/validate/itl/functors.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -71,8 +71,8 @@
{
ITL_FUN_CALL(clear, collected);
ITL_const_FORALL(typename SourceT, item_, items)
- //JODO itl::add(collected, *item_);
- collected.add(*item_);
+ //JODO itl::add(collected, *item_);
+ collected.add(*item_);
}
};
Modified: sandbox/itl/boost/validate/laws/order.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/order.hpp (original)
+++ sandbox/itl/boost/validate/laws/order.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -115,24 +115,24 @@
}
bool debug_holds()
- {
+ {
Type a = this->template getInputValue<operand_a>();
Type b = this->template getInputValue<operand_b>();
- cout << "a = " << a << endl;
- cout << "b = " << b << endl;
+ cout << "a = " << a << endl;
+ cout << "b = " << b << endl;
- bool a_R_b = Relation<Type>()(a,b);
- cout << "a<=b == " << a_R_b << endl;
+ bool a_R_b = Relation<Type>()(a,b);
+ cout << "a<=b == " << a_R_b << endl;
- bool b_R_a = Relation<Type>()(b,a);
- cout << "b<=a == " << b_R_a << endl;
+ bool b_R_a = Relation<Type>()(b,a);
+ cout << "b<=a == " << b_R_a << endl;
- bool a_E_b = Equality<Type>()(a,b);
- cout << "b==a == " << a_E_b << endl;
+ bool a_E_b = Equality<Type>()(a,b);
+ cout << "b==a == " << a_E_b << endl;
return !(Relation<Type>()(a,b) && Relation<Type>()(b,a)) || Equality<Type>()(a,b);
- }
+ }
size_t size()const
{
Modified: sandbox/itl/libs/itl/example/itvset_shell_/itvset_shell.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/itvset_shell_/itvset_shell.cpp (original)
+++ sandbox/itl/libs/itl/example/itvset_shell_/itvset_shell.cpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -92,7 +92,7 @@
break;
case 'j':
{
- itl::join(m1);
+ itl::join(m1);
cout << "{" << m1 << "}" << endl;
}
break;
Modified: sandbox/itl/libs/itl/example/large_bitset_/large_bitset.hpp
==============================================================================
--- sandbox/itl/libs/itl/example/large_bitset_/large_bitset.hpp (original)
+++ sandbox/itl/libs/itl/example/large_bitset_/large_bitset.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -113,7 +113,7 @@
//]
//[large_bitset_demo_functions
- size_t interval_count()const { return _map.interval_count(); }
+ size_t interval_count()const { return itl::interval_count(_map); }
void show_segments()const
{
@@ -131,7 +131,7 @@
typename interval_bitmap_type::const_iterator iter = _map.begin();
while(iter != _map.end())
{
- element_type fst = itl::first(iter->first), lst = itl::last(iter->first);
+ element_type fst = itl::first(iter->first), lst = itl::last(iter->first);
for(element_type chunk = fst; chunk <= lst; chunk++)
std::cout << iter->second.as_string(off_on) << std::endl;
++iter;
Modified: sandbox/itl/libs/itl/example/splititvmap_shell_/splititvmap_shell.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/splititvmap_shell_/splititvmap_shell.cpp (original)
+++ sandbox/itl/libs/itl/example/splititvmap_shell_/splititvmap_shell.cpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -94,7 +94,7 @@
break;
case 'j':
{
- itl::join(m1);
+ itl::join(m1);
cout << "{" << m1 << "}" << endl;
}
break;
Modified: sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_itl_interval_/fastest_itl_interval.cpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -14,8 +14,6 @@
#include "../test_type_lists.hpp"
#include "../test_value_maker.hpp"
-#include <boost/itl/interval.hpp>
-
using namespace std;
using namespace boost;
using namespace unit_test;
@@ -26,8 +24,9 @@
BOOST_AUTO_TEST_CASE
(fastest_itl_interval_ctor_4_ordered_types)
-{ interval_ctor_4_ordered_types<ordered_type_1>(); }
+{ interval_ctor_4_ordered_types<ordered_type_1, >(); }
+/*
BOOST_AUTO_TEST_CASE
(fastest_itl_interval_ctor_4_bicremental_types)
{ interval_ctor_4_bicremental_types<bicremental_type_2>(); }
@@ -71,6 +70,7 @@
BOOST_AUTO_TEST_CASE
(fastest_itl_interval_subtract_4_bicremental_types)
{ interval_subtract_4_bicremental_types<bicremental_type_5>(); }
+*/
/*JODO
BOOST_AUTO_TEST_CASE
Modified: sandbox/itl/libs/itl/test/test_calls.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_calls.hpp (original)
+++ sandbox/itl/libs/itl/test/test_calls.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -25,9 +25,9 @@
bool contains(const Type& object, const CoType& co_object)
{
#ifdef ITL_PURE_CONCEPTUAL
- return object.contains(co_object);
+ return object.contains(co_object);
#else
- return itl::contains(object, co_object);
+ return itl::contains(object, co_object);
#endif
}
@@ -35,9 +35,9 @@
bool within(const Type& object, const CoType& co_object)
{
#ifdef ITL_PURE_CONCEPTUAL
- return object.within(co_object);
+ return object.within(co_object);
#else
- return itl::within(object, co_object);
+ return itl::within(object, co_object);
#endif
}
Modified: sandbox/itl/libs/itl/test/test_icl_quantifier_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_icl_quantifier_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_icl_quantifier_shared.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -21,46 +21,46 @@
>
void make_3_icl_maps_and_derivatives_1
(itl::map<T,U,Trt>& map_a,
- itl::map<T,U,Trt>& map_b,
- itl::map<T,U,Trt>& map_c,
- std::pair<T,U>& map_pair_a,
- std::pair<T,U>& map_pair_b,
- IntervalMap<T,U,Trt>* aux = 0)
+ itl::map<T,U,Trt>& map_b,
+ itl::map<T,U,Trt>& map_c,
+ std::pair<T,U>& map_pair_a,
+ std::pair<T,U>& map_pair_b,
+ IntervalMap<T,U,Trt>* aux = 0)
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
- aux;
+ typedef itl::map<T,U,Trt> MapT;
+ aux;
- map_pair_a = sK_v(5,1);
+ map_pair_a = sK_v(5,1);
map_pair_b = sK_v(9,1);
- add(map_a, sK_v(3,1));
- add(map_a, sK_v(4,1));
- add(map_a, sK_v(5,1));
- add(map_a, sK_v(5,1));
- add(map_a, sK_v(6,1));
- add(map_a, sK_v(7,1));
-
- add(map_b, sK_v(2,1));
- add(map_b, sK_v(8,1));
-
- add(map_c, sK_v(0,2));
- add(map_c, sK_v(1,2));
- add(map_c, sK_v(2,2));
- add(map_c, sK_v(3,2));
- add(map_c, sK_v(4,2));
- add(map_c, sK_v(5,2));
- add(map_c, sK_v(6,2));
- add(map_c, sK_v(7,2));
- add(map_c, sK_v(8,2));
-
- add(map_c, sK_v(3,1));
- add(map_c, sK_v(4,1));
- add(map_c, sK_v(5,1));
- add(map_c, sK_v(6,1));
+ add(map_a, sK_v(3,1));
+ add(map_a, sK_v(4,1));
+ add(map_a, sK_v(5,1));
+ add(map_a, sK_v(5,1));
+ add(map_a, sK_v(6,1));
+ add(map_a, sK_v(7,1));
+
+ add(map_b, sK_v(2,1));
+ add(map_b, sK_v(8,1));
+
+ add(map_c, sK_v(0,2));
+ add(map_c, sK_v(1,2));
+ add(map_c, sK_v(2,2));
+ add(map_c, sK_v(3,2));
+ add(map_c, sK_v(4,2));
+ add(map_c, sK_v(5,2));
+ add(map_c, sK_v(6,2));
+ add(map_c, sK_v(7,2));
+ add(map_c, sK_v(8,2));
+
+ add(map_c, sK_v(3,1));
+ add(map_c, sK_v(4,1));
+ add(map_c, sK_v(5,1));
+ add(map_c, sK_v(6,1));
- add(map_c, sK_v(5,1));
- add(map_c, sK_v(6,1));
+ add(map_c, sK_v(5,1));
+ add(map_c, sK_v(6,1));
}
@@ -80,11 +80,11 @@
void icl_quantifier_check_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
- IntervalMapT aux;
- MapT map_a, map_b, map_c;
- std::pair<T,U> map_pair_a, map_pair_b;
- make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
+ typedef itl::map<T,U,Trt> MapT;
+ IntervalMapT aux;
+ MapT map_a, map_b, map_c;
+ std::pair<T,U> map_pair_a, map_pair_b;
+ make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
CHECK_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair_a, map_pair_b);
CHECK_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair_a, map_pair_b);
@@ -104,11 +104,11 @@
void icl_quantifier_check_monoid_et_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
- IntervalMapT aux;
- MapT map_a, map_b, map_c;
- std::pair<T,U> map_pair_a, map_pair_b;
- make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
+ typedef itl::map<T,U,Trt> MapT;
+ IntervalMapT aux;
+ MapT map_a, map_b, map_c;
+ std::pair<T,U> map_pair_a, map_pair_b;
+ make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
CHECK_MONOID_INSTANCE_WRT(et) (map_a, map_b, map_c, map_pair_a, map_pair_b);
CHECK_MONOID_INSTANCE_WRT(caret)(map_a, map_b, map_c, map_pair_a, map_pair_b);
@@ -131,11 +131,11 @@
void icl_quantifier_check_abelian_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
- IntervalMapT aux;
- MapT map_a, map_b, map_c;
- std::pair<T,U> map_pair_a, map_pair_b;
- make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
+ typedef itl::map<T,U,Trt> MapT;
+ IntervalMapT aux;
+ MapT map_a, map_b, map_c;
+ std::pair<T,U> map_pair_a, map_pair_b;
+ make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair_a, map_pair_b);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair_a, map_pair_b);
@@ -155,11 +155,11 @@
void icl_quantifier_check_abelian_monoid_et_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
- IntervalMapT aux;
- MapT map_a, map_b, map_c;
- std::pair<T,U> map_pair_a, map_pair_b;
- make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
+ typedef itl::map<T,U,Trt> MapT;
+ IntervalMapT aux;
+ MapT map_a, map_b, map_c;
+ std::pair<T,U> map_pair_a, map_pair_b;
+ make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(et) (map_a, map_b, map_c, map_pair_a, map_pair_b);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(caret)(map_a, map_b, map_c, map_pair_a, map_pair_b);
@@ -182,11 +182,11 @@
void icl_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
- IntervalMapT aux;
- MapT map_a, map_b, map_c;
- std::pair<T,U> map_pair_a, map_pair_b;
- make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
+ typedef itl::map<T,U,Trt> MapT;
+ IntervalMapT aux;
+ MapT map_a, map_b, map_c;
+ std::pair<T,U> map_pair_a, map_pair_b;
+ make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair_a, map_pair_b);
CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair_a, map_pair_b);
@@ -208,11 +208,11 @@
void icl_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
- IntervalMapT aux;
- MapT map_a, map_b, map_c;
- std::pair<T,U> map_pair_a, map_pair_b;
- make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
+ typedef itl::map<T,U,Trt> MapT;
+ IntervalMapT aux;
+ MapT map_a, map_b, map_c;
+ std::pair<T,U> map_pair_a, map_pair_b;
+ make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(map_a, map_b, map_c, map_pair_a, map_pair_b);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(map_a, map_b, map_c, map_pair_a, map_pair_b);
@@ -238,11 +238,11 @@
void icl_quantifier_check_abelian_group_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
- IntervalMapT aux;
- MapT map_a, map_b, map_c;
- std::pair<T,U> map_pair_a, map_pair_b;
- make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
+ typedef itl::map<T,U,Trt> MapT;
+ IntervalMapT aux;
+ MapT map_a, map_b, map_c;
+ std::pair<T,U> map_pair_a, map_pair_b;
+ make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
CHECK_ABELIAN_GROUP_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair_a, map_pair_b);
CHECK_ABELIAN_GROUP_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair_a, map_pair_b);
@@ -267,11 +267,11 @@
// (1) (IntervalMapT, +) is an abelian group and
// (2) The inverability law: (0 - x) + x =p= 0 holds.
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
- IntervalMapT aux;
- MapT map_a, map_b, map_c;
- std::pair<T,U> map_pair_a, map_pair_b;
- make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
+ typedef itl::map<T,U,Trt> MapT;
+ IntervalMapT aux;
+ MapT map_a, map_b, map_c;
+ std::pair<T,U> map_pair_a, map_pair_b;
+ make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, map_pair_a, map_pair_b);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, map_pair_a, map_pair_b);
@@ -296,19 +296,19 @@
void icl_quantifier_check_containedness_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef itl::map<T,U,Trt> MapT;
- IntervalMapT aux;
- MapT map_a, map_b, map_c;
- std::pair<T,U> map_pair_a, map_pair_b;
- make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
+ typedef itl::map<T,U,Trt> MapT;
+ IntervalMapT aux;
+ MapT map_a, map_b, map_c;
+ std::pair<T,U> map_pair_a, map_pair_b;
+ make_3_icl_maps_and_derivatives_1(map_a, map_b, map_c, map_pair_a, map_pair_b, &aux);
- check_intersection_containedness(map_a, map_c);
- check_intersection_containedness(map_c, map_pair_a);
+ check_intersection_containedness(map_a, map_c);
+ check_intersection_containedness(map_c, map_pair_a);
- check_union_containedness(map_a, map_c);
- check_union_containedness(map_c, map_pair_a);
+ check_union_containedness(map_a, map_c);
+ check_union_containedness(map_c, map_pair_a);
- check_domain_containedness(map_a);
+ check_domain_containedness(map_a);
}
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -228,11 +228,11 @@
split_map.add(IDv(0,2,2)).add(IIv(2,3,1)).add(CDv(3,6,1)).add(CIv(7,9,2));
join_map = split_map;
- itl::domain(split_set, split_map);
+ itl::domain(split_set, split_map);
itl::domain(sep_set, split_map);
itl::domain(join_set, split_map);
- iterative_size(split_map);
+ iterative_size(split_map);
BOOST_CHECK_EQUAL( iterative_size(split_map), 4 );
BOOST_CHECK_EQUAL( iterative_size(join_map), 3 );
BOOST_CHECK_EQUAL( iterative_size(split_set), 4 );
@@ -372,7 +372,7 @@
BOOST_CHECK_EQUAL( itl::contains(join_map, I_D(0,7)), false );
// Map types
- BOOST_CHECK_EQUAL( itl::contains(join_map, K_v(1,2)), true );
+ BOOST_CHECK_EQUAL( itl::contains(join_map, K_v(1,2)), true );
BOOST_CHECK_EQUAL( itl::contains(join_map, K_v(5,1)), true );
BOOST_CHECK_EQUAL( itl::contains(join_map, K_v(9,2)), true );
@@ -1491,7 +1491,7 @@
split_A.add(I0_3D_1).add(I4_4I_1).add(I6_6I_1);
split_B.add(I4_4I_1).add(I6_6I_1);
- itl::erase_if(size_greater_1<typename SplitIntervalMapT::value_type>(), split_A);
+ itl::erase_if(size_greater_1<typename SplitIntervalMapT::value_type>(), split_A);
BOOST_CHECK_EQUAL( split_A, split_B );
}
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -42,7 +42,7 @@
//empty set
//-------------------------------------------------------------------------
BOOST_CHECK_EQUAL(IntervalMapT().empty(), true);
- BOOST_CHECK_EQUAL(itl::is_empty(IntervalMapT()), 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());
@@ -365,8 +365,8 @@
//USASO: unsatisfctory solution 2: not implementing mapping_type version of o=
BOOST_CHECK_EQUAL( cardinality(is_123_5), itl::infinity<size_T>::value() );
- BOOST_CHECK_EQUAL( is_123_5.size(), itl::infinity<size_T>::value() );
- BOOST_CHECK_EQUAL( itl::length(is_123_5), d2 );
+ BOOST_CHECK_EQUAL( is_123_5.size(), itl::infinity<size_T>::value() );
+ BOOST_CHECK_EQUAL( itl::length(is_123_5), d2 );
}
Modified: sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -21,10 +21,10 @@
>
void make_3_itv_maps_and_derivatives_1
(IntervalMap<T,U,Trt>& itv_map_a,
- IntervalMap<T,U,Trt>& itv_map_b,
- IntervalMap<T,U,Trt>& itv_map_c,
- typename IntervalMap<T,U,Trt>::interval_mapping_type& val_pair,
- mapping_pair<T,U>& map_pair)
+ IntervalMap<T,U,Trt>& itv_map_b,
+ IntervalMap<T,U,Trt>& itv_map_c,
+ typename IntervalMap<T,U,Trt>::interval_mapping_type& val_pair,
+ mapping_pair<T,U>& map_pair)
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -37,7 +37,7 @@
//empty set
//-------------------------------------------------------------------------
BOOST_CHECK_EQUAL(IntervalSet<T>().empty(), true);
- BOOST_CHECK_EQUAL(itl::is_empty(IntervalSet<T>()), 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(interval_count(IntervalSet<T>()), 0);
@@ -433,9 +433,9 @@
IntervalSet<T> is(v1);
BOOST_CHECK_EQUAL( itl::contains(is, v1), true );
- BOOST_CHECK_EQUAL( itl::contains(IntervalSet<T>().add(make<T>(2)), make<T>(2)), true );
- BOOST_CHECK_EQUAL( itl::contains(IntervalSet<T>().insert(make<T>(2)), make<T>(2)), true );
- BOOST_CHECK_EQUAL( itl::contains((is += IntervalT(v3,v7)), IntervalT(v3,v7)), true );
+ BOOST_CHECK_EQUAL( itl::contains(IntervalSet<T>().add(make<T>(2)), make<T>(2)), true );
+ BOOST_CHECK_EQUAL( itl::contains(IntervalSet<T>().insert(make<T>(2)), make<T>(2)), true );
+ BOOST_CHECK_EQUAL( itl::contains((is += IntervalT(v3,v7)), IntervalT(v3,v7)), true );
IntervalSet<T> is0 = is;
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -5,22 +5,24 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef __test_itl_interval_hpp_JOFA_081006__
-#define __test_itl_interval_hpp_JOFA_081006__
+#ifndef BOOST_ITL_TEST_ITL_INTERVAL_HPP_JOFA_081006
+#define BOOST_ITL_TEST_ITL_INTERVAL_HPP_JOFA_081006
-template <class T>
+template <class T, class IntervalT>
void interval_ctor_4_ordered_types()
{
// An empty interval is defined as the closed interval [1,0]
- BOOST_CHECK_EQUAL(interval<T>().empty(), true);
- BOOST_CHECK_EQUAL(interval<T>().cardinality(), itl::neutron<typename itl::size_type_of<T>::type>::value());
- BOOST_CHECK_EQUAL(interval<T>().size(), itl::neutron<typename itl::size_type_of<T>::type>::value());
- BOOST_CHECK_EQUAL(interval<T>().lower(), itl::unon<T>::value());
- BOOST_CHECK_EQUAL(interval<T>().upper(), itl::neutron<T>::value());
-
- BOOST_CHECK_EQUAL(interval<T>(), interval<T>());
- BOOST_CHECK_EQUAL(interval<T>(), interval<T>(itl::unon<T>::value(), itl::neutron<T>::value()));
- BOOST_CHECK_EQUAL(interval<T>(), interval<T>(itl::unon<T>::value(), itl::neutron<T>::value(), closed_bounded));
+ 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(IntervalT().lower(), itl::unon<T>::value());
+ BOOST_CHECK_EQUAL(IntervalT().upper(), itl::neutron<T>::value());
+ BOOST_CHECK_EQUAL(itl::lower(IntervalT()), itl::unon<T>::value());
+ BOOST_CHECK_EQUAL(itl::upper(IntervalT()), itl::neutron<T>::value());
+
+ //BOOST_CHECK_EQUAL(IntervalT(), IntervalT());
+ //BOOST_CHECK_EQUAL(IntervalT(), IntervalT(itl::unon<T>::value(), itl::neutron<T>::value()));
+ //BOOST_CHECK_EQUAL(IntervalT(), IntervalT(itl::unon<T>::value(), itl::neutron<T>::value(), closed_bounded));
}
template <class T>
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -46,12 +46,11 @@
BOOST_CHECK_EQUAL( I4_4I.bounds() == interval_bounds::left_open(), false );
BOOST_CHECK_EQUAL( I4_4I.bounds() == interval_bounds::right_open(), false );
BOOST_CHECK_EQUAL( I4_4I.bounds() == interval_bounds::open(), false );
- /*JODO
- BOOST_CHECK_EQUAL( I4_4I.is_left(closed_bounded), true );
- BOOST_CHECK_EQUAL( I4_4I.is_right(closed_bounded), true );
- BOOST_CHECK_EQUAL( I4_4I.is_left(open_bounded), false );
- BOOST_CHECK_EQUAL( I4_4I.is_right(open_bounded), false );
- */
+ //JODO
+ //BOOST_CHECK_EQUAL( I4_4I.is_left(closed_bounded), true );
+ //BOOST_CHECK_EQUAL( I4_4I.is_right(closed_bounded), true );
+ //BOOST_CHECK_EQUAL( I4_4I.is_left(open_bounded), false );
+ //BOOST_CHECK_EQUAL( I4_4I.is_right(open_bounded), false );
BOOST_CHECK_EQUAL( I4_4I.lower(), v4 );
BOOST_CHECK_EQUAL( I4_4I.upper(), v4 );
@@ -69,81 +68,80 @@
k_4_4 = j_4_4;
BOOST_CHECK_EQUAL( I4_4I, k_4_4 );
- /*
- T v2 = make<T>(2);
- BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4), interval<T>(v2, v4) );
- BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4), interval<T>(v2, v4, closed_bounded) );
- BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4), interval<T>(v2, v4, right_open) );
- BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4), interval<T>(v2, v4, left_open) );
- BOOST_CHECK_EQUAL( interval<T>::open(v2, v4), interval<T>(v2, v4, open_bounded) );
-
- BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).lower(), v2 );
- BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).upper(), v4 );
- BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).boundtype(), closed_bounded );
- BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).bounds() == interval_bounds::closed_bounded(), true );
- BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).is_left(closed_bounded), true );
- BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).is_right(closed_bounded), true );
-
- BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).lower(), v2 );
- BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).upper(), v4 );
- BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).boundtype(), right_open );
- BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).bounds() == interval_bounds::right_open(), true );
- BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).is_left(closed_bounded), true );
- BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).is_right(open_bounded), true );
-
- BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).lower(), v2 );
- BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).upper(), v4 );
- BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).boundtype(), left_open );
- BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).bounds() == interval_bounds::left_open(), true );
- BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).is_left(open_bounded), true );
- BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).is_right(closed_bounded), true );
-
- BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).lower(), v2 );
- BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).upper(), v4 );
- BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).boundtype(), open_bounded );
- BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).bounds() == interval_bounds::open_bounded(), true );
- BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).is_left(open_bounded), true );
- BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).is_right(open_bounded), true );
- */
+ //JODO
+ //T v2 = make<T>(2);
+ //BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4), interval<T>(v2, v4) );
+ //BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4), interval<T>(v2, v4, closed_bounded) );
+ //BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4), interval<T>(v2, v4, right_open) );
+ //BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4), interval<T>(v2, v4, left_open) );
+ //BOOST_CHECK_EQUAL( interval<T>::open(v2, v4), interval<T>(v2, v4, open_bounded) );
+
+ //BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).lower(), v2 );
+ //BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).upper(), v4 );
+ //BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).boundtype(), closed_bounded );
+ //BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).bounds() == interval_bounds::closed_bounded(), true );
+ //BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).is_left(closed_bounded), true );
+ //BOOST_CHECK_EQUAL( interval<T>::closed(v2, v4).is_right(closed_bounded), true );
+
+ //BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).lower(), v2 );
+ //BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).upper(), v4 );
+ //BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).boundtype(), right_open );
+ //BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).bounds() == interval_bounds::right_open(), true );
+ //BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).is_left(closed_bounded), true );
+ //BOOST_CHECK_EQUAL( interval<T>::rightopen(v2, v4).is_right(open_bounded), true );
+
+ //BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).lower(), v2 );
+ //BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).upper(), v4 );
+ //BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).boundtype(), left_open );
+ //BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).bounds() == interval_bounds::left_open(), true );
+ //BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).is_left(open_bounded), true );
+ //BOOST_CHECK_EQUAL( interval<T>::leftopen(v2, v4).is_right(closed_bounded), true );
+
+ //BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).lower(), v2 );
+ //BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).upper(), v4 );
+ //BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).boundtype(), open_bounded );
+ //BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).bounds() == interval_bounds::open_bounded(), true );
+ //BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).is_left(open_bounded), true );
+ //BOOST_CHECK_EQUAL( interval<T>::open(v2, v4).is_right(open_bounded), true );
}
-/*JODO
-template <class T, ITL_COMPARE Compare,
- ITL_INTERVAL(ITL_COMPARE) Interval>
-void interval_equal_4_bicremental_continuous_types()
-{
- T v3 = make<T>(3);
- T v7 = make<T>(7);
- BOOST_CHECK_EQUAL(interval<T>(), interval<T>(v7,v3));
-
- //I: (I)nside = closed bound
- //O: (O)utside = open bound
- interval<T> I3_7I = interval<T>::closed(v3,v7);
- interval<T> I3_7D = interval<T>::rightopen(v3,v7);
- interval<T> C3_7I = interval<T>::leftopen(v3,v7);
- interval<T> C3_7D = interval<T>::open(v3,v7);
-
- BOOST_CHECK_EQUAL( I3_7I , I3_7I );
- BOOST_CHECK_EQUAL( I3_7I == I3_7D, false );
- BOOST_CHECK_EQUAL( I3_7I == C3_7D, false );
- BOOST_CHECK_EQUAL( I3_7I == C3_7D, false );
- BOOST_CHECK_EQUAL( I3_7I != I3_7D, true );
- BOOST_CHECK_EQUAL( I3_7I != C3_7D, true );
- BOOST_CHECK_EQUAL( I3_7I != C3_7D, true );
-
- BOOST_CHECK_EQUAL( I3_7D , I3_7D );
- BOOST_CHECK_EQUAL( I3_7D == C3_7I, false );
- BOOST_CHECK_EQUAL( I3_7D == C3_7D, false );
- BOOST_CHECK_EQUAL( I3_7D != C3_7I, true );
- BOOST_CHECK_EQUAL( I3_7D != C3_7D, true );
-
- BOOST_CHECK_EQUAL( C3_7I , C3_7I );
- BOOST_CHECK_EQUAL( C3_7I == C3_7D, false );
- BOOST_CHECK_EQUAL( C3_7I != C3_7D, true );
-
- BOOST_CHECK_EQUAL( C3_7D, C3_7D );
-}
-*/
+//JODO
+//template <class T, ITL_COMPARE Compare,
+// ITL_INTERVAL(ITL_COMPARE) Interval>
+//void interval_equal_4_bicremental_continuous_types()
+//{
+// T v3 = make<T>(3);
+// T v7 = make<T>(7);
+// BOOST_CHECK_EQUAL(interval<T>(), interval<T>(v7,v3));
+//
+// //I: (I)nside = closed bound
+// //O: (O)utside = open bound
+// interval<T> I3_7I = interval<T>::closed(v3,v7);
+// interval<T> I3_7D = interval<T>::rightopen(v3,v7);
+// interval<T> C3_7I = interval<T>::leftopen(v3,v7);
+// interval<T> C3_7D = interval<T>::open(v3,v7);
+//
+// BOOST_CHECK_EQUAL( I3_7I , I3_7I );
+// BOOST_CHECK_EQUAL( I3_7I == I3_7D, false );
+// BOOST_CHECK_EQUAL( I3_7I == C3_7D, false );
+// BOOST_CHECK_EQUAL( I3_7I == C3_7D, false );
+// BOOST_CHECK_EQUAL( I3_7I != I3_7D, true );
+// BOOST_CHECK_EQUAL( I3_7I != C3_7D, true );
+// BOOST_CHECK_EQUAL( I3_7I != C3_7D, true );
+//
+// BOOST_CHECK_EQUAL( I3_7D , I3_7D );
+// BOOST_CHECK_EQUAL( I3_7D == C3_7I, false );
+// BOOST_CHECK_EQUAL( I3_7D == C3_7D, false );
+// BOOST_CHECK_EQUAL( I3_7D != C3_7I, true );
+// BOOST_CHECK_EQUAL( I3_7D != C3_7D, true );
+//
+// BOOST_CHECK_EQUAL( C3_7I , C3_7I );
+// BOOST_CHECK_EQUAL( C3_7I == C3_7D, false );
+// BOOST_CHECK_EQUAL( C3_7I != C3_7D, true );
+//
+// BOOST_CHECK_EQUAL( C3_7D, C3_7D );
+//}
+
template <class DomainT, ITL_COMPARE Compare,
ITL_INTERVAL(ITL_COMPARE) Interval>
Modified: sandbox/itl/libs/itl/test/test_itl_map.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_map.hpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_map.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -24,7 +24,7 @@
typedef IntervalMap<T,U,Trt> IntervalMapT;
typedef itl::map<T,U,Trt> MapT;
typedef itl::set<T> SetT;
- typedef typename MapT::element_type map_element_type;
+ typedef typename MapT::element_type map_element_type;
IntervalMapT itv_map_a;
itv_map_a.add(IDv(2,4,1)).add(IIv(6,7,3));
@@ -35,7 +35,7 @@
BOOST_CHECK_EQUAL( contains(map_a, MK_u(3)), true );
BOOST_CHECK_EQUAL( within(MK_u(3), map_a), true );
- map_element_type key_value_pair(MK_v(6), MK_u(3));
+ map_element_type key_value_pair(MK_v(6), MK_u(3));
BOOST_CHECK( contains(map_a, key_value_pair) );
BOOST_CHECK( within(key_value_pair, map_a) );
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -230,36 +230,36 @@
template<class Type, class TypeB>
void check_intersection_containedness(const Type& a, const TypeB& b)
{
- BOOST_CHECK_EQUAL(contains(a, a & b), true);
- BOOST_CHECK_EQUAL(contains(a, b & a), true);
- BOOST_CHECK_EQUAL(within(a & b, a), true);
- BOOST_CHECK_EQUAL(within(b & a, a), true);
+ BOOST_CHECK_EQUAL(contains(a, a & b), true);
+ BOOST_CHECK_EQUAL(contains(a, b & a), true);
+ BOOST_CHECK_EQUAL(within(a & b, a), true);
+ BOOST_CHECK_EQUAL(within(b & a, a), true);
}
template<class Type, class TypeB>
void check_union_containedness(const Type& a, const TypeB& b)
{
- BOOST_CHECK_EQUAL(within(a, a + b), true);
- BOOST_CHECK_EQUAL(within(a, b + a), true);
- BOOST_CHECK_EQUAL(contains(a + b, a), true);
- BOOST_CHECK_EQUAL(contains(b + a, a), true);
+ BOOST_CHECK_EQUAL(within(a, a + b), true);
+ BOOST_CHECK_EQUAL(within(a, b + a), true);
+ BOOST_CHECK_EQUAL(contains(a + b, a), true);
+ BOOST_CHECK_EQUAL(contains(b + a, a), true);
}
template<class MapT>
void check_domain_containedness(const MapT& a)
{
- typedef typename MapT::set_type set_type;
- set_type dom;
- domain(dom, a);
- BOOST_CHECK_EQUAL(within(dom, a), true);
- BOOST_CHECK_EQUAL(contains(a, dom), true);
-
- if(!dom.empty())
- {
- typename MapT::domain_type a1 = *dom.begin();
- BOOST_CHECK_EQUAL(within(a1, a), true);
- BOOST_CHECK_EQUAL(contains(a, a1), true);
- }
+ typedef typename MapT::set_type set_type;
+ set_type dom;
+ domain(dom, a);
+ BOOST_CHECK_EQUAL(within(dom, a), true);
+ BOOST_CHECK_EQUAL(contains(a, dom), true);
+
+ if(!dom.empty())
+ {
+ typename MapT::domain_type a1 = *dom.begin();
+ BOOST_CHECK_EQUAL(within(a1, a), true);
+ BOOST_CHECK_EQUAL(contains(a, a1), true);
+ }
}
//==============================================================================
Modified: sandbox/itl/libs/itl/test/test_set_interval_set_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_set_interval_set_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_set_interval_set_shared.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -19,12 +19,12 @@
>
void make_3_interval_sets_and_derivatives_1
(IntervalSet<T>& set_a,
- IntervalSet<T>& set_b,
- IntervalSet<T>& set_c,
- typename IntervalSet<T>::segment_type& segm_d,
- typename IntervalSet<T>::element_type& elem_e)
+ IntervalSet<T>& set_b,
+ IntervalSet<T>& set_c,
+ typename IntervalSet<T>::segment_type& segm_d,
+ typename IntervalSet<T>::element_type& elem_e)
{
- typedef IntervalSet<T> IntervalSetT;
+ typedef IntervalSet<T> IntervalSetT;
typedef typename IntervalSetT::segment_type IntervalT;
typedef typename IntervalSetT::segment_type segment_type;
typedef typename IntervalSetT::element_type element_type;
@@ -187,18 +187,18 @@
typedef typename IntervalSetT::segment_type segment_type;
typedef typename IntervalSetT::element_type element_type;
- IntervalSetT set_a, set_b, set_c;
- segment_type segm_d;
- element_type elem_e;
- make_3_interval_sets_and_derivatives_1(set_a, set_b, set_c, segm_d, elem_e);
-
- check_intersection_containedness(set_a, set_c);
- check_intersection_containedness(set_b, segm_d);
- check_intersection_containedness(set_c, elem_e);
-
- check_union_containedness(set_c, set_c);
- check_union_containedness(set_b, segm_d);
- check_union_containedness(set_a, elem_e);
+ IntervalSetT set_a, set_b, set_c;
+ segment_type segm_d;
+ element_type elem_e;
+ make_3_interval_sets_and_derivatives_1(set_a, set_b, set_c, segm_d, elem_e);
+
+ check_intersection_containedness(set_a, set_c);
+ check_intersection_containedness(set_b, segm_d);
+ check_intersection_containedness(set_c, elem_e);
+
+ check_union_containedness(set_c, set_c);
+ check_union_containedness(set_b, segm_d);
+ check_union_containedness(set_a, elem_e);
}
Modified: sandbox/itl/libs/itl/test/test_type_lists.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_type_lists.hpp (original)
+++ sandbox/itl/libs/itl/test/test_type_lists.hpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -15,8 +15,6 @@
#include <boost/itl/ptime.hpp>
#include <boost/itl/rational.hpp>
-#include <boost/itl/interval.hpp>
-
#if(_MSC_VER < 1500 && defined(_DEBUG) ) // 1500 = MSVC-9.0
typedef int boost_posix_time_ptime;
#else
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-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -9,6 +9,7 @@
#define BOOST_ITL_TEST_VALUE_MAKER_HPP_JOFA_080916
#include <boost/itl/type_traits/neutron.hpp>
+#include <boost/itl/interval_bounds.hpp>
#include "test_calls.hpp"
namespace boost{ namespace itl
@@ -26,10 +27,10 @@
struct mono
{
- mono(){};
- mono& operator ++ (){ return *this; }
- mono& operator -- (){ return *this; }
- mono& operator += (const mono&){ return *this; }
+ mono(){};
+ mono& operator ++ (){ return *this; }
+ mono& operator -- (){ return *this; }
+ mono& operator += (const mono&){ return *this; }
};
bool operator == (const mono&, const mono&){ return true; }
Modified: sandbox/itl/libs/validate/example/labat_signed_quantifier_/labat_signed_quantifier.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_signed_quantifier_/labat_signed_quantifier.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_signed_quantifier_/labat_signed_quantifier.cpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -29,7 +29,7 @@
GentorProfileSgl::it()->set_range_double(-1.0, 1.0);
GentorProfileSgl::it()->report_profile();
- //validater.set_information_level(inform::never);
+ //validater.set_information_level(inform::never);
validater.validate();
};
Modified: sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp 2010-09-29 16:03:57 EDT (Wed, 29 Sep 2010)
@@ -84,11 +84,11 @@
//TestLawT;
//typedef Antisymmetry<itl::map<int,int>, itl::sub_super_set, itl::element_equal> TestLawT;
- //typedef InplaceAssociativity<itl::interval_map<int,itl::set<int> >, itl::inplace_caret, itl::element_equal> TestLawT;
+ //typedef InplaceAssociativity<itl::interval_map<int,itl::set<int> >, itl::inplace_caret, itl::element_equal> TestLawT;
- typedef InplaceFlip< itl::map<int,int,partial_enricher> > TestLawT;
- //typedef InplaceFlip< itl::map<int,int> > TestLawT;
- //typedef InplaceFlip< itl::map<int, itl::set<int> > > TestLawT;
+ typedef InplaceFlip< itl::map<int,int,partial_enricher> > TestLawT;
+ //typedef InplaceFlip< itl::map<int,int> > TestLawT;
+ //typedef InplaceFlip< itl::map<int, itl::set<int> > > TestLawT;
LawValidater<TestLawT> test_law;