|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r65023 - in sandbox/itl: boost/itl boost/itl/detail boost/itl/type_traits boost/validate/driver boost/validate/itl libs/itl/example/boost_party_ libs/itl/example/interval_container_ libs/itl/example/man_power_ libs/itl/example/month_and_week_grid_ libs/itl/example/overlap_counter_ libs/itl/example/party_ libs/itl/example/partys_height_average_ libs/itl/example/partys_tallest_guests_ libs/itl/example/std_copy_ libs/itl/example/std_transform_ libs/itl/example/user_groups_ libs/itl/test libs/itl/test/fastest_itl_map_ libs/itl/test/fastest_partial_interval_quantifier_ libs/validate/example
From: afojgo_at_[hidden]
Date: 2010-08-26 13:09:40
Author: jofaber
Date: 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
New Revision: 65023
URL: http://svn.boost.org/trac/boost/changeset/65023
Log:
Refactoring. Concept based design for itl::map.
Added:
sandbox/itl/boost/itl/detail/interval_map_functors.hpp (contents, props changed)
sandbox/itl/boost/itl/detail/map_functors.hpp (contents, props changed)
sandbox/itl/boost/itl/map_functions.hpp (contents, props changed)
sandbox/itl/boost/itl/seqs.hpp (contents, props changed)
Text files modified:
sandbox/itl/boost/itl/continuous_interval.hpp | 33
sandbox/itl/boost/itl/detail/design_config.hpp | 8
sandbox/itl/boost/itl/detail/interval_map_algo.hpp | 18
sandbox/itl/boost/itl/detail/interval_morphism.hpp | 8
sandbox/itl/boost/itl/detail/interval_set_algo.hpp | 97 ++
sandbox/itl/boost/itl/detail/map_algo.hpp | 129 ----
sandbox/itl/boost/itl/detail/set_algo.hpp | 10
sandbox/itl/boost/itl/discrete_interval.hpp | 38 +
sandbox/itl/boost/itl/functions.hpp | 33
sandbox/itl/boost/itl/interval_base_map.hpp | 23
sandbox/itl/boost/itl/interval_base_set.hpp | 4
sandbox/itl/boost/itl/interval_bounds.hpp | 4
sandbox/itl/boost/itl/interval_functions.hpp | 18
sandbox/itl/boost/itl/interval_map.hpp | 10
sandbox/itl/boost/itl/map.hpp | 1164 ++++-----------------------------------
sandbox/itl/boost/itl/rightopen_interval.hpp | 2
sandbox/itl/boost/itl/set.hpp | 58 +
sandbox/itl/boost/itl/split_interval_map.hpp | 10
sandbox/itl/boost/itl/type_traits/is_combinable.hpp | 1
sandbox/itl/boost/itl/type_traits/is_discrete.hpp | 11
sandbox/itl/boost/validate/driver/itl_driver.hpp | 4
sandbox/itl/boost/validate/itl/functors.hpp | 4
sandbox/itl/libs/itl/example/boost_party_/boost_party.cpp | 2
sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp | 2
sandbox/itl/libs/itl/example/man_power_/man_power.cpp | 10
sandbox/itl/libs/itl/example/month_and_week_grid_/month_and_week_grid.cpp | 26
sandbox/itl/libs/itl/example/overlap_counter_/overlap_counter.cpp | 14
sandbox/itl/libs/itl/example/party_/party.cpp | 10
sandbox/itl/libs/itl/example/partys_height_average_/partys_height_average.cpp | 14
sandbox/itl/libs/itl/example/partys_tallest_guests_/partys_tallest_guests.cpp | 20
sandbox/itl/libs/itl/example/std_copy_/std_copy.cpp | 16
sandbox/itl/libs/itl/example/std_transform_/std_transform.cpp | 10
sandbox/itl/libs/itl/example/user_groups_/user_groups.cpp | 30
sandbox/itl/libs/itl/test/Jamfile.v2 | 2
sandbox/itl/libs/itl/test/fastest_itl_map_/fastest_itl_map_cases.hpp | 13
sandbox/itl/libs/itl/test/fastest_partial_interval_quantifier_/fastest_partial_interval_quantifier.cpp | 1
sandbox/itl/libs/itl/test/fastest_partial_interval_quantifier_cases.hpp | 46
sandbox/itl/libs/itl/test/fastest_total_interval_quantifier_cases.hpp | 56
sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp | 2
sandbox/itl/libs/itl/test/test_interval_quantifier_shared.hpp | 130 ++--
sandbox/itl/libs/itl/test/test_itl_map.hpp | 37 +
sandbox/itl/libs/itl/test/test_laws.hpp | 34 +
sandbox/itl/libs/itl/test/test_partial_interval_quantifier_cases.hpp | 40
sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp | 16
sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp | 22
sandbox/itl/libs/itl/test/test_total_interval_quantifier_cases.hpp | 56
sandbox/itl/libs/itl/test/test_value_maker.hpp | 11
sandbox/itl/libs/itl/test/vc9_fast_tests.sln | 18
sandbox/itl/libs/itl/test/vc9_slow_tests.sln | 12
sandbox/itl/libs/validate/example/vc9_validate_examples.sln | 6
50 files changed, 791 insertions(+), 1552 deletions(-)
Modified: sandbox/itl/boost/itl/continuous_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/continuous_interval.hpp (original)
+++ sandbox/itl/boost/itl/continuous_interval.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -26,7 +26,7 @@
public:
typedef continuous_interval<DomainT,Compare> type;
typedef DomainT domain_type;
- typedef typename bounded_value<DomainT,Compare>::type bounded_domain_type;
+ typedef typename bounded_value<DomainT>::type bounded_domain_type;
public:
//==========================================================================
@@ -93,9 +93,30 @@
}
-//------------------------------------------------------------------------------
-//- dynamic_intervals: Adapt interval class to interval concept
-//------------------------------------------------------------------------------
+//==============================================================================
+//=T continuous_interval -> concept intervals
+//==============================================================================
+template<class DomainT, ITL_COMPARE Compare>
+struct intervals< itl::continuous_interval<DomainT, Compare> >
+{
+ typedef intervals type;
+ typedef DomainT domain_type;
+ typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
+ typedef itl::continuous_interval<DomainT, Compare> interval_type;
+
+ static interval_type construct(const domain_type& lo, const domain_type& up)
+ {
+ return interval_type(lo, up);
+ }
+
+ static domain_type lower(const interval_type& inter_val){ return inter_val.lower(); };
+ static domain_type upper(const interval_type& inter_val){ return inter_val.upper(); };
+};
+
+
+//==============================================================================
+//=T continuous_interval -> concept dynamic_intervals
+//==============================================================================
template<class DomainT, ITL_COMPARE Compare>
struct dynamic_intervals<boost::itl::continuous_interval<DomainT,Compare> >
{
@@ -107,8 +128,8 @@
static_cast<itl::continuous_interval<DomainT,Compare>* >(0) );
}
- static interval_type construct_bounded(const bounded_value<DomainT,Compare>& lo,
- const bounded_value<DomainT,Compare>& up)
+ static interval_type construct_bounded(const bounded_value<DomainT>& lo,
+ const bounded_value<DomainT>& up)
{
return itl::continuous_interval<DomainT,Compare>
(
Modified: sandbox/itl/boost/itl/detail/design_config.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/design_config.hpp (original)
+++ sandbox/itl/boost/itl/detail/design_config.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -23,7 +23,7 @@
// will be used as default for all interval containers.
// ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS should be defined in the application
// before other includes from the ITL
-#define ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS //JODO comment this out for the final release
+//#define ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS //JODO comment this out for the final release
// If ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS is NOT defined, ITL uses intervals
// with dynamic borders as default.
@@ -32,13 +32,13 @@
#endif
//#define ITL_CONCEPT_ORIENTED
-//#define ITL_PURE_CONCEPTUAL
+#define ITL_PURE_CONCEPTUAL
#ifndef ITL_CONCEPT_ORIENTED
#define ITL_OBJECT_ORIENTED
#endif
-#ifdef ITL_CONCEPT_ORIENTED
+#ifdef ITL_CONCEPT_ORIENTED //CL
# define ITL_FUN_CALL(func, arg) itl::func(arg)
# define ITL_FUN_REN(func_obj, func_conc, arg) itl::func_conc(arg)
#else //ITL_OBJECT_ORIENTED
@@ -46,7 +46,7 @@
# define ITL_FUN_REN(func_obj, func_conc, arg) arg.func_obj()
#endif
-#ifdef ITL_OBJECT_ORIENTED
+#ifdef ITL_OBJECT_ORIENTED //CL
# define ITL_BEGIN_COMMON_MEMBER_FUNCTIONS public
# define ITL_END_COMMON_MEMBER_FUNCTIONS public
#else //ITL_CONCEPT_ORIENTED
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-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -105,18 +105,18 @@
}
//- set_type -------------------------------------------------------------------
-template<class IntervalMapT>
-typename enable_if<mpl::not_<is_total<IntervalMapT> >, bool>::type
-contains(const IntervalMapT& super_map,
- const typename IntervalMapT::set_type& sub_set)
+template<class IntervalMapT, class IntervalSetT>
+typename enable_if<mpl::and_<mpl::not_<is_total<IntervalMapT> >
+ ,is_interval_set<IntervalSetT> >, bool>::type
+contains(const IntervalMapT& super_map, const IntervalSetT& sub_set)
{
return Interval_Set::within(sub_set, super_map);
}
-template<class IntervalMapT>
-typename enable_if<is_total<IntervalMapT>, bool>::type
-contains(const IntervalMapT& super_map,
- const typename IntervalMapT::set_type& sub_set)
+template<class IntervalMapT, class IntervalSetT>
+typename enable_if<mpl::and_<is_total<IntervalMapT>
+ ,is_interval_set<IntervalSetT> >, bool>::type
+contains(const IntervalMapT& super_map, const IntervalSetT& sub_set)
{
return true;
}
@@ -130,7 +130,7 @@
bool contains(const IntervalMapT& container,
const typename IntervalMapT::element_type& key_value_pair)
{
- IntervalMapT::const_iterator it_ = container.find(key_value_pair.key);
+ typename IntervalMapT::const_iterator it_ = container.find(key_value_pair.key);
return it_ != container.end() && it_->second == key_value_pair.data;
}
Added: sandbox/itl/boost/itl/detail/interval_map_functors.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl/detail/interval_map_functors.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -0,0 +1,143 @@
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-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_INTERVAL_MAP_FUNCTORS_HPP_JOFA_100826
+#define BOOST_ITL_DETAIL_INTERVAL_MAP_FUNCTORS_HPP_JOFA_100826
+
+#include <boost/itl/detail/design_config.hpp>
+#include <boost/itl/functors.hpp>
+#include <boost/itl/interval_functions.hpp>
+#include <boost/itl/detail/interval_map_algo.hpp>
+
+namespace boost{namespace itl
+{
+
+//==============================================================================
+//=P Containment
+//==============================================================================
+
+
+template<class MapT>
+struct interval_map_contains
+{
+ typedef typename MapT::element_type element_type;
+ typedef typename MapT::segment_type segment_type;
+ typedef typename MapT::interval_type interval_type;
+ typedef typename MapT::const_iterator const_iterator;
+
+ static bool apply(const MapT& super, const element_type& key_value_pair)
+ {
+ const_iterator it_ = super.find(key_value_pair.key);
+ return it_ != super.end() && it_->second == key_value_pair.data;
+ }
+
+ static bool apply(const MapT& super, const segment_type& sub_segment)
+ {
+ interval_type sub_interval = sub_segment.first;
+ if(itl::is_empty(sub_interval))
+ return true;
+
+ std::pair<const_iterator, const_iterator> exterior = super.equal_range(sub_interval);
+ if(exterior.first == exterior.second)
+ return false;
+
+ const_iterator last_overlap = prior(exterior.second);
+
+ if(!(sub_segment.second == exterior.first->second) )
+ return false;
+
+ return
+ itl::contains(hull(exterior.first->first, last_overlap->first), sub_interval)
+ && Interval_Map::is_joinable(super, exterior.first, last_overlap);
+ }
+
+ template<class CoMapT>
+ static typename enable_if<is_interval_map<CoMapT>, bool>::type
+ apply(const MapT& super, const CoMapT& sub)
+ {
+ return Interval_Set::within(sub, super);
+ }
+};
+
+//------------------------------------------------------------------------------
+
+template<class MapT, bool is_total>
+struct interval_map_contains_key
+{
+ typedef typename MapT::domain_type domain_type;
+ typedef typename MapT::interval_type interval_type;
+ typedef typename MapT::const_iterator const_iterator;
+
+ static bool apply(const MapT&, const domain_type&);
+ static bool apply(const MapT&, const interval_type&);
+
+ template<class SetT>
+ static typename enable_if<is_interval_set<SetT>, bool>::type
+ apply(const MapT&, const SetT&);
+};
+
+template<class MapT>
+struct interval_map_contains_key<MapT, true>
+{ // is_total
+ typedef typename MapT::domain_type domain_type;
+ typedef typename MapT::interval_type interval_type;
+ typedef typename MapT::set_type set_type;
+
+ //JODO enable_if< is_key_type_of >
+ // Key objects are always contained in a total map
+ static bool apply(const MapT&, const domain_type& ){ return true; }
+ static bool apply(const MapT&, const interval_type&){ return true; }
+
+ template<class SetT>
+ static typename enable_if<is_interval_set<SetT>, bool>::type
+ apply(const MapT&, const SetT&){ return true; }
+};
+
+template<class MapT>
+struct interval_map_contains_key<MapT, false>
+{ // !is_total
+ typedef typename MapT::domain_type domain_type;
+ typedef typename MapT::interval_type interval_type;
+ typedef typename MapT::set_type set_type;
+
+ typedef typename MapT::const_iterator const_iterator;
+
+ static bool apply(const MapT& super, const domain_type& key)
+ {
+ return super.find(key) != super.end();
+ }
+
+ static bool apply(const MapT& super, const interval_type& sub_interval)
+ {
+ if(itl::is_empty(sub_interval))
+ return true;
+
+ std::pair<const_iterator, const_iterator> exterior = super.equal_range(sub_interval);
+ if(exterior.first == exterior.second)
+ return false;
+
+ const_iterator last_overlap = prior(exterior.second);
+
+ return
+ itl::contains(hull(exterior.first->first, last_overlap->first), sub_interval)
+ && Interval_Set::is_joinable(super, exterior.first, last_overlap);
+ }
+
+ template<class SetT>
+ static typename enable_if<is_interval_set<SetT>, bool>::type
+ apply(const MapT& super, const SetT& sub)
+ {
+ return Interval_Set::within(sub, super);
+ }
+
+};
+
+
+}} // namespace itl boost
+
+#endif
+
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-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -23,7 +23,8 @@
for(typename IntervalContainerT::domain_type element = first(itv); element <= last(itv); ++element)
{
- result.insert(ElementContainerT::make_element(element, coval));
+ insert(result, ElementContainerT::make_value(element, coval));
+ //CL result.insert(ElementContainerT::make_element(element, coval));
}
}
}
@@ -31,12 +32,13 @@
template <typename IntervalContainerT, typename ElementContainerT>
void cluster(IntervalContainerT& result, const ElementContainerT& src)
{
+ typedef typename IntervalContainerT::key_type key_type;
ITL_const_FORALL(typename ElementContainerT, element_, src)
{
const typename ElementContainerT::key_type& key = ElementContainerT::key_value(element_);
- const typename ElementContainerT::data_type& data = ElementContainerT::data_value(element_);
+ const typename ElementContainerT::data_type& data = ElementContainerT::codomain_value(element_);
- result += IntervalContainerT::make_domain_element(key, data);
+ result += IntervalContainerT::make_value(key_type(key), data);
}
}
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-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -114,6 +114,26 @@
// Subset/superset compare on ranges of two interval container
//------------------------------------------------------------------------------
+template<class IntervalContainerT>
+bool is_joinable(const IntervalContainerT& container,
+ typename IntervalContainerT::const_iterator first,
+ typename IntervalContainerT::const_iterator past)
+{
+ if(first == container.end())
+ return true;
+
+ typename IntervalContainerT::const_iterator it_ = first, next_ = first;
+ ++next_;
+
+ while(next_ != container.end() && it_ != past)
+ if(!itl::touches(IntervalContainerT::key_value(it_++),
+ IntervalContainerT::key_value(next_++)))
+ return false;
+
+ return true;
+}
+
+
template<class LeftT, class RightT>
bool is_inclusion_equal(const LeftT& left, const RightT& right)
{
@@ -131,13 +151,28 @@
bool>::type
within(const LeftT&, const RightT&)
{
- cout << "within\n";
return true;
}
template<class LeftT, class RightT>
-typename enable_if<mpl::not_<mpl::and_<is_concept_combinable<is_interval_set, is_interval_map, LeftT, RightT>,
- is_total<RightT> > >,
+typename enable_if<mpl::and_<is_concept_combinable<is_interval_set, is_interval_map, LeftT, RightT>,
+ mpl::not_<is_total<RightT> > >,
+ bool>::type
+within(const LeftT& sub, const RightT& super)
+{
+ int result =
+ subset_compare
+ (
+ sub, super,
+ sub.begin(), sub.end(),
+ super.begin(), super.end()
+ );
+ return result == inclusion::subset || result == inclusion::equal;
+}
+
+
+template<class LeftT, class RightT> //JODO Codereplication: Unify some more
+typename enable_if<is_concept_combinable<is_interval_map, is_interval_map, LeftT, RightT>,
bool>::type
within(const LeftT& sub, const RightT& super)
{
@@ -152,18 +187,49 @@
}
template<class LeftT, class RightT>
+typename enable_if<is_concept_combinable<is_interval_set, is_interval_set, LeftT, RightT>,
+ bool>::type
+within(const LeftT& sub, const RightT& super)
+{
+ int result =
+ subset_compare
+ (
+ sub, super,
+ sub.begin(), sub.end(),
+ super.begin(), super.end()
+ );
+ return result == inclusion::subset || result == inclusion::equal;
+}
+
+
+
+template<class LeftT, class RightT>
typename enable_if<mpl::and_<is_concept_combinable<is_interval_map, is_interval_set, LeftT, RightT>,
is_total<LeftT> >,
bool>::type
contains(const LeftT&, const RightT&)
{
- cout << "contains\n";
return true;
}
template<class LeftT, class RightT>
-typename enable_if<mpl::not_<mpl::and_<is_concept_combinable<is_interval_map, is_interval_set, LeftT, RightT>,
- is_total<LeftT> > >,
+typename enable_if<mpl::and_<is_concept_combinable<is_interval_map, is_interval_set, LeftT, RightT>,
+ mpl::not_<is_total<LeftT> > >,
+ bool>::type
+contains(const LeftT& super, const RightT& sub)
+{
+ int result =
+ subset_compare
+ (
+ super, sub,
+ super.begin(), super.end(),
+ sub.begin(), sub.end()
+ );
+ return result == inclusion::superset || result == inclusion::equal;
+}
+
+template<class LeftT, class RightT>
+typename enable_if<is_concept_combinable<is_interval_set, is_interval_set, LeftT, RightT>,
bool>::type
contains(const LeftT& super, const RightT& sub)
{
@@ -203,25 +269,6 @@
&& Interval_Set::is_joinable(container, exterior.first, last_overlap);
}
-template<class IntervalContainerT>
-bool is_joinable(const IntervalContainerT& container,
- typename IntervalContainerT::const_iterator first,
- typename IntervalContainerT::const_iterator past)
-{
- if(first == container.end())
- return true;
-
- typename IntervalContainerT::const_iterator it_ = first, next_ = first;
- ++next_;
-
- while(next_ != container.end() && it_ != past)
- if(!itl::touches(IntervalContainerT::key_value(it_++),
- IntervalContainerT::key_value(next_++)))
- return false;
-
- return true;
-}
-
template<class IntervalContainerT>
bool is_dense(const IntervalContainerT& container,
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-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -24,80 +24,8 @@
namespace Map
{
-template<class MapType>
-bool within(const MapType& sub, const MapType& super)
-{
- if(&super == &sub) return true;
- if(ITL_FUN_REN(empty, is_empty, sub)) return true;
- if(ITL_FUN_REN(empty, is_empty, super)) return false;
- if(super.size() < sub.size() ) return false;
- if(*sub.begin() < *super.begin()) return false;
- if(*super.rbegin() < *sub.rbegin() ) return false;
-
- typename MapType::const_iterator common_lwb_;
- typename MapType::const_iterator common_upb_;
- if(!Set::common_range(common_lwb_, common_upb_, sub, super))
- return false;
-
- typename MapType::const_iterator sub_ = sub.begin(), super_;
- while(sub_ != sub.end())
- {
- super_ = super.find((*sub_).first);
- if(super_ == super.end())
- return false;
- else if(!(sub_->second == super_->second))
- return false;
- sub_++;
- }
- return true;
-}
-
-template<class MapType>
-bool within(const typename MapType::set_type& sub, const MapType& super)
-{
- typedef typename MapType::set_type SetType;
-
- if(sub.empty()) return true;
- if(super.empty()) return false;
- if(super.size() < sub.size() ) return false;
- if(*sub.begin() < *super.begin()) return false;
- if(*super.rbegin() < *sub.rbegin() ) return false;
-
- typename SetType::const_iterator common_lwb_;
- typename SetType::const_iterator common_upb_;
- if(!Set::common_range(common_lwb_, common_upb_, sub, super))
- return false;
-
- typename SetType::const_iterator sub_ = sub.begin();
- typename MapType::const_iterator super_;
- while(sub_ != sub.end())
- {
- super_ = super.find(*sub_++);
- if(super_ == super.end())
- return false;
- }
- return true;
-}
-
-
-template <class MapType>
-bool intersects(const MapType& left, const MapType& right)
-{
- typename MapType::const_iterator right_common_lower_;
- typename MapType::const_iterator right_common_upper_;
- if(!Set::common_range(right_common_lower_, right_common_upper_, right, left))
- return false;
-
- typename MapType::const_iterator right_ = right_common_lower_;
- while(right_ != right_common_upper_)
- if(left.intersects(*right_++))
- return true;
-
- return false;
-}
-
template <class ObjectT, class CoObjectT>
-bool key_intersects(const ObjectT& left, const CoObjectT& right)
+bool intersects(const ObjectT& left, const CoObjectT& right)
{
typename CoObjectT::const_iterator right_common_lower_;
typename CoObjectT::const_iterator right_common_upper_;
@@ -112,53 +40,12 @@
return false;
}
-//----------------------------------------------------------------------
-// flip
-//----------------------------------------------------------------------
-template<class MapType>
-void flip(MapType& result, const MapType& x2)
-{
- if(mpl::and_<is_total<MapType>, absorbs_neutrons<MapType> >::value)
- {
- ITL_FUN_CALL(clear, result);
- return;
- }
-
- typename MapType::const_iterator x2_ = x2.begin(), cur_x2_, x1_;
- while(x2_ != x2.end())
- {
- cur_x2_ = x2_;
- std::pair<typename MapType::iterator,bool> insertion
- = result.insert(*x2_++);
- if(!insertion.second)
- {
- //result.erase(insertion.first);
- if(is_set<typename MapType::codomain_type>::value)
- {
- typename MapType::iterator res_ = insertion.first;
- typename MapType::codomain_type common_value = res_->second;
- typename MapType::key_type key_value = res_->first;
- typename MapType::inverse_codomain_intersect()(common_value, cur_x2_->second);
- result.subtract(*res_);
- result.add(typename MapType::value_type(key_value, common_value));
- }
- else
- result.subtract(*insertion.first);
- }
- }
-
- if(mpl::and_<is_total<MapType>, mpl::not_<absorbs_neutrons<MapType> > >::value)
- ITL_FORALL(typename MapType, it_, result)
- it_->second = neutron<typename MapType::codomain_type>::value();
-}
-
-
-template<class MapType>
-typename MapType::const_iterator next_proton(typename MapType::const_iterator& iter_, const MapType& object)
+template<class MapT>
+typename MapT::const_iterator next_proton(typename MapT::const_iterator& iter_, const MapT& object)
{
while( iter_ != object.end()
- && iter_->second == neutron<typename MapType::codomain_type>::value())
+ && iter_->second == neutron<typename MapT::codomain_type>::value())
++iter_;
return iter_;
@@ -166,14 +53,14 @@
/** Function template <tt>lexicographical_equal</tt> implements
lexicographical equality except for neutronic content values. */
-template<class MapType>
-bool lexicographical_protonic_equal(const MapType& left, const MapType& right)
+template<class MapT>
+bool lexicographical_protonic_equal(const MapT& left, const MapT& right)
{
if(&left == &right)
return true;
- typename MapType::const_iterator left_ = left.begin();
- typename MapType::const_iterator right_ = right.begin();
+ typename MapT::const_iterator left_ = left.begin();
+ typename MapT::const_iterator right_ = right.begin();
left_ = next_proton(left_, left);
right_ = next_proton(right_, right);
Added: sandbox/itl/boost/itl/detail/map_functors.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl/detail/map_functors.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -0,0 +1,856 @@
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-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_MAP_FUNCTORS_HPP_JOFA_100823
+#define BOOST_ITL_DETAIL_MAP_FUNCTORS_HPP_JOFA_100823
+
+#include <boost/itl/detail/design_config.hpp>
+#include <boost/itl/functors.hpp>
+#include <boost/itl/map_functions.hpp>
+
+namespace boost{namespace itl
+{
+
+template<class MapT, class Predicate>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+erase_if(const Predicate& pred, MapT& object);//JODO gcc-3.4.4 does not recognize some functions from map_functions.hpp
+ //JODO e.g. erase_if and subtract. Forward decl should not be necessary
+ //JODO but may be it is better to use forward decls only instead of inlclues here.
+
+
+template<class MapT, class Combiner> //JODO locate
+struct adds_inversely
+{
+ typedef adds_inversely type;
+ BOOST_STATIC_CONSTANT(bool,
+ value = (mpl::and_< has_inverse<typename MapT::codomain_type>
+ , is_negative<Combiner>
+ >::value));
+};
+
+
+template<class MapT, class Combiner, bool creates_inverse>
+struct element_version
+{
+ static typename MapT::value_type apply(const typename MapT::value_type& val);
+};
+
+template<class MapT, class Combiner>
+struct element_version<MapT, Combiner, false>
+{
+ static typename MapT::value_type apply(const typename MapT::value_type& value_pair)
+ { return value_pair; }
+};
+
+template<class MapT, class Combiner>
+struct element_version<MapT, Combiner, true>
+{
+ static typename MapT::value_type apply(const typename MapT::value_type& value_pair)
+ {
+ return typename MapT::value_type(value_pair.first, version<Combiner>()(value_pair.second));
+ }
+};
+
+//==============================================================================
+//=P Containment
+//==============================================================================
+
+template<class MapT>
+struct map_within
+{
+ typedef typename MapT::set_type set_type;
+
+ static bool apply(const typename MapT::set_type& sub, const MapT& super)
+ {
+ if(itl::is_empty(sub)) return true;
+ if(itl::is_empty(super)) return false;
+ if(itl::size(super) < itl::size(sub)) return false;
+
+ typename set_type::const_iterator common_lwb_;
+ typename set_type::const_iterator common_upb_;
+ if(!Set::common_range(common_lwb_, common_upb_, sub, super))
+ return false;
+
+ typename set_type::const_iterator sub_ = sub.begin();
+ typename MapT::const_iterator super_;
+ while(sub_ != seqs<MapT>::end(sub))
+ {
+ super_ = seqs<MapT>::find(super, *sub_++);
+ if(super_ == seqs<MapT>::end(super))
+ return false;
+ }
+ return true;
+ }
+
+ static bool apply(const MapT& sub, const MapT& super)
+ {
+ if(&super == &sub) return true;
+ if(itl::is_empty(sub)) return true;
+ if(itl::is_empty(super)) return false;
+ if(itl::size(super) < itl::size(sub)) return false;
+
+ typename MapT::const_iterator common_lwb_;
+ typename MapT::const_iterator common_upb_;
+ if(!Set::common_range(common_lwb_, common_upb_, sub, super))
+ return false;
+
+ typename MapT::const_iterator sub_ = sub.begin(), super_;
+ while(sub_ != seqs<MapT>::end(sub))
+ {
+ super_ = seqs<MapT>::find(super, seqs<MapT>::key_value(sub_));
+ if(super_ == super.end())
+ return false;
+ else if(!(seqs<MapT>::co_value(sub_) == seqs<MapT>::co_value(super_)))
+ return false;
+ sub_++;
+ }
+ return true;
+ }
+};
+
+//==============================================================================
+//=P Addition
+//==============================================================================
+
+template<class MapT, class Combiner, bool absorbs_neutrons>
+struct map_add
+{
+ typedef MapT map_type;
+ typedef typename map_type::value_type value_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::iterator iterator;
+
+ static MapT& apply(map_type& object, const value_type& value_pair);
+ static iterator apply(map_type& object, iterator prior, const element_type& value_pair);
+};
+
+template <class MapT, class Combiner>
+struct map_add<MapT, Combiner, true>
+{ // absorbs_neutrons
+ typedef MapT map_type;
+ typedef typename map_type::value_type value_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::codomain_type codomain_type;
+ typedef typename map_type::iterator iterator;
+
+ BOOST_STATIC_CONSTANT(bool, co_version = (adds_inversely<MapT,Combiner>::value));
+
+ static map_type& apply(map_type& object, const value_type& val)
+ {
+ if(val.second == Combiner::neutron())
+ return object;
+ // if Combiner is negative e.g. subtract and
+ std::pair<iterator, bool> insertion = // the codomain has an inverse, we have to
+ seqs<map_type>::insert(object, // insert the inverse element of val.second
+ element_version<MapT,Combiner,co_version>::apply(val));
+
+ if( insertion.second )
+ return object;
+ else
+ {
+ iterator it = insertion.first;
+ Combiner()((*it).second, val.second); // If this combination results in a
+ // neutral element,
+ if((*it).second == Combiner::neutron()) // it has to be removed.
+ seqs<map_type>::erase(object, it);
+
+ return object;
+ }
+ }
+
+
+ static iterator apply(map_type& object, iterator prior, const element_type& value_pair)
+ {
+ if(value_pair.second == Combiner::neutron())
+ return seqs<map_type>::end(object);
+
+ iterator inserted_
+ = seqs<map_type>::insert(object, prior,
+ value_type(value_pair.first, Combiner::neutron()));
+ Combiner()(inserted_->second, value_pair.second); // May generate an inverse via inv(x)= 0-x
+
+ if(inserted_->second == Combiner::neutron())
+ {
+ seqs<map_type>::erase(object, inserted_);
+ return seqs<map_type>::end(object);
+ }
+ else
+ return inserted_;
+ }
+};
+
+
+template <class MapT, class Combiner>
+struct map_add<MapT, Combiner, false>
+{ // !absorbs_neutrons
+ typedef MapT map_type;
+ typedef typename map_type::value_type value_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::codomain_type codomain_type;
+ typedef typename map_type::iterator iterator;
+
+ BOOST_STATIC_CONSTANT(bool, co_version = (adds_inversely<MapT,Combiner>::value));
+
+ static map_type& apply(map_type& object, const value_type& value_pair)
+ {
+ std::pair<iterator, bool> insertion =
+ seqs<map_type>::insert(object,
+ element_version<MapT,Combiner,co_version>::apply(value_pair));
+
+ if( insertion.second )
+ return object;
+ else
+ {
+ iterator it = insertion.first;
+ Combiner()((*it).second, value_pair.second);
+ return object;
+ }
+ }
+
+ static iterator apply(map_type& object, iterator prior, const element_type& value_pair)
+ {
+ iterator inserted_
+ = seqs<MapT>::insert(object, prior,
+ value_type(value_pair.first, Combiner::neutron()));
+ Combiner()(inserted_->second, value_pair.second); // May generate an inverse via inv(x)= 0-x
+ return inserted_;
+ }
+
+};
+
+
+//==============================================================================
+//=P Subtraction
+//==============================================================================
+
+//------------------------------------------------------------------------------
+//-P Subtraction for partial maps
+//------------------------------------------------------------------------------
+
+template<class MapT, class Combiner, bool absorbs_neutrons>
+struct map_partial_subtract
+{
+ typedef MapT map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::element_type element_type;
+
+ static map_type& apply(map_type&, const element_type&);
+};
+
+//------------------------------------------------------------------------------
+
+template<class MapT, bool is_total_invertible>
+struct map_subtract
+{
+ typedef MapT map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::element_type element_type;
+
+ static map_type& apply(map_type&, const element_type& value_pair);
+};
+
+template<class MapT>
+struct map_subtract<MapT, true>
+{
+ typedef MapT map_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::inverse_codomain_combine inverse_codomain_combine;
+
+ static map_type& apply(map_type& object, const element_type& value_pair)
+ {
+ return map_add<map_type
+ ,inverse_codomain_combine
+ ,absorbs_neutrons<MapT>::value
+ >::apply(object, value_pair);
+ }
+};
+
+template<class MapT>
+struct map_subtract<MapT, false>
+{
+ typedef MapT map_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::inverse_codomain_combine inverse_codomain_combine;
+
+ static map_type& apply(map_type& object, const element_type& value_pair)
+ {
+ return map_partial_subtract<map_type
+ ,inverse_codomain_combine
+ ,absorbs_neutrons<MapT>::value >
+ ::apply(object, value_pair);
+ }
+};
+
+template<class MapT, class Combiner>
+struct map_partial_subtract<MapT, Combiner, true>
+{
+ typedef MapT map_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::codomain_combine codomain_combine;
+ typedef typename map_type::iterator iterator;
+
+ static map_type& apply(map_type& object, const element_type& value_pair)
+ {
+ iterator it_ = seqs<map_type>::find(object, value_pair.first);
+ if(it_ != seqs<map_type>::end(object))
+ {
+ Combiner()((*it_).second, value_pair.second);
+ if((*it_).second == codomain_combine::neutron())
+ seqs<map_type>::erase(object, it_);
+ }
+ return object;
+ }
+};
+
+template<class MapT, class Combiner>
+struct map_partial_subtract<MapT, Combiner, false>
+{
+ typedef MapT map_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::iterator iterator;
+
+ static map_type& apply(map_type& object, const element_type& value_pair)
+ {
+ iterator it_ = seqs<MapT>::find(object, value_pair.first);
+ if(it_ != seqs<MapT>::end(object))
+ Combiner()((*it_).second, value_pair.second);
+
+ return object;
+ }
+};
+
+
+//==============================================================================
+//=P Insertion
+//==============================================================================
+
+template<class MapT, class Combiner, bool absorbs_neutrons>
+struct map_insert
+{
+ typedef MapT map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::iterator iterator;
+
+ static map_type& apply(map_type&, const element_type&);
+ static map_type& apply(map_type&, iterator, const element_type&);
+};
+
+template<class MapT, class Combiner>
+struct map_insert<MapT, Combiner, true>
+{
+ typedef MapT map_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::codomain_combine codomain_combine;
+ typedef typename map_type::iterator iterator;
+
+ static std::pair<iterator,bool> apply(map_type& object, const element_type& value_pair)
+ {
+ if(value_pair.second == codomain_combine::neutron())
+ return std::pair<iterator,bool>(object.end(),true);
+ else
+ return seqs<map_type>::insert(object, value_pair);
+ }
+
+ static iterator apply(map_type& object, iterator prior, const element_type& value_pair)
+ {
+ if(value_pair.second == codomain_combine::neutron())
+ return seqs<map_type>::end(object);
+ else
+ return seqs<map_type>::insert(object, prior, value_pair);
+ }
+
+};
+
+template<class MapT, class Combiner>
+struct map_insert<MapT, Combiner, false>
+{
+ typedef MapT map_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::iterator iterator;
+
+ static std::pair<iterator,bool> apply(map_type& object, const element_type& value_pair)
+ {
+ return seqs<MapT>::insert(object, value_pair);
+ }
+
+ static iterator apply(map_type& object, iterator prior, const element_type& value_pair)
+ {
+ return seqs<MapT>::insert(object, prior, value_pair);
+ }
+
+};
+
+//==============================================================================
+//=P Erasure
+//==============================================================================
+
+template<class MapT, class Combiner, bool absorbs_neutrons>
+struct map_erase
+{
+ typedef MapT map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::size_type size_type;
+ typedef typename map_type::iterator iterator;
+
+ static size_type apply(map_type&, const element_type&);
+
+ static size_type apply(map_type& object, const domain_type& key)
+ {
+ iterator it_ = seqs<map_type>::find(object, key);
+ if(it_ != seqs<map_type>::end(object))
+ {
+ seqs<map_type>::erase(object, it_);
+ return 1;
+ }
+
+ return 0;
+ }
+
+};
+
+template<class MapT, class Combiner>
+struct map_erase<MapT, Combiner, true>
+{
+ typedef MapT map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::size_type size_type;
+ typedef typename map_type::codomain_combine codomain_combine;
+ typedef typename map_type::iterator iterator;
+
+ static size_type apply(map_type& object, const element_type& value_pair)
+ {
+ if(value_pair.second == codomain_combine::neutron())
+ return 0; // neutrons are never contained 'substantially'
+ // only 'virtually'.
+
+ iterator it_ = seqs<map_type>::find(object, value_pair.first);
+ if(it_ != seqs<map_type>::end(object) && value_pair.second == it_->second)
+ {
+ seqs<map_type>::erase(object, it_);
+ return 1;
+ }
+
+ return 0;
+ }
+};
+
+template<class MapT, class Combiner>
+struct map_erase<MapT, Combiner, false>
+{
+ typedef MapT map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::size_type size_type;
+ typedef typename map_type::iterator iterator;
+
+ static size_type apply(map_type& object, const element_type& value_pair)
+ {
+ iterator it_ = seqs<map_type>::find(object, value_pair.first);
+ if(it_ != seqs<map_type>::end(object) && value_pair.second == it_->second)
+ {
+ seqs<map_type>::erase(object, it_);
+ return 1;
+ }
+
+ return 0;
+ }
+};
+
+//==============================================================================
+//=P Intersection
+//==============================================================================
+
+template<class MapT, bool is_total>
+struct map_add_intersection
+{
+ typedef MapT map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::element_type element_type;
+
+ //JODO test add_intersection(c, a, b) == c += (a & b)
+ static map_type& apply(map_type&, const map_type&, const domain_type&);
+ static map_type& apply(map_type&, const map_type&, const element_type&);
+};
+
+
+template<class MapT>
+struct map_add_intersection<MapT, true>
+{ // is_total
+ typedef MapT map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::element_type element_type;
+
+
+ static map_type& apply(map_type& section, const map_type& object, const domain_type& key_value)
+ {
+ typename map_type::const_iterator it_ = seqs<map_type>::find(object, key_value);
+ if(it_ != seqs<map_type>::end(object))
+ itl::add(section, *it_);
+ return section;
+ }
+
+ static map_type& apply(map_type& section, const map_type& object, const element_type& value_pair)
+ {
+ itl::add(section, value_pair); //JODO test this
+ return section;
+ }
+};
+
+template<class MapT>
+struct map_add_intersection<MapT, false>
+{ // !is_total
+ typedef MapT map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::codomain_intersect codomain_intersect;
+ typedef typename map_type::const_iterator const_iterator;
+
+ BOOST_STATIC_CONSTANT(bool, absorbs = (absorbs_neutrons<MapT>::value));
+
+ static map_type& apply(map_type& section, const map_type& object, const domain_type& key_value)
+ {
+ const_iterator it_ = seqs<map_type>::find(object, key_value);
+ if(it_ != seqs<map_type>::end(object))
+ map_add<map_type,codomain_intersect,absorbs>::apply(section, *it_);
+
+ return section;
+ }
+
+ static map_type& apply(map_type& section, const map_type& object, const element_type& value_pair)
+ {
+ const_iterator it_ = seqs<map_type>::find(object, value_pair.first);
+ if(it_ != seqs<map_type>::end(object))
+ {
+ map_add<map_type,codomain_intersect,absorbs>::apply(section, *it_);
+ map_add<map_type,codomain_intersect,absorbs>::apply(section, value_pair);
+ }
+ return section;
+ }
+};
+
+//------------------------------------------------------------------------------
+//-P inplace_intersect
+//------------------------------------------------------------------------------
+
+template<class MapT, bool is_total>
+struct map_inplace_intersect
+{
+ typedef MapT map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::element_type element_type;
+
+ //JODO test add_intersection(c, a, b) == c += (a & b)
+ static map_type& apply(map_type&, const element_type&);
+ static map_type& apply(map_type&, const map_type&);
+};
+
+
+template<class MapT>
+struct map_inplace_intersect<MapT, true>
+{ // is_total
+ typedef MapT map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::element_type element_type;
+
+ static map_type& apply(map_type& object, const element_type& operand){return object += operand;}
+ static map_type& apply(map_type& object, const map_type& operand) {return object += operand;}
+};
+
+template<class MapT>
+struct map_inplace_intersect<MapT, false>
+{ // !is_total
+ typedef MapT map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::codomain_intersect codomain_intersect;
+ typedef typename map_type::const_iterator const_iterator;
+
+ static MapT& apply(MapT& object, const element_type& operand)
+ {
+ MapT section;
+ map_add_intersection<MapT,false>::apply(section, object, operand);
+ seqs<MapT>::swap(object, section);
+ return object;
+ }
+
+ static MapT& apply(MapT& object, const MapT& operand)
+ {
+ MapT section;
+ //CL map_add_intersection<MapT,false>::apply(section, object, operand);
+
+ const_iterator common_lwb_;
+ const_iterator common_upb_;
+ if(Set::common_range(common_lwb_, common_upb_, operand, object))
+ {
+ const_iterator sec_ = common_lwb_;
+ while(sec_ != common_upb_)
+ {
+ const_iterator it_ = seqs<MapT>::find(object, sec_->first);
+ if(it_ != seqs<MapT>::end(object))
+ {
+ itl::add(section, *it_);
+ map_add<MapT, codomain_intersect, absorbs_neutrons<MapT>::value >::apply(section, *sec_);
+ }
+ ++sec_;
+ }
+ }
+
+ seqs<MapT>::swap(object, section);
+ return object;
+ }
+
+};
+
+//------------------------------------------------------------------------------
+//-P intersects
+//------------------------------------------------------------------------------
+template<class MapT, bool is_total>
+struct map_intersects
+{
+ typedef MapT map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::set_type set_type;
+
+ static bool apply(map_type&, const domain_type&);
+ static bool apply(map_type&, const element_type&);
+ static bool apply(map_type&, const set_type&);
+ static bool apply(map_type&, const map_type&);
+};
+
+
+template<class MapT>
+struct map_intersects<MapT, true>
+{ // is_total
+ typedef MapT map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::set_type set_type;
+
+ static bool apply(map_type&, const domain_type&) {return true;}
+ static bool apply(map_type&, const element_type&){return true;}
+ static bool apply(map_type&, const set_type&) {return true;}
+ static bool apply(map_type&, const map_type&) {return true;}
+};
+
+template<class MapT>
+struct map_intersects<MapT, false>
+{ // !is_total
+ typedef MapT map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::set_type set_type;
+
+ static bool apply(const MapT& object, const domain_type& key)
+ {
+ return object.contains(key);
+ }
+
+ static bool apply(const MapT& object, const element_type& key_value_pair)
+ {
+ MapT intersection;
+ map_add_intersection<MapT,false>::apply(intersection, object, key_value_pair);
+ return !intersection.empty();
+ }
+
+ static bool apply(const MapT& object, const set_type& key_set)
+ {
+ if(object.iterative_size() < key_set.iterative_size())
+ return Map::intersects(object, key_set);
+ else
+ return Map::intersects(key_set, object);
+ }
+
+ static bool apply(const MapT& object, const MapT& operand)
+ {
+ if(object.iterative_size() < operand.iterative_size())
+ return Map::intersects(object, operand);
+ else
+ return Map::intersects(operand, object);
+ }
+};
+
+
+//==============================================================================
+//=P Symmetric difference
+//==============================================================================
+
+template<class MapT, bool codomain_is_set>
+struct map_flip_
+{
+ typedef MapT map_type;
+ typedef typename map_type::element_type element_type;
+
+ static void apply(MapT&, const element_type&);
+ static void apply(MapT&, const MapT&);
+};
+
+template<class MapT, bool is_total, bool absorbs_neutrons>
+struct map_flip
+{
+ typedef MapT map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::element_type element_type;
+
+ static map_type& apply(map_type&, const element_type&);
+ static map_type& apply(map_type&, const map_type&);
+};
+
+template<class MapT>
+struct map_flip<MapT, true, true>
+{ // is_total, absorbs_neutrons
+ typedef MapT map_type;
+ typedef typename map_type::element_type element_type;
+
+ static map_type& apply(map_type& object, const element_type&)
+ {
+ itl::clear(object);
+ return object;
+ }
+
+ static map_type& apply(map_type& object, const map_type&)
+ {
+ itl::clear(object);
+ return object;
+ }
+};
+
+template<class MapT>
+struct map_flip<MapT, true, false>
+{ // is_total, !absorbs_neutrons
+ typedef MapT map_type;
+ typedef typename map_type::codomain_type codomain_type;
+ BOOST_STATIC_CONSTANT(bool, codomain_is_set = (is_set<codomain_type>::value));
+
+ static map_type& apply(map_type& object, const map_type& operand)
+ {
+ map_flip_<MapT,codomain_is_set>::apply(object, operand);
+
+ ITL_FORALL(typename MapT, it_, object)
+ it_->second = neutron<codomain_type>::value();
+
+ return object;
+ }
+};
+
+template<class MapT, bool absorbs_neutrons>
+struct map_flip<MapT, false, absorbs_neutrons>
+{ // !is_total
+ typedef MapT map_type;
+ typedef typename map_type::codomain_type codomain_type;
+ BOOST_STATIC_CONSTANT(bool, codomain_is_set = (is_set<codomain_type>::value));
+
+ static map_type& apply(map_type& object, const map_type& operand)
+ {
+ map_flip_<MapT,codomain_is_set>::apply(object, operand);
+ return object;
+ }
+};
+
+//------------------------------------------------------------------------------
+template<class MapT>
+struct map_flip_<MapT, false>
+{ // !codomain_is_set
+ typedef MapT map_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::iterator iterator;
+ typedef typename map_type::const_iterator const_iterator;
+
+ static void apply(MapT& result, const element_type& value_pair)
+ {
+ std::pair<iterator,bool> insertion = itl::insert(result, value_pair);
+
+ if(!insertion.second)
+ MapT::subtract_::apply(result, *insertion.first);
+ }
+
+ static void apply(MapT& result, const MapT& x2)
+ {
+ const_iterator x2_ = seqs<MapT>::begin(x2);
+ while(x2_ != seqs<MapT>::end(x2))
+ apply(result, *x2_++);
+ }
+};
+
+
+template<class MapT>
+struct map_flip_<MapT, true>
+{ // codomain_is_set
+ typedef MapT map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::codomain_type codomain_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::iterator iterator;
+ typedef typename map_type::const_iterator const_iterator;
+ typedef typename map_type::inverse_codomain_intersect
+ inverse_codomain_intersect;
+
+ static void apply(MapT& result, const element_type& value_pair)
+ {
+ std::pair<iterator,bool> insertion = itl::insert(result, value_pair);
+
+ if(!insertion.second)
+ {
+ iterator res_ = insertion.first;
+ codomain_type common_value = res_->second;
+ domain_type key_value = res_->first;
+ inverse_codomain_intersect()(common_value, value_pair.second);
+ MapT::subtract_::apply(result, *res_);
+ itl::add(result, element_type(key_value, common_value));
+ }
+ }
+
+ static void apply(MapT& result, const MapT& x2)
+ {
+ const_iterator x2_ = seqs<MapT>::begin(x2);
+ while(x2_ != seqs<MapT>::end(x2))
+ apply(result, *x2_++);
+ }
+};
+
+
+
+
+//=============================================================================
+//=P Neutron absorbtion
+//=============================================================================
+
+template<class MapT, bool absorbs_neutrons>
+struct map_absorb_neutrons
+{
+ typedef MapT map_type;
+ static void apply(map_type&);
+};
+
+template<class MapT>
+struct map_absorb_neutrons<MapT, false>
+{ // !absorbs_neutrons
+ typedef MapT map_type;
+ static void absorb_neutrons(map_type&){}
+};
+
+
+template<class MapT>
+struct map_absorb_neutrons<MapT, true>
+{ // absorbs_neutrons
+ typedef MapT map_type;
+ typedef typename MapT::element_type element_type;
+
+ static void absorb_neutrons(map_type& object)
+ {
+ itl::erase_if(content_is_neutron<element_type>(), object);
+ }
+};
+
+
+}} // namespace itl boost
+
+#endif
+
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-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -13,6 +13,7 @@
#include <boost/itl/detail/notate.hpp>
#include <boost/itl/predicates.hpp>
#include <boost/itl/functors.hpp>
+#include <boost/itl/seqs.hpp>
/*
<b>SetAlgo </b>
@@ -36,7 +37,8 @@
lwb = x1.end();
upb = x1.end();
- if(ITL_FUN_REN(empty, is_empty, x1) || ITL_FUN_REN(empty, is_empty, x2))
+ //JODO gcc.3.4.4 :( if(itl::is_empty(x1) || itl::is_empty(x2))
+ if(x1.empty() || x2.empty())
return false;
IteratorT x1_fst_ = x1.begin();
@@ -68,7 +70,7 @@
typedef typename ObjectT::const_iterator Object_const_iterator;
typename ObjectT::iterator prior_ = result.end();
for(Object_const_iterator x2_ = x2.begin(); x2_ != x2.end(); x2_++)
- prior_ = result.add(prior_, *x2_);
+ prior_ = add(result, prior_, *x2_);
return result;
}
@@ -115,8 +117,8 @@
bool within(const SetType& sub, const SetType& super)
{
if(&super == &sub) return true;
- if(ITL_FUN_REN(empty, is_empty, sub)) return true;
- if(ITL_FUN_REN(empty, is_empty, super)) return false;
+ if(itl::is_empty(sub)) return true;
+ if(itl::is_empty(super)) return false;
if(*sub.begin() < *super.begin()) return false;
if(*super.rbegin() < *sub.rbegin() ) return false;
Modified: sandbox/itl/boost/itl/discrete_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/discrete_interval.hpp (original)
+++ sandbox/itl/boost/itl/discrete_interval.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -28,7 +28,7 @@
public:
typedef discrete_interval<DomainT,Compare> type;
typedef DomainT domain_type;
- typedef typename bounded_value<DomainT,Compare>::type bounded_domain_type;
+ typedef typename bounded_value<DomainT>::type bounded_domain_type;
public:
//==========================================================================
@@ -107,21 +107,45 @@
}
-//------------------------------------------------------------------------------
-//- intervals: Adapt interval class to interval concept
-//------------------------------------------------------------------------------
+
+//==============================================================================
+//=T discrete_interval -> concept intervals
+//==============================================================================
+template<class DomainT, ITL_COMPARE Compare>
+struct intervals< itl::discrete_interval<DomainT, Compare> >
+{
+ typedef intervals type;
+ typedef DomainT domain_type;
+ typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
+ typedef itl::discrete_interval<DomainT, Compare> interval_type;
+
+ static interval_type construct(const domain_type& lo, const domain_type& up)
+ {
+ return interval_type(lo, up);
+ }
+
+ static domain_type lower(const interval_type& inter_val){ return inter_val.lower(); };
+ static domain_type upper(const interval_type& inter_val){ return inter_val.upper(); };
+};
+
+
+
+//==============================================================================
+//=T discrete_interval -> concept dynamic_intervals
+//==============================================================================
template<class DomainT, ITL_COMPARE Compare>
struct dynamic_intervals<boost::itl::discrete_interval<DomainT,Compare> >
{
+ typedef dynamic_intervals type;
typedef boost::itl::discrete_interval<DomainT,Compare> interval_type;
static interval_type construct(const DomainT& lo, const DomainT& up, interval_bounds bounds)
{
- return interval_type(lo, up, bounds, static_cast<interval_type* >(0) );
+ return interval_type(lo, up, bounds, static_cast<interval_type*>(0) );
}
- static interval_type construct_bounded(const bounded_value<DomainT,Compare>& lo,
- const bounded_value<DomainT,Compare>& up)
+ static interval_type construct_bounded(const bounded_value<DomainT>& lo,
+ const bounded_value<DomainT>& up)
{
return interval_type
(
Modified: sandbox/itl/boost/itl/functions.hpp
==============================================================================
--- sandbox/itl/boost/itl/functions.hpp (original)
+++ sandbox/itl/boost/itl/functions.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -11,8 +11,11 @@
#include <boost/mpl/and.hpp>
#include <boost/mpl/or.hpp>
#include <boost/utility/enable_if.hpp>
+#include <boost/itl/type_traits/is_interval_container.hpp>
#include <boost/itl/type_traits/is_element_container.hpp>
#include <boost/itl/type_traits/is_combinable.hpp>
+#include <boost/itl/detail/interval_map_functors.hpp>
+#include <boost/itl/detail/interval_map_algo.hpp>
namespace boost{namespace itl
{
@@ -27,11 +30,7 @@
typename enable_if<is_interval_container<ObjectT>, void>::type
clear(ObjectT& object) //JODO test
{
-#ifdef ITL_CONCEPT_ORIENTED //JODO find final decision
object.erase(object.begin(), object.end());
-#else //ITL_OBJECT_ORIENTED
- object.clear();
-#endif
}
/** Tests if the container is empty.
@@ -40,11 +39,7 @@
typename enable_if<is_interval_container<ObjectT>, bool>::type
is_empty(const ObjectT& object)
{
-#ifdef ITL_CONCEPT_ORIENTED //JODO find final decision
return object.begin() == object.end();
-#else //ITL_OBJECT_ORIENTED
- return object.empty();
-#endif
}
@@ -57,7 +52,8 @@
bool>::type
contains(const ObjectT& super, const OperandT& sub)
{
- return Interval_Set::contains(super, sub);
+ return interval_map_contains<ObjectT>::apply(super, sub);
+ //CL?? return Interval_Set::contains(super, sub);
}
template<class ObjectT, class OperandT>
@@ -74,7 +70,8 @@
bool>::type
contains(const ObjectT& super, const OperandT& sub)
{
- return Interval_Map::contains(super, sub);
+ return interval_map_contains<ObjectT>::apply(super, sub);
+ //CL?? return Interval_Map::contains(super, sub);
}
template<class ObjectT, class OperandT>
@@ -91,7 +88,8 @@
bool>::type
contains(const ObjectT& super, const OperandT& sub)
{
- return Interval_Map::contains(super, sub);
+ return interval_map_contains_key<ObjectT, is_total<ObjectT>::value>::apply(super, sub);
+ //CL?? return Interval_Map::contains(super, sub);
}
template<class ObjectT, class IntervalSetT>
@@ -100,7 +98,8 @@
bool>::type
contains(const ObjectT& super, const IntervalSetT& sub)
{
- return Interval_Map::contains(super, sub);
+ return interval_map_contains_key<ObjectT, is_total<ObjectT>::value>::apply(super, sub);
+ //CL?? return Interval_Map::contains(super, sub);
}
@@ -408,7 +407,7 @@
ObjectT>::type&
erase(ObjectT& object, const OperandT& operand)
{
- if(ITL_FUN_REN(empty, is_empty, operand))
+ if(itl::is_empty(operand))
return object;
typename OperandT::const_iterator common_lwb;
@@ -490,7 +489,7 @@
while(it_ != right_common_upper_)
{
left.add_intersection(intersection, *it_++);
- if(!ITL_FUN_REN(empty, is_empty, intersection))
+ if(!itl::is_empty(intersection))
return true;
}
@@ -509,7 +508,7 @@
{
LeftT intersection;
- if(ITL_FUN_REN(empty, is_empty, left) || ITL_FUN_REN(empty, is_empty, right))
+ if(itl::is_empty(left) || itl::is_empty(right))
return false;
typename RightT::const_iterator right_common_lower_;
@@ -522,7 +521,7 @@
while(it_ != right_common_upper_)
{
left.add_intersection(intersection, RightT::key_value(it_++));
- if(!ITL_FUN_REN(empty, is_empty, intersection))
+ if(!itl::is_empty(intersection))
return true;
}
@@ -616,7 +615,7 @@
hull(const ObjectT& object)
{
return
- ITL_FUN_REN(empty, is_empty, object) ? neutron<typename ObjectT::interval_type>::value()
+ itl::is_empty(object) ? neutron<typename ObjectT::interval_type>::value()
: hull((ObjectT::key_value(object.begin())), ObjectT::key_value(object.rbegin()));
}
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-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -40,6 +40,8 @@
DomainT key;
CodomainT data;
+ mapping_pair():key(), data(){}
+
mapping_pair(const DomainT& key_value, const CodomainT& data_value)
:key(key_value), data(data_value){}
@@ -479,7 +481,7 @@
{
typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> operand_type;
- if(ITL_FUN_REN(empty, is_empty, operand))
+ if(itl::is_empty(operand))
return *that();
typename operand_type::const_iterator common_lwb;
@@ -543,7 +545,7 @@
)const
{
typedef IntervalSet<DomainT,Compare,Interval,Alloc> sectant_type;
- if(ITL_FUN_REN(empty, is_empty, sectant))
+ if(itl::is_empty(sectant))
return;
typename sectant_type::const_iterator common_lwb;
@@ -608,7 +610,7 @@
type intersection;
add_intersection(intersection, interval_value_pair);
- return !ITL_FUN_REN(empty, is_empty, intersection);
+ return !itl::is_empty(intersection);
}
@@ -736,17 +738,14 @@
static const key_type& key_value(IteratorT value_){ return (*value_).first; }
template<typename IteratorT>
- static const data_type& data_value(IteratorT value_){ return (*value_).second; }
-
- template<typename IteratorT>
static codomain_type codomain_value(IteratorT value_){ return (*value_).second; }
template<typename LeftIterT, typename RightIterT>
static bool key_less(LeftIterT left_, RightIterT right_)
{ return key_compare()((*left_).first, (*right_).first); }
- static value_type make_domain_element(const domain_type& dom_val, const codomain_type& codom_val)
- { return value_type(interval_type(dom_val), codom_val); }
+ static value_type make_value(const key_type& key_value, const codomain_type& codom_val)
+ { return value_type(key_value, codom_val); }
protected:
sub_type* that() { return static_cast<sub_type*>(this); }
@@ -773,7 +772,7 @@
}
template <class Combiner>
- std::pair<iterator,bool> map_insert(const interval_type& inter_val, const codomain_type& co_val)
+ std::pair<iterator,bool> _map_insert(const interval_type& inter_val, const codomain_type& co_val)
{
if(mpl::and_<is_total<type>, has_inverse<codomain_type>, is_negative<Combiner> >::value)
return this->_map.insert(value_type(inter_val, version<Combiner>()(co_val)));
@@ -784,7 +783,7 @@
// Insertion with hint, that does report insertion failure
template <class Combiner>
std::pair<iterator, bool>
- map_insert(iterator prior_, const interval_type& inter_val, const codomain_type& co_val)
+ _map_insert(iterator prior_, const interval_type& inter_val, const codomain_type& co_val)
{
iterator inserted_
= this->_map.insert(prior_, value_type(inter_val, co_val));
@@ -799,7 +798,7 @@
template <class Combiner>
std::pair<iterator, bool>
- map_add(iterator prior_, const interval_type& inter_val, const codomain_type& co_val)
+ _map_add(iterator prior_, const interval_type& inter_val, const codomain_type& co_val)
{
// Never try to insert a neutron into a neutron absorber here:
BOOST_ASSERT(!(Traits::absorbs_neutrons && co_val==Combiner::neutron()));
@@ -1563,7 +1562,7 @@
struct is_set<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_set<itl::interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- BOOST_STATIC_CONSTANT(bool, value = true);
+ BOOST_STATIC_CONSTANT(bool, value = (is_set<CodomainT>::value));
};
template
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-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -465,8 +465,8 @@
static bool key_less(LeftIterT lhs_, RightIterT rhs_)
{ return key_compare()(*lhs_, *rhs_); }
- static value_type make_domain_element(const domain_type& dom_val, const codomain_type&)
- { return value_type(interval_type(dom_val)); }
+ static value_type make_value(const key_type& key_value, const codomain_type&)
+ { return value_type(key_value); }
protected:
sub_type* that() { return static_cast<sub_type*>(this); }
Modified: sandbox/itl/boost/itl/interval_bounds.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_bounds.hpp (original)
+++ sandbox/itl/boost/itl/interval_bounds.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -174,12 +174,12 @@
{ return right_subtract_bounds(x1.bounds(), x2.bounds()); }
-template<class DomainT, ITL_COMPARE Compare>
+template<class DomainT>
class bounded_value
{
public:
typedef DomainT domain_type;
- typedef bounded_value<DomainT,Compare> type;
+ typedef bounded_value<DomainT> type;
public:
bounded_value(const domain_type& value, interval_bounds bound)
: _value(value), _bound(bound) {}
Modified: sandbox/itl/boost/itl/interval_functions.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_functions.hpp (original)
+++ sandbox/itl/boost/itl/interval_functions.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -29,7 +29,7 @@
//==============================================================================
class interval_bounds; //JODO separate dynamically and statically bounded interval concepts
-template<class DomainT, ITL_COMPARE Compare> class bounded_value;
+template<class DomainT> class bounded_value;
//------------------------------------------------------------------------------
//- Adapter classes
@@ -54,8 +54,8 @@
typedef typename IntervalT::domain_compare domain_compare;
static IntervalT construct(const domain_type& lo, const domain_type& up, interval_bounds bounds);
- static IntervalT construct_bounded(const bounded_value<domain_type,domain_compare>& lo,
- const bounded_value<domain_type,domain_compare>& up);
+ static IntervalT construct_bounded(const bounded_value<domain_type>& lo,
+ const bounded_value<domain_type>& up);
};
@@ -571,7 +571,7 @@
typename IntervalT::size_type>::type
cardinality(const IntervalT& object)
{
- return (last(object) + itl::unon<IntervalT::size_type>::value()) - first(object);
+ return (last(object) + itl::unon<typename IntervalT::size_type>::value()) - first(object);
}
@@ -592,7 +592,7 @@
typename IntervalT::size_type>::type
cardinality(const IntervalT& object)
{
- return (last(object) + itl::unon<IntervalT::size_type>::value()) - first(object);
+ return (last(object) + itl::unon<typename IntervalT::size_type>::value()) - first(object);
}
@@ -601,7 +601,9 @@
//- size -----------------------------------------------------------------------
template<class IntervalT>
-inline typename IntervalT::size_type size(const IntervalT& object)
+inline typename enable_if<is_interval<IntervalT>,
+ typename IntervalT::size_type>::type
+size(const IntervalT& object)
{
return cardinality(object);
}
@@ -620,7 +622,7 @@
typename IntervalT::difference_type>::type
length(const IntervalT& object)
{
- return (last(object) + itl::unon<IntervalT::difference_type>::value())
+ return (last(object) + itl::unon<typename IntervalT::difference_type>::value())
- first(object);
}
@@ -637,7 +639,7 @@
typename IntervalT::difference_type>::type
length(const IntervalT& object)
{
- return (last(object) + itl::unon<IntervalT::difference_type>::value())
+ return (last(object) + itl::unon<typename IntervalT::difference_type>::value())
- first(object);
}
Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -276,7 +276,7 @@
return;
std::pair<iterator,bool> insertion
- = this->template map_insert<Combiner>(inter_val, co_val);
+ = this->template _map_insert<Combiner>(inter_val, co_val);
if(insertion.second)
join_neighbours(insertion.first);
@@ -312,7 +312,7 @@
return prior_;
std::pair<iterator,bool> insertion
- = this->template map_add<Combiner>(prior_, inter_val, co_val);
+ = this->template _map_add<Combiner>(prior_, inter_val, co_val);
if(insertion.second)
return join_neighbours(insertion.first);
@@ -470,7 +470,7 @@
//NOTE: This is NOT an insertion that has to take care for correct application of
// the Combiner functor. It only reestablished that state after splitting the
- // 'it_' interval value pair. Using map_insert<Combiner> does not work here.
+ // 'it_' interval value pair. Using _map_insert<Combiner> does not work here.
iterator insertion_ = this->_map.insert(it_, value_type(right_resid, it_->second));
join_right(insertion_);
@@ -637,7 +637,7 @@
return prior_;
std::pair<iterator,bool> insertion
- = this->template map_insert<codomain_combine>(prior_, inter_val, co_val);
+ = this->template _map_insert<codomain_combine>(prior_, inter_val, co_val);
if(insertion.second)
return join_neighbours(insertion.first);
@@ -788,7 +788,7 @@
struct is_set<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_set<itl::interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- BOOST_STATIC_CONSTANT(bool, value = true);
+ BOOST_STATIC_CONSTANT(bool, value = (is_set<CodomainT>::value));
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2007-2009: Joachim Faulhaber
+Copyright (c) 2007-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
@@ -24,22 +24,21 @@
#include <boost/itl/detail/design_config.hpp>
#include <boost/itl/detail/concept_check.hpp>
#include <boost/itl/type_traits/is_map.hpp>
+#include <boost/itl/type_traits/is_element_container.hpp>
#include <boost/itl/type_traits/has_inverse.hpp>
#include <boost/itl/type_traits/to_string.hpp>
+#include <boost/itl/seqs.hpp>
#include <boost/itl/functors.hpp>
#include <boost/itl/predicates.hpp>
#include <boost/itl/set.hpp>
+#include <boost/itl/map_functions.hpp>
#include <boost/itl/detail/map_algo.hpp>
+#include <boost/itl/detail/map_functors.hpp>
namespace boost{namespace itl
{
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127) // conditional expression is constant
-#endif
-
struct partial_absorber
{
enum { absorbs_neutrons = true };
@@ -79,6 +78,71 @@
inline std::string type_to_string<total_enricher>::apply() { return "e^0"; }
+template<class, class, class, ITL_COMPARE, ITL_COMBINE, ITL_SECTION, ITL_ALLOC>
+class map;
+
+//==============================================================================
+//=+ seqs
+//==============================================================================
+
+template<class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+struct seqs< itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
+{
+ typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> map_type;
+ typedef typename map_type::domain_type domain_type;
+ typedef typename map_type::codomain_type codomain_type;
+ typedef typename map_type::element_type element_type;
+ typedef typename map_type::size_type size_type;
+ typedef typename map_type::domain_compare domain_compare;
+
+ typedef typename map_type::iterator iterator;
+ typedef typename map_type::const_iterator const_iterator;
+
+ static const_iterator begin(const map_type& object){ return object.begin(); }
+ static iterator begin( map_type& object){ return object.begin(); }
+ static const_iterator end (const map_type& object){ return object.end(); }
+ static iterator end ( map_type& object){ return object.end(); }
+ static size_type size (const map_type& object){ return object.size(); }
+
+ static const_iterator find(const map_type& object, const domain_type& key)
+ { return object.find(key); }
+
+ static iterator find(map_type& object, const domain_type& key)
+ { return object.find(key); }
+
+ static std::pair<iterator,bool> insert(map_type& object, const element_type& key_value_pair)
+ { return object.insert(key_value_pair); }
+
+ static iterator insert(map_type& object, iterator prior, const element_type& key_value_pair)
+ { return object.insert(prior, key_value_pair); }
+
+ static void erase(map_type& object, iterator pos)
+ { object.erase(pos); }
+
+ static void erase(map_type& object, iterator first, iterator past)
+ { object.erase(first, past); }
+
+ static void swap(map_type& left, map_type& right)
+ { left.swap(right); }
+
+ //--------------------------------------------------------------------------
+ template<typename IteratorT>
+ static const domain_type& key_value(IteratorT value_){ return value_->first; }
+
+ template<typename IteratorT>
+ static const codomain_type& co_value(IteratorT value_){ return value_->second; }
+
+ template<typename LeftIterT, typename RightIterT>
+ static bool key_less(LeftIterT lhs_, RightIterT rhs_)
+ { return domain_compare()((*lhs_).first,(*rhs_).first); }
+
+ static element_type make_value(const domain_type& key_value, const codomain_type& data_value)
+ { return element_type(key_value, data_value); }
+};
+
+//==============================================================================
+
+
/** \brief Addable, subractable and intersectable maps */
template
<
@@ -114,11 +178,34 @@
typedef ITL_COMPARE_DOMAIN(Compare,DomainT) domain_compare;
typedef ITL_COMBINE_CODOMAIN(Combine,CodomainT) codomain_combine;
typedef domain_compare key_compare;
+ typedef ITL_COMPARE_DOMAIN(Compare,element_type) element_compare;
typedef typename inverse<codomain_combine >::type inverse_codomain_combine;
- typedef ITL_SECTION_CODOMAIN(Section,CodomainT) codomain_intersect;
+ typedef typename mpl::if_
+ <is_set<codomain_type>
+ , ITL_SECTION_CODOMAIN(Section,CodomainT)
+ , codomain_combine
+ >::type codomain_intersect; //JODO extra metafuction?
+ //JODO What, if codomain is not a set but the user want's to use a special intersection functor?
typedef typename inverse<codomain_intersect>::type inverse_codomain_intersect;
typedef typename base_type::value_compare value_compare;
+ BOOST_STATIC_CONSTANT(bool, _total = (Traits::is_total));
+ BOOST_STATIC_CONSTANT(bool, _absorbs = (Traits::absorbs_neutrons));
+ BOOST_STATIC_CONSTANT(bool,
+ total_invertible = (mpl::and_<is_total<type>, has_inverse<codomain_type> >::value));
+
+ typedef map_add<type,codomain_combine,_absorbs> add_;
+ typedef map_subtract<type,total_invertible> subtract_;
+
+ typedef map_insert<type,codomain_combine,_absorbs> insert_;
+ typedef map_erase<type,codomain_combine,_absorbs> erase_;
+
+ typedef map_add_intersection<type,_total> add_intersection_;
+ typedef map_inplace_intersect<type,_total> inplace_intersect_;
+ typedef map_intersects<type,_total> intersects_;
+
+ typedef map_flip<type,_total,_absorbs> flip_;
+
public:
typedef typename base_type::pointer pointer;
typedef typename base_type::const_pointer const_pointer;
@@ -173,11 +260,9 @@
void swap(map& src) { base_type::swap(src); }
//==========================================================================
-ITL_BEGIN_COMMON_MEMBER_FUNCTIONS:
using base_type::empty;
using base_type::clear;
-ITL_END_COMMON_MEMBER_FUNCTIONS:
using base_type::begin;
using base_type::end;
using base_type::rbegin;
@@ -189,6 +274,7 @@
using base_type::key_comp;
using base_type::value_comp;
+ using base_type::insert;
using base_type::erase;
using base_type::find;
using base_type::count;
@@ -204,23 +290,12 @@
//= Containedness
//==========================================================================
- /** Checks if a key is in the map */
- bool contains(const domain_type& key)const { return !(find(key) == end()); }
-
- /** Checks if a key-value pair is in the map */
- bool contains(const element_type& key_value_pair)const
- {
- const_iterator found_ = find(key_value_pair.first);
- return found_ != end() && found_->second == key_value_pair.second;
- }
+ template<class SubObject>
+ bool contains(const SubObject& sub)const
+ { return itl::contains(*this, sub); }
- /** Is <tt>*this</tt> contained in <tt>super</tt>? */
- bool contained_in(const map& super)const
- { return Map::within(*this, super); }
-
- /** Does <tt>*this</tt> contain <tt>sub</tt>? */
- bool contains(const map& sub)const
- { return Map::within(sub, *this); }
+ bool within(const map& super)const
+ { return itl::contains(super, *this); }
//==========================================================================
//= Size
@@ -228,9 +303,9 @@
/** \c iterative_size() yields the number of elements that is visited
throu complete iteration. For interval sets \c iterative_size() is
different from \c size(). */
- size_t iterative_size()const { return size(); }
+ size_t iterative_size()const { return size(); } //JODO
- size_t cardinality()const { return size(); }
+ //CL?? size_t cardinality()const { return size(); }
//==========================================================================
//= Selection
@@ -253,56 +328,31 @@
value is added to the data value already found in the map. */
map& add(const value_type& value_pair)
{
- typedef invertible_maps
- <type, codomain_combine, absorbs_neutrons<type>::value,
- adds_inversely<type,codomain_combine>::value > invertible_map_type;
- return invertible_map_type::add(*this, value_pair);
- //CL? return _add<codomain_combine>(value_pair);
+ return itl::add(*this, value_pair);
}
/** \c add add \c value_pair into the map using \c prior as a hint to
insert \c value_pair after the position \c prior is pointing to. */
iterator add(iterator prior, const value_type& value_pair)
{
- return _add<codomain_combine>(prior, value_pair);
+ return itl::add(*this, prior, value_pair);
}
/** If the \c value_pair's key value is in the map, it's data value is
subtraced from the data value stored in the map. */
map& subtract(const value_type& value_pair)
{
- if(Traits::is_total && has_inverse<codomain_type>::value)
- this->template _add<inverse_codomain_combine>(value_pair);
- else
- this->template _subtract<inverse_codomain_combine>(value_pair);
-
- return *this;
+ return itl::subtract(*this, value_pair);
}
//==========================================================================
//= Insertion, erasure
//==========================================================================
- std::pair<iterator,bool> insert(const value_type& value_pair)
- {
- if(Traits::absorbs_neutrons && value_pair.second == codomain_combine::neutron())
- return std::pair<iterator,bool>(end(),true);
- else
- return base_type::insert(value_pair);
- }
-
- iterator insert(iterator prior, const value_type& value_pair)
- {
- if(Traits::absorbs_neutrons && value_pair.second == codomain_combine::neutron())
- return end();
- else
- return base_type::insert(prior, value_pair);
- }
-
/** With <tt>key_value_pair = (k,v)</tt> set value \c v for key \c k */
map& set(const element_type& key_value_pair)
{
- (*this)[key_value_pair.first] = key_value_pair.second;
+ (*this)[key_value_pair.first] = key_value_pair.second; //JODO absorbs_neutrons?
return *this;
}
@@ -314,69 +364,35 @@
//= Intersection
//==========================================================================
- /** The intersection of \c key in \c *this map is added to \c section. */
- void add_intersection(map& section, const domain_type& key_value)const;
-
- /** The intersection of \c key_value_pair and \c *this map is added to \c section. */
- void add_intersection(map& section, const element_type& key_value_pair)const;
-
- /** The intersection of set \c sectant with \c *this map is added to \c section. */
- void add_intersection(map& section, const set_type& sectant)const;
-
- /** The intersection of map \c sectant with \c *this map is added to \c section. */
- void add_intersection(map& section, const map& sectant)const;
-
- /** Returns true, if there is an intersection of \c key and \c *this map.
- Functions \c intersects and \c contains are identical on key value arguments
- of type \c domain_type. Complexity: Logarithmic in container size. */
- bool intersects(const domain_type& key)const;
-
- /** Returns true, if there is an intersection of \key_value_pair and \c *this map.
- If the key is found, the content of \c key_value_pair has to have an intersection
- with the content of the data value in the map.
- Complexity: Logarithmic in container size. */
- bool intersects(const element_type& key_value_pair)const;
+ /** The intersection of \c operand in \c *this map is added to \c section. */
+ template<class OperandT>
+ map& add_intersection(map& section, const OperandT& operand)const
+ { return itl::add_intersection(section, *this, operand); }
+
+ /** Returns true, if there is an intersection of \c operand and \c *this map. */
+ template<class OperandT>
+ bool intersects(const OperandT& operand)const
+ {
+ return itl::intersects(*this, operand);
+ }
//==========================================================================
//= Symmetric difference
//==========================================================================
- map& flip(const element_type& key_value_pair)
- { Map::flip(*this, map(key_value_pair)); return *this; }
-
-
- //==========================================================================
- //= Morphisms
- //==========================================================================
-
- void absorb_neutrons()
- {
- //content_is_neutron<key_type, data_type> neutron_dropper;
- if(!Traits::absorbs_neutrons)
- erase_if(content_is_neutron<value_type>());
+ map& flip(const element_type& value_pair)
+ {
+ return (*this) ^= value_pair;
}
//==========================================================================
- //= Representation
- //==========================================================================
-
- /** Represent this map as string */
- std::string as_string()const;
-
- //==========================================================================
//= Algorithm unifiers
//==========================================================================
/** \c key_value allows for a uniform access to \c key_values which is
is used for common algorithms on sets and maps. */
template<typename IteratorT>
- static const key_type& key_value(IteratorT value_)
- { return (*value_).first; }
-
- /** \c data_value allows for a uniform access to \c data_values which is
- is used for common algorithms on sets and maps. */
- template<typename IteratorT>
- static const data_type& data_value(IteratorT value_){ return (*value_).second; }
+ static const key_type& key_value(IteratorT value_){ return (*value_).first; }
/** \c codomain_value allows for a uniform access to \c codomain_values which is
is used for common algorithms on sets and maps. */
@@ -389,21 +405,8 @@
static bool key_less(LeftIterT lhs_, RightIterT rhs_)
{ return key_compare()((*lhs_).first,(*rhs_).first); }
- /** \c iterative_size() yields the number of elements that is visited
- throu complete iteration. For interval sets \c iterative_size() is
- different from \c size(). */
- static value_type make_element(const key_type& key_val, const data_type& data_val)
- { return value_type(key_val, data_val); }
-
- /** Erase the elements in *this map to which property \c hasProperty applies.
- Keep all the rest. */
- template<class Predicate>
- map& erase_if(const Predicate&);
-
- /** Copy the elements in map \c src to which property \c hasProperty applies
- into \c *this map. */
- template<class Predicate>
- map& assign_if(const map& src, const Predicate&);
+ static value_type make_value(const key_type& key_value, const codomain_type& data_value)
+ { return value_type(key_value, data_value); }
/** Copy the key values of the map to \c domain_set. Complexity: Linear. */
void domain(set_type& domain_set)const
@@ -412,901 +415,10 @@
ITL_const_FORALL_THIS(it_)
prior_ = domain_set.insert(prior_, it_->first);
}
-
-private:
- template<class Combiner>
- map& _add(const value_type& value_pair);
-
- template<class Combiner>
- iterator _add(iterator prior, const value_type& value_pair);
-
- template<class Combiner>
- map& _subtract(const value_type& value_pair);
-};
-
-
-//==============================================================================
-//=+ invertible_maps
-//==============================================================================
-template<class MapT, class Combiner,
- bool absorbs_neutrons, bool creates_inverse>
-struct invertible_maps
-{
- static MapT& add(MapT& object, const typename MapT::value_type& val);
-};
-
-template <class MapT, class Combiner>
-struct invertible_maps<MapT, Combiner, true, true > // absorbs_neutrons, creates_inverse
-{
- typedef MapT map_type;
- typedef typename map_type::value_type value_type;
- typedef typename map_type::iterator iterator;
-
- static map_type& add(map_type& object, const value_type& val)
- {
- if(val.second == Combiner::neutron())
- return object;
-
- std::pair<iterator, bool>
- insertion = object.insert(value_type(val.first, version<Combiner>()(val.second)));
-
- if( insertion.second )
- return object;
- else
- {
- iterator it = insertion.first;
- Combiner()((*it).second, val.second);
-
- if((*it).second == Combiner::neutron())
- object.erase(it);
-
- return object;
- }
-
- }
-};
-
-template <class MapT, class Combiner>
-struct invertible_maps<MapT, Combiner, true, false > // absorbs_neutrons, !creates_inverse
-{
- typedef MapT map_type;
- typedef typename map_type::value_type value_type;
- typedef typename map_type::iterator iterator;
-
- static map_type& add(map_type& object, const value_type& val)
- {
- if(val.second == Combiner::neutron())
- return object;
-
- std::pair<iterator, bool> insertion = object.insert(val);
-
- if( insertion.second )
- return object;
- else
- {
- iterator it = insertion.first;
- Combiner()((*it).second, val.second);
-
- if((*it).second == Combiner::neutron())
- object.erase(it);
-
- return object;
- }
- }
-};
-
-template <class MapT, class Combiner>
-struct invertible_maps<MapT, Combiner, false, true> // !absorbs_neutrons, creates_inverse
-{
- typedef MapT map_type;
- typedef typename map_type::value_type value_type;
- typedef typename map_type::iterator iterator;
-
- static map_type& add(map_type& object, const value_type& val)
- {
- std::pair<iterator, bool>
- insertion = object.insert(value_type(val.first, version<Combiner>()(val.second)));
-
- if( insertion.second )
- return object;
- else
- {
- iterator it = insertion.first;
- Combiner()((*it).second, val.second);
- return object;
- }
- }
-};
-
-template <class MapT, class Combiner>
-struct invertible_maps<MapT, Combiner, false, false> // !absorbs_neutrons, !creates_inverse
-{
- typedef MapT map_type;
- typedef typename map_type::value_type value_type;
- typedef typename map_type::iterator iterator;
-
- static map_type& add(map_type& object, const value_type& val)
- {
- std::pair<iterator, bool> insertion = object.insert(val);
-
- if( insertion.second )
- return object;
- else
- {
- iterator it = insertion.first;
- Combiner()((*it).second, val.second);
- return object;
- }
- }
};
-//==============================================================================
-//= Addition
-//==============================================================================
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
- template <class Combiner>
-map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
- map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::_add(const value_type& val)
-{
- if(Traits::absorbs_neutrons && val.second == Combiner::neutron())
- return *this;
-
- std::pair<iterator, bool> insertion;
- if(mpl::and_<is_total<type>, has_inverse<codomain_type>, is_negative<Combiner> >::value)
- insertion = insert(value_type(val.first, version<Combiner>()(val.second)));
- else // Existential case
- insertion = insert(val);
-
- if( insertion.second )
- return *this;
- else
- {
- iterator it = insertion.first;
- Combiner()((*it).second, val.second);
-
- if(Traits::absorbs_neutrons && (*it).second == Combiner::neutron())
- erase(it);
-
- return *this;
- }
-}
-
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
- template <class Combiner>
-typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::iterator
- map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
- ::_add(iterator prior_, const value_type& val)
-{
- if(Traits::absorbs_neutrons && val.second == Combiner::neutron())
- return end();
-
- iterator inserted_ = base_type::insert(prior_, value_type(val.first, Combiner::neutron()));
- Combiner()(inserted_->second, val.second);
-
- if(Traits::absorbs_neutrons && inserted_->second == Combiner::neutron())
- {
- erase(inserted_);
- return end();
- }
- else
- return inserted_;
-}
-
-
-//==============================================================================
-//= Subtraction
-//==============================================================================
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
- template <class Combiner>
-map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
- map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::_subtract(const value_type& val)
-{
- iterator it_ = find(val.first);
- if(it_ != end())
- {
- Combiner()((*it_).second, val.second);
- if(Traits::absorbs_neutrons && (*it_).second == codomain_combine::neutron())
- erase(it_);
- }
- return *this;
-}
-
-
-
-//==============================================================================
-//= Erasure
-//==============================================================================
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::size_type
- map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
- ::erase(const value_type& value_pair)
-{
- if(Traits::absorbs_neutrons && value_pair.second == codomain_combine::neutron())
- return 0; // neutrons are never contained 'substantially'
- // only 'virtually'.
-
- iterator it_ = find(value_pair.first);
- if(it_ != end() && value_pair.second == it_->second)
- {
- erase(it_);
- return 1;
- }
-
- return 0;
-}
-
-
-//==============================================================================
-//= Intersection
-//==============================================================================
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-void map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
- ::add_intersection(map& section, const value_type& sectant)const
-{
- if(Traits::is_total)
- {
- section = *this;
- section.add(sectant);
- }
- else
- {
- const_iterator it_ = find(sectant.first);
- if(it_ != end())
- {
- section.add(*it_);
- if(is_set<codomain_type>::value)
- section.template _add<codomain_intersect>(sectant);
- else
- section.template _add<codomain_combine>(sectant);
- }
- }
-}
-
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-void map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
- ::add_intersection(map& section, const domain_type& sectant)const
-{
- const_iterator it_ = find(sectant);
- if(it_ != end())
- section.add(*it_);
-}
-
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-void map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
- ::add_intersection(map& section, const typename map::set_type& sectant)const
-{
- typename set_type::const_iterator common_lwb_;
- typename set_type::const_iterator common_upb_;
- if(!Set::common_range(common_lwb_, common_upb_, sectant, *this))
- return;
-
- typename set_type::const_iterator sec_ = common_lwb_;
- while(sec_ != common_upb_)
- add_intersection(section, *sec_++);
-}
-
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-void map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
- ::add_intersection(map& section, const map& sectant)const
-{
- const_iterator common_lwb_;
- const_iterator common_upb_;
- if(!Set::common_range(common_lwb_, common_upb_, sectant, *this))
- return;
-
- const_iterator sec_ = common_lwb_;
- while(sec_ != common_upb_)
- {
- const_iterator it_ = find(sec_->first);
- if(it_ != end())
- {
- section.add(*it_);
- if(is_set<CodomainT>::value)
- section.template _add<codomain_intersect>(*sec_);
- else
- section.template _add<codomain_combine>(*sec_);
- }
- ++sec_;
- }
-}
-
-//------------------------------------------------------------------------------
-//- intersects
-//------------------------------------------------------------------------------
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline bool map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
- ::intersects(const domain_type& key)const
-{
- return traits::is_total || contains(key);
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline bool map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
- ::intersects(const element_type& key_value_pair)const
-{
- if(traits::is_total)
- return true;
-
- type intersection;
- add_intersection(intersection, key_value_pair);
- return !intersection.empty();
-}
-
-
-//==============================================================================
-//= Conversion
-//==============================================================================
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-std::string map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::as_string()const
-{
- std::string repr;
- ITL_const_FORALL_THIS(it) {
- std::string elem("(");
- elem += to_string<DomainT>::apply((*it).first);
- elem += "->";
- elem += to_string<CodomainT>::apply((*it).second);
- elem += ")";
-
- repr += elem;
- }
- return repr;
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
- template<class Predicate>
-map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
- ::erase_if(const Predicate& pred)
-{
- iterator it = begin();
- while(it != end())
- if(Predicate()(*it))
- erase(it++);
- else ++it;
- return *this;
-}
-
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
- template<class Predicate>
-map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
- ::assign_if(const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& src, const Predicate& pred)
-{
- clear();
- const_iterator it = src.begin();
- while(it != src.end())
- if(pred(*it))
- add(*it++);
-
- return *this;
-}
-
-//-------------------------------------------------------------------------
-template <class DomainT, class CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
- insert(map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& addend)
-{
- typedef map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> map_type;
-
- ITL_const_FORALL(typename map_type, elem_, addend)
- object.insert(*elem_);
-
- return object;
-}
-
-template <class DomainT, class CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
- erase(map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& erasure)
-{
- typedef map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> map_type;
-
- ITL_const_FORALL(typename map_type, elem_, erasure)
- object.erase(*elem_);
-
- return object;
-}
-
-template <class DomainT, class CodomainT, class Traits,
- ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
- erase(map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const set<DomainT,Compare,Alloc>& erasure)
-{
- typedef set<DomainT,Compare,Alloc> operand_type;
-
- ITL_const_FORALL(typename operand_type, elem_, erasure)
- object.erase(*elem_);
-
- return object;
-}
-
-
-//-----------------------------------------------------------------------------
-// non member functions
-//-----------------------------------------------------------------------------
-
-
-//==========================================================================
-//= Containedness
-//==========================================================================
-//JODO general container concept
-/** All content of the container is dropped.
- Complexity: linear. */
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-void clear(itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object) //JODO test
-{
- //object.clear();
- object.erase(object.begin(), object.end());
-}
-
-/** Tests if the container is empty.
- Complexity: constant. */
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-bool is_empty(const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object)
-{
- //return object.empty();
- return object.begin() == object.end();
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline bool
-contains(const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& super,
- const DomainT& key)
-{
- return !(super.find(key) == super.end());
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline bool
-contains( const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& super,
- const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::element_type& key_value_pair)
-{
- const_iterator found_ = super.find(key_value_pair.first);
- return found_ != super.end() && found_->second == key_value_pair.second;
-}
-
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline bool
-contains(const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& super,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& sub)
-{
- return Map::within(sub, super);
-}
-
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline bool
-within(const DomainT& key,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& super)
-{
- return !(super.find(key) == super.end());
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline bool
-within(const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::element_type& key_value_pair,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& super )
-{
- const_iterator found_ = super.find(key_value_pair.first);
- return found_ != super.end() && found_->second == key_value_pair.second;
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline bool
-within(const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& sub,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& super)
-{
- return Map::within(sub, super);
-}
-
-
-//==============================================================================
-//= Equivalences and Orderings
-//==============================================================================
-
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4996) //'std::equal': Function call with parameters that may be unsafe - this call relies on the caller to check that the passed values are correct. To disable this warning, use -D_SCL_SECURE_NO_WARNINGS. See documentation on how to use Visual C++ 'Checked Iterators'
-#endif // I do guarantee here that I am using the parameters correctly :)
-
-/** Standard equality, which is lexicographical equality of the sets
- as sequences, that are given by their Compare order. */
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline bool operator == (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
-{
- return lhs.size() == rhs.size()
- && equal(lhs.begin(), lhs.end(), rhs.begin());
-}
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline bool operator != (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
-{ return !(lhs == rhs); }
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline bool is_element_equal(const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
-{ return lhs == rhs; }
-
-/** Protonic equality is equality on all elements that do not carry a neutron as content. */
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline bool is_protonic_equal (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
-{
- return Map::lexicographical_protonic_equal(lhs, rhs);
-}
-
-/** Strict weak less ordering which is given by the Compare order */
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline bool operator < (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
-{
- return std::lexicographical_compare(
- lhs.begin(), lhs.end(), rhs.begin(), rhs.end(),
- Compare<std::pair<DomainT,CodomainT> >()
- );
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline bool operator > (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
-{ return rhs < lhs; }
-
-/** Partial ordering which is induced by Compare */
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline bool operator <= (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
-{ return !(lhs > rhs); }
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline bool operator >= (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& lhs,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& rhs)
-{ return !(lhs < rhs); }
-
-//------------------------------------------------------------------------------
-//==============================================================================
-//= Addition
-//==============================================================================
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
-operator += ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::element_type& operand)
-{ return object.add(operand); }
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator + ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object,
- const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::element_type& operand)
-{
- return object += operand;
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator + (const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::element_type& operand,
- itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object )
-{
- return object += operand;
-}
-
-/** Add a map \c operand to map \c object. If an element of \c operand already exists
- in \c object, add up the contents. */
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
-operator += ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
-{
- return Set::add(object, operand);
-}
-
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator + ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
-{
- return object += operand;
-}
-
-
-//--------------------------------------------------------------------------
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
-operator |= ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::value_type& operand)
-{ return object.add(operand); }
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator | ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object,
- const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::value_type& operand)
-{
- return object |= operand;
-}
-
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator | (const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::element_type& operand,
- itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object )
-{
- return object |= operand;
-}
-
-/** Add a map \c operand to map \c object. If an element of \c operand already exists
- in \c object, add up the contents. */
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
-operator |= ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
-{
- return Set::add(object, operand);
-}
-
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator | ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
-{
- return object |= operand;
-}
-
-
-//==============================================================================
-//= Subtraction
-//==============================================================================
-
-/** Subtract a map \c x2 from this map. If an element of \c x2 already exists
- in \c *this, subtract the contents using <tt>operator -=</tt>. */
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
-operator -= ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
-{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- ITL_const_FORALL(typename ObjectT, it_, operand)
- object.subtract(*it_);
-
- return object;
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator - ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
-{
- return object -= operand;
-}
-
-/** Subtract a set \c x2 from this map. Every element of \c this map that
- has a key that is element of \c x2 is deleted from the map. */
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
-operator -= ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::set_type& operand)
-{
- return Set::erase(object, operand);
-}
-
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator - ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::set_type& operand)
-{
- return object -= operand;
-}
-
-
-//==============================================================================
-//= Intersection
-//==============================================================================
-
-/** Intersect map \c x2 and \c *this.
- So \c *this becomes the intersection of \c *this and \c x2 */
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
-operator &= ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
-{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object_type;
- if(Traits::is_total)
- return object += operand;
- else
- {
- object_type section;
- object.add_intersection(section, operand);
- object.swap(section);
- return object;
- }
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator & ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
-{
- return object &= operand;
-}
-
-/** Intersect set \c x2 and \c *this.
- So \c *this becomes the intersection of \c *this and \c x2 */
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
-operator &= ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::set_type& operand)
-{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object_type;
- object_type section;
- object.add_intersection(section, operand);
- object.swap(section);
- return object;
-}
-
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator & (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object,
- const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::set_type& operand)
-{
- return object &= operand;
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator & (const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::set_type& operand,
- itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object )
-{
- return object &= operand;
-}
-
-//------------------------------------------------------------------------------
-//- intersects
-//------------------------------------------------------------------------------
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-bool intersects(const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::domain_type& key)
-{
- return object.intersects(key);
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-bool intersects(
- const typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::domain_type& key,
- const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object)
-{
- return object.intersects(key);
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-bool intersects(const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::element_type& key_value_pair)
-{
- return object.intersects(key_value_pair);
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-bool intersects(
- const typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::element_type& key_value_pair,
- const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object)
-{
- return object.intersects(key_value_pair);
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-bool intersects(const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& left,
- const typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::set_type& right)
-{
- typedef map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> MapT;
- if(is_total<MapT>::value)
- return true;
-
- if(left.iterative_size() < right.iterative_size())
- return Map::key_intersects(right, left);
- else
- return Map::key_intersects(left, right);
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-bool intersects(
- const typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::set_type& left,
- const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& right)
-{
- typedef map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> MapT;
- if(is_total<MapT>::value)
- return true;
-
- if(left.iterative_size() < right.iterative_size())
- return Map::key_intersects(right, left);
- else
- return Map::key_intersects(left, right);
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-bool intersects(const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& left,
- const map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& right)
-{
- typedef map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> MapT;
- if(is_total<MapT>::value)
- return true;
-
- if(left.iterative_size() < right.iterative_size())
- return Map::intersects(right, left);
- else
- return Map::intersects(left, right);
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc,
- class LeftT, class RightT>
-enable_if<mpl::or_<is_same< typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>, LeftT >,
- is_same< typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>, RightT>
- >, bool>
-is_disjoint(const LeftT& left, const RightT& right)
-{
- return !intersects(left, right);
-}
-
-
-
-//==============================================================================
-//= Symmetric difference
-//==============================================================================
-
-/** Symmetric subtract map \c x2 and \c *this.
- So \c *this becomes the symmetric difference of \c *this and \c x2 */
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>&
-operator ^= ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
-{
- Map::flip(object, operand);
- return object;
-}
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator ^ ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
-{
- return object ^= operand;
-}
-
-
-//---------------------------------------------------------------------------------
-template<class CharType, class CharTraits,
- class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-std::basic_ostream<CharType, CharTraits>& operator <<
- (std::basic_ostream<CharType, CharTraits>& stream,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object)
-{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- stream << "{";
- ITL_const_FORALL(typename ObjectT, it, object)
- stream << "(" << it->first << "->" << it->second << ")";
-
- return stream << "}";
-}
//-----------------------------------------------------------------------------
// type traits
@@ -1315,7 +427,7 @@
struct is_set<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
{
typedef is_set<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
- BOOST_STATIC_CONSTANT(bool, value = true);
+ BOOST_STATIC_CONSTANT(bool, value = (is_set<CodomainT>::value));
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
@@ -1333,20 +445,6 @@
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-struct is_interval_container<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
-{
- typedef is_interval_container<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> > type;
- BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-struct is_interval_splitter<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
-{
- typedef is_interval_splitter type;
- BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
struct absorbs_neutrons<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
{
typedef absorbs_neutrons type;
@@ -1360,16 +458,6 @@
BOOST_STATIC_CONSTANT(int, value = Traits::is_total);
};
-template<class MapT, class Combiner>
-struct adds_inversely
-{
- typedef adds_inversely type;
- BOOST_STATIC_CONSTANT(bool,
- value = (mpl::and_< has_inverse<typename MapT::codomain_type>
- , is_negative<Combiner>
- >::value));
-};
-
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
struct type_to_string<itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> >
{
@@ -1381,9 +469,7 @@
}
};
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
+
}} // namespace itl boost
Added: sandbox/itl/boost/itl/map_functions.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl/map_functions.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -0,0 +1,714 @@
+/*-----------------------------------------------------------------------------+
+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_MAP_FUNCTIONS_HPP_JOFA_100824
+#define BOOST_ITL_MAP_FUNCTIONS_HPP_JOFA_100824
+
+#include <boost/itl/detail/design_config.hpp>
+#include <boost/itl/detail/map_algo.hpp>
+#include <boost/itl/detail/map_functors.hpp>
+
+namespace boost{namespace itl
+{
+
+//==============================================================================
+//= Containedness
+//==============================================================================
+
+/** All content of the container is dropped.
+ Complexity: linear. */
+template<class MapT>
+typename enable_if<is_element_map<MapT>, void>::type
+clear(MapT& object)
+{
+ seqs<MapT>::erase(object, seqs<MapT>::begin(object), seqs<MapT>::end(object));
+}
+
+/** Tests if the container is empty.
+ Complexity: constant. */
+template<class MapT>
+typename enable_if<is_element_map<MapT>, bool>::type
+is_empty(const MapT& object)
+{
+ return seqs<MapT>::begin(object) == seqs<MapT>::end(object);
+}
+
+/** Checks if a key is in the map */
+template<class MapT>
+typename enable_if<is_element_map<MapT>, bool>::type
+contains(const MapT& object, const typename MapT::domain_type& key)
+{
+ return !(seqs<MapT>::find(object,key) == seqs<MapT>::end(object));
+}
+
+/** Checks if a key-value pair is in the map */
+template<class MapT>
+typename enable_if<is_element_map<MapT>, bool>::type
+contains(const MapT& object, const typename MapT::element_type& key_value_pair)
+{
+ typedef typename MapT::const_iterator const_iterator;
+ const_iterator found_ = seqs<MapT>::find(object, key_value_pair.first);
+ return found_ != seqs<MapT>::end(object) && found_->second == key_value_pair.second;
+}
+
+/** Does <tt>super</tt> contain <tt>sub</tt>? */
+template<class MapT>
+typename enable_if<is_element_map<MapT>, bool>::type
+contains(const MapT& super, const MapT& sub)
+{ return map_within<MapT>::apply(sub, super); }
+
+/** Does <tt>super</tt> contain <tt>sub</tt>? */
+template<class MapT>
+typename enable_if<is_element_map<MapT>, bool>::type
+contains(const MapT& super, const typename MapT::set_type& sub)
+{ return map_within<MapT>::apply(sub, super); }
+
+//- within ---------------------------------------------------------------------
+
+/** Is <tt>sub</tt> contained within <tt>super</tt>? */
+template<class MapT>
+typename enable_if<is_element_map<MapT>, bool>::type
+within(const typename MapT::domain_type& sub, const MapT& super)
+{ return contains(super, sub); }
+
+/** Is <tt>sub</tt> contained within <tt>super</tt>? */
+template<class MapT>
+typename enable_if<is_element_map<MapT>, bool>::type
+within(const typename MapT::element_type& sub, const MapT& super)
+{ return contains(super, sub); }
+
+/** Is <tt>sub</tt> contained within <tt>super</tt>? */
+template<class MapT>
+typename enable_if<is_element_map<MapT>, bool>::type
+within(const typename MapT::set_type& sub, const MapT& super)
+{ return map_within<MapT>::apply(sub, super); }
+
+/** Is <tt>sub</tt> contained within <tt>super</tt>? */
+template<class MapT>
+typename enable_if<is_element_map<MapT>, bool>::type
+within(const MapT& sub, const MapT& super)
+{ return map_within<MapT>::apply(sub, super); }
+
+//==============================================================================
+//= Size
+//==============================================================================
+template<class MapT>
+typename enable_if<is_element_map<MapT>, typename MapT::size_type>::type
+size(const MapT& object)
+{
+ return seqs<MapT>::size(object);
+}
+
+template<class MapT>
+typename enable_if<is_element_map<MapT>, typename MapT::size_type>::type
+cardinality(const MapT& object)
+{
+ return seqs<MapT>::size(object);
+}
+
+template<class MapT>
+typename enable_if<is_element_map<MapT>, typename MapT::size_type>::type
+iterative_size(const MapT& object)
+{
+ return seqs<MapT>::size(object);
+}
+
+
+
+//==============================================================================
+//= Equivalences and Orderings
+//==============================================================================
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4996) //'std::equal': Function call with parameters that may be unsafe - this call relies on the caller to check that the passed values are correct. To disable this warning, use -D_SCL_SECURE_NO_WARNINGS. See documentation on how to use Visual C++ 'Checked Iterators'
+#endif // I do guarantee here that I am using the parameters correctly :)
+
+/** Standard equality, which is lexicographical equality of the sets
+ as sequences, that are given by their Compare order. */
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, bool>::type
+operator == (const MapT& lhs, const MapT& rhs)
+{
+ return seqs<MapT>::size(lhs) == seqs<MapT>::size(rhs)
+ && equal(seqs<MapT>::begin(lhs), seqs<MapT>::end(lhs), seqs<MapT>::begin(rhs));
+}
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, bool>::type
+operator != (const MapT& lhs, const MapT& rhs)
+{ return !(lhs == rhs); }
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, bool>::type
+is_element_equal(const MapT& lhs, const MapT& rhs)
+{ return lhs == rhs; }
+
+/** Protonic equality is equality on all elements that do not carry a neutron as content. */
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, bool>::type
+is_protonic_equal(const MapT& lhs, const MapT& rhs)
+{
+ return Map::lexicographical_protonic_equal(lhs, rhs);
+}
+
+/** Strict weak less ordering which is given by the Compare order */
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, bool>::type
+operator < (const MapT& lhs, const MapT& rhs)
+{
+ return std::lexicographical_compare(
+ seqs<MapT>::begin(lhs), seqs<MapT>::end(lhs),
+ seqs<MapT>::begin(rhs), seqs<MapT>::end(rhs),
+ typename MapT::element_compare()
+ //lhs.value_comp() //JODO why does this implementation violate antisymmetry?
+ );
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, bool>::type
+operator > (const MapT& lhs, const MapT& rhs)
+{ return rhs < lhs; }
+
+/** Partial ordering which is induced by Compare */
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, bool>::type
+operator <= (const MapT& lhs, const MapT& rhs)
+{ return !(lhs > rhs); }
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, bool>::type
+operator >= (const MapT& lhs, const MapT& rhs)
+{ return !(lhs < rhs); }
+
+//------------------------------------------------------------------------------
+
+
+//==============================================================================
+//= Addition
+//==============================================================================
+/** \c add inserts \c value_pair into the map if it's key does
+ not exist in the map.
+ If \c value_pairs's key value exists in the map, it's data
+ value is added to the data value already found in the map. */
+template <class MapT>
+typename enable_if<is_element_map<MapT>, MapT>::type&
+add(MapT& object, const typename MapT::value_type& value_pair)
+{
+ return MapT::add_::apply(object, value_pair);
+}
+
+/** \c add add \c value_pair into the map using \c prior as a hint to
+ insert \c value_pair after the position \c prior is pointing to. */
+template <class MapT>
+typename enable_if<is_element_map<MapT>, typename MapT::iterator>::type
+add(MapT& object, typename MapT::iterator prior,
+ const typename MapT::value_type& value_pair)
+{
+ return MapT::add_::apply(object, prior, value_pair);
+}
+
+template <class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+operator += (MapT& object, const typename MapT::element_type& value_pair)
+{
+ return itl::add(object, value_pair);
+}
+
+template <class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type
+operator + (MapT object, const typename MapT::element_type& value_pair)
+{
+ return object += value_pair;
+}
+
+template <class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type
+operator + (const typename MapT::element_type& value_pair, MapT object)
+{
+ return object += value_pair;
+}
+
+template <class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+operator += (MapT& object, const MapT& addend)
+{
+ return Set::add(object, addend);
+}
+
+template <class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type
+operator + (MapT object, const MapT& addend)
+{
+ return object += addend;
+}
+
+//==============================================================================
+
+template <class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+operator |= (MapT& object, const typename MapT::element_type& value_pair)
+{
+ return itl::add(object, value_pair);
+}
+
+template <class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type
+operator | (MapT object, const typename MapT::element_type& value_pair)
+{
+ return object += value_pair;
+}
+
+template <class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type
+operator | (const typename MapT::element_type& value_pair, MapT object)
+{
+ return object += value_pair;
+}
+
+template <class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+operator |= (MapT& object, const MapT& addend)
+{
+ return Set::add(object, addend);
+}
+
+template <class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type
+operator | (MapT object, const MapT& addend)
+{
+ return object += addend;
+}
+
+
+
+
+//==============================================================================
+//= Subtraction
+//==============================================================================
+/** If the \c value_pair's key value is in the map, it's data value is
+ subtraced from the data value stored in the map. */
+template <class MapT>
+typename enable_if<is_element_map<MapT>, MapT>::type&
+subtract(MapT& object, const typename MapT::element_type& value_pair)
+{
+ return MapT::subtract_::apply(object, value_pair);
+}
+
+template <class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+operator -= (MapT& object, const typename MapT::element_type& value_pair)
+{
+ return itl::subtract(object, value_pair);
+}
+
+template <class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type
+operator - (MapT object, const typename MapT::element_type& value_pair)
+{
+ return object -= value_pair;
+}
+
+template <class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+operator -= (MapT& object, const MapT& subtrahend)
+{
+ ITL_const_FORALL(typename MapT, it_, subtrahend)
+ itl::subtract(object, *it_);
+
+ return object;
+}
+
+template <class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type
+operator - (MapT object, const MapT& subtrahend)
+{
+ return object -= subtrahend;
+}
+
+template <class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+operator -= (MapT& object, const typename MapT::set_type& subtrahend)
+{
+ return Set::erase(object, subtrahend);
+}
+
+template <class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type
+operator - (MapT object, const typename MapT::set_type& subtrahend)
+{
+ return object -= subtrahend;
+}
+
+
+
+//==============================================================================
+//= Insertion
+//==============================================================================
+
+template<class MapT>
+typename enable_if<is_element_map<MapT>,
+ std::pair<typename MapT::iterator,bool> >::type
+insert(MapT& object, const typename MapT::element_type& value_pair)
+{
+ typedef typename MapT::insert_ map_insert;
+ return map_insert::apply(object, value_pair);
+}
+
+template<class MapT>
+typename enable_if<is_element_map<MapT>,
+ typename MapT::iterator>::type
+insert(MapT& object, typename MapT::iterator prior, const typename MapT::element_type& value_pair)
+{
+ return MapT::insert_::apply(object, prior, value_pair);
+}
+
+template<class MapT>
+typename enable_if<is_element_map<MapT>, MapT>::type&
+insert(MapT& object, const MapT& addend)
+{
+ typedef typename MapT::iterator iterator;
+
+ iterator prior_ = seqs<MapT>::end(object);
+ ITL_const_FORALL(typename MapT, elem_, addend)
+ itl::insert(object, prior_, *elem_);
+
+ return object;
+}
+
+//==============================================================================
+//= Erasure
+//==============================================================================
+
+template<class MapT>
+typename enable_if<is_element_map<MapT>, typename MapT::size_type>::type
+erase(MapT& object, const typename MapT::domain_type& key_value)
+{
+ return MapT::erase_::apply(object, key_value);
+}
+
+template<class MapT>
+typename enable_if<is_element_map<MapT>, typename MapT::size_type>::type
+erase(MapT& object, const typename MapT::element_type& value_pair)
+{
+ return MapT::erase_::apply(object, value_pair);
+}
+
+template<class MapT>
+typename enable_if<is_element_map<MapT>, MapT>::type&
+erase(MapT& object, const typename MapT::set_type& erasure)
+{
+ typedef typename MapT::set_type set_type;
+ ITL_const_FORALL(typename set_type, elem_, erasure)
+ itl::erase(object, *elem_);
+
+ return object;
+}
+
+template<class MapT>
+typename enable_if<is_element_map<MapT>, MapT>::type&
+erase(MapT& object, const MapT& erasure)
+{
+ ITL_const_FORALL(typename MapT, elem_, erasure)
+ itl::erase(object, *elem_);
+
+ return object;
+}
+
+
+
+//==============================================================================
+//= Intersection
+//==============================================================================
+
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+add_intersection(MapT& section, const MapT& object, const typename MapT::domain_type& key_value)
+{
+ return MapT::add_intersection_::apply(section, object, key_value);
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+add_intersection(MapT& section, const MapT& object, const typename MapT::element_type& value_pair)
+{
+ return MapT::add_intersection_::apply(section, object, value_pair);
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+add_intersection(MapT& section, const MapT& object, const typename MapT::set_type& key_set)
+{
+ typedef typename MapT::set_type set_type;
+ typedef typename set_type::const_iterator const_iterator;
+
+ const_iterator common_lwb_;
+ const_iterator common_upb_;
+ if(!Set::common_range(common_lwb_, common_upb_, key_set, object))
+ return section;
+
+ const_iterator sec_ = common_lwb_;
+ while(sec_ != common_upb_)
+ itl::add_intersection(section, object, *sec_++);
+
+ return section;
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+add_intersection(MapT& section, const MapT& object, const MapT& operand)
+{
+ return MapT::add_intersection_::apply(section, object, operand);
+}
+
+
+/** Intersect map \c x2 and \c *this.
+ So \c *this becomes the intersection of \c *this and \c x2 */
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+operator &= (MapT& object, const MapT& operand)
+{
+ return MapT::inplace_intersect_::apply(object, operand);
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type
+operator & (MapT object, const MapT& operand)
+{
+ return object &= operand;
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+operator &= (MapT& object, const typename MapT::element_type& operand) //JODO codereplica.
+{
+ return MapT::inplace_intersect_::apply(object, operand);
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type
+operator & (MapT object, const typename MapT::element_type& value_pair)
+{
+ return object &= value_pair;
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type
+operator & (const typename MapT::element_type& value_pair, MapT object)
+{
+ return object &= value_pair;
+}
+
+
+/** Intersect set \c x2 and \c *this.
+ So \c *this becomes the intersection of \c *this and \c x2 */
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+operator &= (MapT& object, const typename MapT::set_type& operand)
+{
+ MapT section;
+ add_intersection(section, object, operand);
+ seqs<MapT>::swap(object, section);
+ return object;
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type
+operator & (MapT object, const typename MapT::set_type& key_set)
+{
+ return object &= key_set; //JODO test a - (a & s) == a - s
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type
+operator & (const typename MapT::set_type& key_set, MapT object)
+{
+ return object &= key_set; //JODO test a - (s & a) == a - s
+}
+
+
+//------------------------------------------------------------------------------
+//- intersects
+//------------------------------------------------------------------------------
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, bool>::type
+intersects(const MapT& object, const typename MapT::domain_type& operand)
+{
+ return MapT::intersects_::apply(object, operand);
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, bool>::type
+intersects(const typename MapT::domain_type& operand, const MapT& object)
+{
+ return MapT::intersects_::apply(object, operand);
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, bool>::type
+intersects(const MapT& object, const typename MapT::element_type& operand)
+{
+ return MapT::intersects_::apply(object, operand);
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, bool>::type
+intersects(const typename MapT::element_type& operand, const MapT& object)
+{
+ return MapT::intersects_::apply(object, operand);
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, bool>::type
+intersects(const MapT& object, const typename MapT::set_type& operand)
+{
+ return MapT::intersects_::apply(object, operand);
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, bool>::type
+intersects(const typename MapT::set_type& operand, const MapT& object)
+{
+ return MapT::intersects_::apply(object, operand);
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, bool>::type
+intersects(const MapT& object, const MapT& operand)
+{
+ return MapT::intersects_::apply(object, operand);
+}
+
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, bool>::type
+disjoint(const MapT& left, const MapT& right)//JODO All variants via meta predicate.
+{
+ return !intersects(left, right);
+}
+
+
+
+//==============================================================================
+//= Symmetric difference
+//==============================================================================
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+operator ^= (MapT& object, const typename MapT::element_tpye& operand)
+{
+ return MapT::flip_::apply(object, operand);
+}
+
+
+/** Symmetric subtract map \c x2 and \c *this.
+ So \c *this becomes the symmetric difference of \c *this and \c x2 */
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+operator ^= (MapT& object, const MapT& operand)
+{
+ return MapT::flip_::apply(object, operand);
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type
+operator ^ (MapT object, const MapT& operand)
+{
+ return object ^= operand;
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type
+operator ^ (MapT object, const typename MapT::element_type& value_pair)
+{
+ MapT operand;//JODO
+ seqs<MapT>::insert(operand, value_pair);
+ return object ^= operand;
+}
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type
+operator ^ (const typename MapT::element_type& value_pair, MapT object)
+{
+ MapT operand;//JODO
+ seqs<MapT>::insert(operand, value_pair);
+ return object ^= operand;
+}
+
+//==============================================================================
+//= Manipulation by predicates
+//==============================================================================
+
+template<class MapT, class Predicate>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+erase_if(const Predicate& pred, MapT& object)
+{
+ typename MapT::iterator it_ = seqs<MapT>::begin(object);
+ while(it_ != seqs<MapT>::end(object))
+ if(pred(*it_))
+ itl::erase(object, it_++);
+ else ++it_;
+ return object;
+}
+
+
+template<class MapT, class Predicate>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+add_if(const Predicate& pred, MapT& object, const MapT& src)
+{
+ typename MapT::const_iterator it_ = seqs<MapT>::begin(src);
+ while(it_ != seqs<MapT>::end(src))
+ if(pred(*it_))
+ itl::add(object, *it_++);
+
+ return object;
+}
+
+template<class MapT, class Predicate>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+assign_if(const Predicate& pred, MapT& object, const MapT& src)
+{
+ itl::clear(object);
+ return add_if(object, src, pred);
+}
+
+//==============================================================================
+//= Neutron absorbtion
+//==============================================================================
+
+template<class MapT>
+inline typename enable_if<is_element_map<MapT>, MapT>::type&
+absorb_neutrons(MapT& object)
+{
+ return map_absorb_neutrons<MapT,absorbs_neutrons<MapT>::value>::apply(object);
+}
+
+
+
+//---------------------------------------------------------------------------------
+template<class CharType, class CharTraits, class MapT>
+inline typename enable_if<is_element_map<MapT>, std::basic_ostream<CharType, CharTraits> >::type&
+operator << (std::basic_ostream<CharType, CharTraits>& stream, const MapT& object)
+{
+ stream << "{";
+ ITL_const_FORALL(typename MapT, it, object)
+ stream << "(" << it->first << "->" << it->second << ")";
+
+ return stream << "}";
+}
+
+
+}} // namespace itl boost
+
+#endif // BOOST_ITL_MAP_FUNCTIONS_HPP_JOFA_100824
+
Modified: sandbox/itl/boost/itl/rightopen_interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/rightopen_interval.hpp (original)
+++ sandbox/itl/boost/itl/rightopen_interval.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -91,7 +91,7 @@
}
//==============================================================================
-//= Concept interval: Adaption via trais class
+//=T rightopen_interval -> concept intervals
//==============================================================================
template<class DomainT, ITL_COMPARE Compare>
struct intervals< itl::rightopen_interval<DomainT, Compare> >
Added: sandbox/itl/boost/itl/seqs.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/itl/seqs.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -0,0 +1,66 @@
+/*-----------------------------------------------------------------------------+
+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)
++-----------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------------
+itl_rational provides adapter code for boost::rational.
+------------------------------------------------------------------------------*/
+
+#ifndef BOOST_ITL_SEQS_HPP_JOFA_100824
+#define BOOST_ITL_SEQS_HPP_JOFA_100824
+
+
+namespace boost{namespace itl
+{
+
+template<class SeqT>
+struct seqs
+{
+ typedef SeqT seq_type;
+ typedef typename seq_type::domain_type domain_type;
+ typedef typename seq_type::codomain_type codomain_type;
+ typedef typename seq_type::element_type element_type;
+ typedef typename seq_type::size_type size_type;
+ typedef typename seq_type::iterator iterator;
+ typedef typename seq_type::const_iterator const_iterator;
+
+ static const_iterator begin(const seq_type&);
+ static iterator begin( seq_type&);
+ static const_iterator end (const seq_type&);
+ static iterator end ( seq_type&);
+ static size_type size (const seq_type&);
+ static const_iterator find (const seq_type&, const domain_type&);
+ static iterator find ( seq_type&, const domain_type&);
+
+ static std::pair<iterator,bool> insert(seq_type&, const element_type&);
+ static iterator insert(seq_type&, iterator, const element_type&);
+ static void erase (seq_type&, iterator);
+ static void erase (seq_type&, iterator, iterator);
+
+ static void swap(seq_type&, seq_type&);
+
+ //--------------------------------------------------------------------------
+ template<typename IteratorT>
+ static const domain_type& key_value(IteratorT value_);
+
+ template<typename IteratorT>
+ static const codomain_type& co_value(IteratorT value_);
+
+ template<typename LeftIterT, typename RightIterT>
+ static bool key_less(LeftIterT lhs_, RightIterT rhs_);
+
+ static element_type make_value(const domain_type& key_value, const codomain_type& data_value);
+
+};
+
+
+}} // namespace itl boost
+
+
+#endif
+
+
Modified: sandbox/itl/boost/itl/set.hpp
==============================================================================
--- sandbox/itl/boost/itl/set.hpp (original)
+++ sandbox/itl/boost/itl/set.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -231,10 +231,10 @@
template<typename IteratorT>
static const key_type& key_value(IteratorT value_){ return (*value_); }
- /** \c data_value allows for a uniform access to \c data_values which is
+ /** \c codomain_value allows for a uniform access to \c data_values which is
is used for common algorithms on sets and maps. */
template<typename IteratorT>
- static const data_type& data_value(IteratorT value_){ return (*value_); }
+ static const codomain_type& codomain_value(IteratorT value_){ return (*value_); }
/** \c key_less allows for a uniform notation of key comparison which
is used for common algorithms on sets and maps. */
@@ -244,8 +244,8 @@
/** \c make_element allows for a uniform notation of key comparison which
is used for common algorithms on sets and maps. */
- static value_type make_element(const key_type& key_val, const data_type&)
- { return key_val; }
+ static value_type make_value(const key_type& key_value, const codomain_type&)
+ { return key_value; }
};
@@ -449,7 +449,36 @@
const itl::set<DomainT,Compare,Alloc>& rhs)
{ return !(lhs < rhs); }
-//--------------------------------------------------------------------------
+//==============================================================================
+//= Size
+//==============================================================================
+
+template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
+typename set<DomainT,Compare,Alloc>::size_type
+size(const itl::set<DomainT,Compare,Alloc>& object)
+{
+ return object.size();
+}
+
+template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
+typename set<DomainT,Compare,Alloc>::size_type
+cardinality(const itl::set<DomainT,Compare,Alloc>& object)
+{
+ return object.size();
+}
+
+template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
+typename set<DomainT,Compare,Alloc>::size_type
+iterative_size(const itl::set<DomainT,Compare,Alloc>& object)
+{
+ return object.size();
+}
+
+
+
+//==============================================================================
+//= Addition
+//==============================================================================
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
inline itl::set<DomainT,Compare,Alloc>&
@@ -697,6 +726,25 @@
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
+std::pair<typename set<DomainT,Compare,Alloc>::iterator, bool>
+ add( set<DomainT,Compare,Alloc>& object,
+ const DomainT& operand)
+{ return object.insert(operand); }
+
+template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
+typename set<DomainT,Compare,Alloc>::iterator
+ add( set<DomainT,Compare,Alloc>& object,
+ typename set<DomainT,Compare,Alloc>::iterator prior,
+ const DomainT& operand)
+{ return object.insert(prior, operand); }
+
+template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
+std::pair<typename set<DomainT,Compare,Alloc>::iterator, bool>
+ insert( set<DomainT,Compare,Alloc>& object,
+ const DomainT& operand)
+{ return object.insert(operand); }
+
+template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
set<DomainT,Compare,Alloc>&
insert( set<DomainT,Compare,Alloc>& object,
const set<DomainT,Compare,Alloc>& operand)
Modified: sandbox/itl/boost/itl/split_interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_map.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_map.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -178,7 +178,7 @@
return;
std::pair<iterator,bool> insertion
- = this->template map_insert<Combiner>(inter_val, co_val);
+ = this->template _map_insert<Combiner>(inter_val, co_val);
if(!insertion.second)
{
@@ -211,7 +211,7 @@
return prior_;
std::pair<iterator,bool> insertion
- = this->template map_add<Combiner>(prior_, inter_val, co_val);
+ = this->template _map_add<Combiner>(prior_, inter_val, co_val);
if(insertion.second)
return insertion.first;
@@ -352,7 +352,7 @@
//NOTE: This is NOT an insertion that has to take care for correct application of
// the Combiner functor. It only reestablished that state after splitting the
- // 'it_' interval value pair. Using map_insert<Combiner> does not work here.
+ // 'it_' interval value pair. Using _map_insert<Combiner> does not work here.
iterator insertion_ = this->_map.insert(it_, value_type(right_resid, it_->second));
Combiner()(it_->second, co_val);
@@ -502,7 +502,7 @@
return prior_;
std::pair<iterator,bool> insertion
- = this->template map_insert<codomain_combine>(prior_, inter_val, co_val);
+ = this->template _map_insert<codomain_combine>(prior_, inter_val, co_val);
if(insertion.second)
return insertion.first;
@@ -647,7 +647,7 @@
struct is_set<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> >
{
typedef is_set<itl::split_interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> > type;
- BOOST_STATIC_CONSTANT(bool, value = true);
+ BOOST_STATIC_CONSTANT(bool, value = (is_set<CodomainT>::value));
};
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
Modified: sandbox/itl/boost/itl/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-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -15,6 +15,7 @@
#include <boost/mpl/not.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/itl/type_traits/is_concept_equivalent.hpp>
+#include <boost/itl/type_traits/is_interval_container.hpp>
namespace boost{namespace itl
{
Modified: sandbox/itl/boost/itl/type_traits/is_discrete.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_discrete.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_discrete.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -5,23 +5,20 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef BOOST_ITL_TYPE_TRAITS_IS_DISCRETE_HPP_JOFA_080910
-#define BOOST_ITL_TYPE_TRAITS_IS_DISCRETE_HPP_JOFA_080910
+#ifndef BOOST_ITL_TYPE_TRAITS_IS_DISCRETE_HPP_JOFA_100410
+#define BOOST_ITL_TYPE_TRAITS_IS_DISCRETE_HPP_JOFA_100410
#include <string>
#include <boost/type_traits/is_integral.hpp>
namespace boost{ namespace itl
{
- template <class Type> struct is_discrete;
-
- template<class Type> struct is_discrete
+ template <class Type> struct is_discrete
{
- typedef is_discrete<Type> type;
+ typedef is_discrete type;
BOOST_STATIC_CONSTANT(bool, value = is_integral<Type>::value);
};
-
}} // namespace boost itl
#endif
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-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -157,7 +157,7 @@
std::cout << "------------------------------------------------------------------------------" << std::endl;
// Summary for the current cycle
- double avg_evaluation_time_per_law = avg_evaluation_time/_frequencies.size();
+ 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(_frequencies.size() < 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-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -71,7 +71,8 @@
{
ITL_FUN_CALL(clear, collected);
ITL_const_FORALL(typename SourceT, item_, items)
- collected.add(*item_);
+ //JODO itl::add(collected, *item_);
+ collected.add(*item_);
}
};
@@ -86,6 +87,7 @@
ITL_FUN_CALL(clear, collected);
typename TargetT::iterator prior_ = collected.end();
ITL_const_FORALL(typename SourceT, item_, items)
+ //JODO prior_ = add(collected, prior_, *item_);
prior_ = collected.add(prior_, *item_);
}
};
Modified: sandbox/itl/libs/itl/example/boost_party_/boost_party.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/boost_party_/boost_party.cpp (original)
+++ sandbox/itl/libs/itl/example/boost_party_/boost_party.cpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -56,7 +56,7 @@
// Prior to other includes for interval containers we define ...
#define ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS
// ... so all interval containers will use rightopen_intervals that
-// has static interval borders.
+// have static interval borders.
#include <boost/itl/interval_map.hpp>
Modified: sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp (original)
+++ sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -20,7 +20,7 @@
// Prior to other includes for interval containers we define ...
#define ITL_USE_STATIC_INTERVAL_BORDER_DEFAULTS
// ... so all interval containers will use rightopen_intervals that
-// has static interval borders.
+// have static interval borders.
#include <boost/itl/interval_bounds.hpp> //JODO static bounded intervals should be independend of interval_bounds
Modified: sandbox/itl/libs/itl/example/man_power_/man_power.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/man_power_/man_power.cpp (original)
+++ sandbox/itl/libs/itl/example/man_power_/man_power.cpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -44,12 +44,12 @@
interval_set<date> weekends;
date cur_weekend_sat
- = scope.first()
- + days(days_until_weekday(scope.first(), greg_weekday(Saturday)))
+ = first(scope)
+ + days(days_until_weekday(first(scope), greg_weekday(Saturday)))
- weeks(1);
week_iterator week_iter(cur_weekend_sat);
- for(; week_iter <= scope.last(); ++week_iter)
+ for(; week_iter <= last(scope); ++week_iter)
weekends += discrete_interval<date>::rightopen(*week_iter, *week_iter + days(2));
weekends &= scope; // cut off the surplus
@@ -144,14 +144,14 @@
manpower += bodos_working_hours;
- cout << scope.first() << " - " << scope.last()
+ cout << first(scope) << " - " << last(scope)
<< " available man-power:" << endl;
cout << "---------------------------------------------------------------\n";
for(interval_map<date,int>::iterator it = manpower.begin();
it != manpower.end(); it++)
{
- cout << it->first.first() << " - " << it->first.last()
+ cout << first(it->first) << " - " << last(it->first)
<< " -> " << it->second << endl;
}
}
Modified: sandbox/itl/libs/itl/example/month_and_week_grid_/month_and_week_grid.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/month_and_week_grid_/month_and_week_grid.cpp (original)
+++ sandbox/itl/libs/itl/example/month_and_week_grid_/month_and_week_grid.cpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -45,15 +45,15 @@
// This function splits a gregorian::date interval 'scope' into a month grid:
// For every month contained in 'scope' that month is contained as interval
// in the resulting split_interval_set.
-date_grid month_grid(const interval<date>& scope)
+date_grid month_grid(const discrete_interval<date>& scope)
{
split_interval_set<date> month_grid;
- date frame_months_1st = scope.first().end_of_month() + days(1) - months(1);
+ date frame_months_1st = first(scope).end_of_month() + days(1) - months(1);
month_iterator month_iter(frame_months_1st);
- for(; month_iter <= scope.last(); ++month_iter)
- month_grid += interval<date>::rightopen(*month_iter, *month_iter + months(1));
+ for(; month_iter <= last(scope); ++month_iter)
+ month_grid += discrete_interval<date>::rightopen(*month_iter, *month_iter + months(1));
month_grid &= scope; // cut off the surplus
@@ -63,15 +63,15 @@
// This function splits a gregorian::date interval 'scope' into a week grid:
// For every week contained in 'scope' that month is contained as interval
// in the resulting split_interval_set.
-date_grid week_grid(const interval<date>& scope)
+date_grid week_grid(const discrete_interval<date>& scope)
{
split_interval_set<date> week_grid;
- date frame_weeks_1st = scope.first() + days(days_until_weekday(scope.first(), greg_weekday(Monday))) - weeks(1);
+ date frame_weeks_1st = first(scope) + days(days_until_weekday(first(scope), greg_weekday(Monday))) - weeks(1);
week_iterator week_iter(frame_weeks_1st);
- for(; week_iter <= scope.last(); ++week_iter)
- week_grid.insert(interval<date>::rightopen(*week_iter, *week_iter + weeks(1)));
+ for(; week_iter <= last(scope); ++week_iter)
+ week_grid.insert(discrete_interval<date>::rightopen(*week_iter, *week_iter + weeks(1)));
week_grid &= scope; // cut off the surplus
@@ -86,27 +86,27 @@
date someday = day_clock::local_day();
date thenday = someday + months(2);
- interval<date> itv = interval<date>::rightopen(someday, thenday);
+ discrete_interval<date> itv = discrete_interval<date>::rightopen(someday, thenday);
// Compute a month grid
date_grid month_and_week_grid = month_grid(itv);
// Intersection of the month and week grids:
month_and_week_grid &= week_grid(itv);
- cout << "interval : " << itv.first() << " - " << itv.last()
+ cout << "interval : " << first(itv) << " - " << last(itv)
<< " month and week partitions:" << endl;
cout << "---------------------------------------------------------------\n";
for(date_grid::iterator it = month_and_week_grid.begin();
it != month_and_week_grid.end(); it++)
{
- if(it->first().day() == 1)
+ if(first(*it).day() == 1)
cout << "new month: ";
- else if(it->first().day_of_week()==greg_weekday(Monday))
+ else if(first(*it).day_of_week()==greg_weekday(Monday))
cout << "new week : " ;
else if(it == month_and_week_grid.begin())
cout << "first day: " ;
- cout << it->first() << " - " << it->last() << endl;
+ cout << first(*it) << " - " << last(*it) << endl;
}
}
Modified: sandbox/itl/libs/itl/example/overlap_counter_/overlap_counter.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/overlap_counter_/overlap_counter.cpp (original)
+++ sandbox/itl/libs/itl/example/overlap_counter_/overlap_counter.cpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -20,9 +20,9 @@
aggregation is summation of an integer. A interval_map<int,int> maps
intervals of int to ints.
- If we insert a value pair (interval<int>(2,6), 1) into the interval_map, it
+ If we insert a value pair (discrete_interval<int>(2,6), 1) into the interval_map, it
increases the content of all value pairs in the map by 1, if their interval
- part overlaps with interval<int>(2,6).
+ part overlaps with discrete_interval<int>(2,6).
\include overlap_counter_/overlap_counter.cpp
*/
@@ -45,7 +45,7 @@
{
for(OverlapCounterT::const_iterator it = counter.begin(); it != counter.end(); it++)
{
- interval<int> itv = (*it).first;
+ discrete_interval<int> itv = (*it).first;
int overlaps_count = (*it).second;
if(overlaps_count == 1)
cout << "in interval " << itv << " intervals do not overlap" << endl;
@@ -57,21 +57,21 @@
void overlap_counter()
{
OverlapCounterT overlap_counter;
- interval<int> inter_val;
+ discrete_interval<int> inter_val;
- inter_val = interval<int>::rightopen(4,8);
+ inter_val = discrete_interval<int>::rightopen(4,8);
cout << "-- adding " << inter_val << " -----------------------------------------" << endl;
overlap_counter += make_pair(inter_val, 1);
print_overlaps(overlap_counter);
cout << "-----------------------------------------------------------" << endl;
- inter_val = interval<int>::rightopen(6,9);
+ inter_val = discrete_interval<int>::rightopen(6,9);
cout << "-- adding " << inter_val << " -----------------------------------------" << endl;
overlap_counter += make_pair(inter_val, 1);
print_overlaps(overlap_counter);
cout << "-----------------------------------------------------------" << endl;
- inter_val = interval<int>::rightopen(1,9);
+ inter_val = discrete_interval<int>::rightopen(1,9);
cout << "-- adding " << inter_val << " -----------------------------------------" << endl;
overlap_counter += make_pair(inter_val, 1);
print_overlaps(overlap_counter);
Modified: sandbox/itl/libs/itl/example/party_/party.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/party_/party.cpp (original)
+++ sandbox/itl/libs/itl/example/party_/party.cpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -57,7 +57,7 @@
typedef boost::itl::set<string> GuestSetT;
// Time is the domain type the split_interval_map. It's key values are therefore
-// time intervals: interval<Time>. The content is the set of names: GuestSetT.
+// time intervals. The content is the set of names: GuestSetT.
void party()
@@ -75,14 +75,14 @@
interval_map<Time, GuestSetT> party;
- party += make_pair( interval<Time>::rightopen(Time(19,30), Time(23,00)), mary_harry);
- party += make_pair( interval<Time>::rightopen(Time(20,10), Time(monday,0,0)), diana_susan);
- party += make_pair( interval<Time>::rightopen(Time(22,15), Time(monday,0,30)), peter);
+ party += make_pair( discrete_interval<Time>::rightopen(Time(19,30), Time(23,00)), mary_harry);
+ party += make_pair( discrete_interval<Time>::rightopen(Time(20,10), Time(monday,0,0)), diana_susan);
+ party += make_pair( discrete_interval<Time>::rightopen(Time(22,15), Time(monday,0,30)), peter);
interval_map<Time, GuestSetT>::iterator it = party.begin();
while(it != party.end())
{
- interval<Time> when = it->first;
+ discrete_interval<Time> when = it->first;
// Who is at the party within the time interval 'when' ?
GuestSetT who = (*it++).second;
cout << when << ": " << who << endl;
Modified: sandbox/itl/libs/itl/example/partys_height_average_/partys_height_average.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/partys_height_average_/partys_height_average.cpp (original)
+++ sandbox/itl/libs/itl/example/partys_height_average_/partys_height_average.cpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -65,35 +65,35 @@
height_sums +=
make_pair(
- interval<ptime>::rightopen(
+ discrete_interval<ptime>::rightopen(
time_from_string("2008-05-20 19:30"),
time_from_string("2008-05-20 23:00")),
counted_sum(165)); // Mary is 1,65 m tall.
height_sums +=
make_pair(
- interval<ptime>::rightopen(
+ discrete_interval<ptime>::rightopen(
time_from_string("2008-05-20 19:30"),
time_from_string("2008-05-20 23:00")),
counted_sum(180)); // Harry is 1,80 m tall.
height_sums +=
make_pair(
- interval<ptime>::rightopen(
+ discrete_interval<ptime>::rightopen(
time_from_string("2008-05-20 20:10"),
time_from_string("2008-05-21 00:00")),
counted_sum(170)); // Diana is 1,70 m tall.
height_sums +=
make_pair(
- interval<ptime>::rightopen(
+ discrete_interval<ptime>::rightopen(
time_from_string("2008-05-20 20:10"),
time_from_string("2008-05-21 00:00")),
counted_sum(165)); // Susan is 1,65 m tall.
height_sums +=
make_pair(
- interval<ptime>::rightopen(
+ discrete_interval<ptime>::rightopen(
time_from_string("2008-05-20 22:15"),
time_from_string("2008-05-21 00:30")),
counted_sum(200)); // Peters height is 2,00 m
@@ -102,11 +102,11 @@
cout << "-------------- History of average guest height -------------------\n";
while(height_sum_ != height_sums.end())
{
- interval<ptime> when = height_sum_->first;
+ discrete_interval<ptime> when = height_sum_->first;
double height_average = (*height_sum_++).second.average();
cout << setprecision(3)
- << "[" << when.first() << " - " << when.upper() << ")"
+ << "[" << first(when) << " - " << upper(when) << ")"
<< ": " << height_average <<" cm = " << height_average/30.48 << " ft" << endl;
}
}
Modified: sandbox/itl/libs/itl/example/partys_tallest_guests_/partys_tallest_guests.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/partys_tallest_guests_/partys_tallest_guests.cpp (original)
+++ sandbox/itl/libs/itl/example/partys_tallest_guests_/partys_tallest_guests.cpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -57,21 +57,21 @@
tallest_guest +=
make_pair(
- interval<ptime>::rightopen(
+ discrete_interval<ptime>::rightopen(
time_from_string("2008-05-20 19:30"),
time_from_string("2008-05-20 23:00")),
180); // Mary & Harry: Harry is 1,80 m tall.
tallest_guest +=
make_pair(
- interval<ptime>::rightopen(
+ discrete_interval<ptime>::rightopen(
time_from_string("2008-05-20 20:10"),
time_from_string("2008-05-21 00:00")),
170); // Diana & Susan: Diana is 1,70 m tall.
tallest_guest +=
make_pair(
- interval<ptime>::rightopen(
+ discrete_interval<ptime>::rightopen(
time_from_string("2008-05-20 22:15"),
time_from_string("2008-05-21 00:30")),
200); // Peters height is 2,00 m
@@ -80,10 +80,10 @@
cout << "-------------- History of maximum guest height -------------------\n";
while(height_ != tallest_guest.end())
{
- interval<ptime> when = height_->first;
+ discrete_interval<ptime> when = height_->first;
// Of what height are the tallest guests within the time interval 'when' ?
int height = (*height_++).second;
- cout << "[" << when.first() << " - " << when.upper() << ")"
+ cout << "[" << first(when) << " - " << upper(when) << ")"
<< ": " << height <<" cm = " << height/30.48 << " ft" << endl;
}
@@ -98,21 +98,21 @@
// like e.g. min, max etc. in their 'inplace' or op= incarnation
tallest_guest +=
make_pair(
- interval<ptime>::rightopen(
+ discrete_interval<ptime>::rightopen(
time_from_string("2008-05-20 19:30"),
time_from_string("2008-05-20 23:00")),
180); // Mary & Harry: Harry is 1,80 m tall.
tallest_guest +=
make_pair(
- interval<ptime>::rightopen(
+ discrete_interval<ptime>::rightopen(
time_from_string("2008-05-20 20:10"),
time_from_string("2008-05-21 00:00")),
170); // Diana & Susan: Diana is 1,70 m tall.
tallest_guest +=
make_pair(
- interval<ptime>::rightopen(
+ discrete_interval<ptime>::rightopen(
time_from_string("2008-05-20 22:15"),
time_from_string("2008-05-21 00:30")),
200); // Peters height is 2,00 m
@@ -123,10 +123,10 @@
cout << "--- Same map as above but split for every interval insertion. ---\n";
while(height_ != tallest_guest.end())
{
- interval<ptime> when = height_->first;
+ discrete_interval<ptime> when = height_->first;
// Of what height are the tallest guests within the time interval 'when' ?
int height = (*height_++).second;
- cout << "[" << when.first() << " - " << when.upper() << ")"
+ cout << "[" << first(when) << " - " << upper(when) << ")"
<< ": " << height <<" cm = " << height/30.48 << " ft" << endl;
}
Modified: sandbox/itl/libs/itl/example/std_copy_/std_copy.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/std_copy_/std_copy.cpp (original)
+++ sandbox/itl/libs/itl/example/std_copy_/std_copy.cpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -32,19 +32,19 @@
// 'make_segments' returns a vector of interval value pairs, which
// are not sorted. The values are taken from the minimal example
// in section 'interval combining styles'.
-vector<pair<interval<int>, int> > make_segments()
+vector<pair<discrete_interval<int>, int> > make_segments()
{
- vector<pair<interval<int>, int> > segment_vec;
- segment_vec.push_back(make_pair(interval<int>::rightopen(2,4), 1));
- segment_vec.push_back(make_pair(interval<int>::rightopen(4,5), 1));
- segment_vec.push_back(make_pair(interval<int>::rightopen(1,3), 1));
+ vector<pair<discrete_interval<int>, int> > segment_vec;
+ segment_vec.push_back(make_pair(discrete_interval<int>::rightopen(2,4), 1));
+ segment_vec.push_back(make_pair(discrete_interval<int>::rightopen(4,5), 1));
+ segment_vec.push_back(make_pair(discrete_interval<int>::rightopen(1,3), 1));
return segment_vec;
}
// 'show_segments' displays the source segements.
-void show_segments(const vector<pair<interval<int>, int> >& segments)
+void show_segments(const vector<pair<discrete_interval<int>, int> >& segments)
{
- vector<pair<interval<int>, int> >::const_iterator iter = segments.begin();
+ vector<pair<discrete_interval<int>, int> >::const_iterator iter = segments.begin();
while(iter != segments.end())
{
cout << "(" << iter->first << "," << iter->second << ")";
@@ -55,7 +55,7 @@
void std_copy()
{
// So we have some segments stored in an std container.
- vector<pair<interval<int>, int> > segments = make_segments();
+ vector<pair<discrete_interval<int>, int> > segments = make_segments();
// Display the input
cout << "input sequence: "; show_segments(segments); cout << "\n\n";
Modified: sandbox/itl/libs/itl/example/std_transform_/std_transform.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/std_transform_/std_transform.cpp (original)
+++ sandbox/itl/libs/itl/example/std_transform_/std_transform.cpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -51,17 +51,17 @@
// interval maps with MyObject data we need a function
// 'to_segment' that maps an object of type MyObject into
// the value type to the interval map we want to tranform to ...
-pair<interval<int>, int> to_segment(const MyObject& myObj)
+pair<discrete_interval<int>, int> to_segment(const MyObject& myObj)
{
- return std::pair< interval<int>, int >
- (interval<int>::closed(myObj.from(), myObj.to()), myObj.value());
+ return std::pair< discrete_interval<int>, int >
+ (discrete_interval<int>::closed(myObj.from(), myObj.to()), myObj.value());
}
// ... there may be another function that returns the interval
// of an object only
-interval<int> to_interval(const MyObject& myObj)
+discrete_interval<int> to_interval(const MyObject& myObj)
{
- return interval<int>::closed(myObj.from(), myObj.to());
+ return discrete_interval<int>::closed(myObj.from(), myObj.to());
}
Modified: sandbox/itl/libs/itl/example/user_groups_/user_groups.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/user_groups_/user_groups.cpp (original)
+++ sandbox/itl/libs/itl/example/user_groups_/user_groups.cpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -47,7 +47,7 @@
typedef boost::itl::set<string> MemberSetT;
// boost::gregorian::date is the domain type the interval map.
-// It's key values are therefore time intervals: interval<date>. The content
+// It's key values are therefore time intervals: discrete_interval<date>. The content
// is the set of names: MemberSetT.
typedef interval_map<date, MemberSetT> MembershipT;
@@ -74,18 +74,18 @@
med_users.add( // add and element
make_pair(
- interval<date>::closed(
+ discrete_interval<date>::closed(
from_string("2008-01-01"), from_string("2008-12-31")), mary_harry));
med_users += // element addition can also be done via operator +=
make_pair(
- interval<date>::closed(
+ discrete_interval<date>::closed(
from_string("2008-01-15"), from_string("2008-12-31")),
chief_physician);
med_users +=
make_pair(
- interval<date>::closed(
+ discrete_interval<date>::closed(
from_string("2008-02-01"), from_string("2008-10-15")),
director_of_admin);
@@ -94,18 +94,18 @@
admin_users += // element addition can also be done via operator +=
make_pair(
- interval<date>::closed(
+ discrete_interval<date>::closed(
from_string("2008-03-20"), from_string("2008-09-30")), diana_susan);
admin_users +=
make_pair(
- interval<date>::closed(
+ discrete_interval<date>::closed(
from_string("2008-01-15"), from_string("2008-12-31")),
chief_physician);
admin_users +=
make_pair(
- interval<date>::closed(
+ discrete_interval<date>::closed(
from_string("2008-02-01"), from_string("2008-10-15")),
director_of_admin);
@@ -117,10 +117,10 @@
cout << "----- Membership of medical staff -----------------------------------\n";
while(med_ != med_users.end())
{
- interval<date> when = (*med_).first;
+ discrete_interval<date> when = (*med_).first;
// Who is member of group med_users within the time interval 'when' ?
MemberSetT who = (*med_++).second;
- cout << "[" << when.first() << " - " << when.last() << "]"
+ cout << "[" << first(when) << " - " << last(when) << "]"
<< ": " << who << endl;
}
@@ -128,10 +128,10 @@
cout << "----- Membership of admin staff -------------------------------------\n";
while(admin_ != admin_users.end())
{
- interval<date> when = (*admin_).first;
+ discrete_interval<date> when = (*admin_).first;
// Who is member of group admin_users within the time interval 'when' ?
MemberSetT who = (*admin_++).second;
- cout << "[" << when.first() << " - " << when.last() << "]"
+ cout << "[" << first(when) << " - " << last(when) << "]"
<< ": " << who << endl;
}
@@ -139,10 +139,10 @@
cout << "----- Membership of all users (med + admin) -------------------------\n";
while(all_ != all_users.end())
{
- interval<date> when = (*all_).first;
+ discrete_interval<date> when = (*all_).first;
// Who is member of group med_users OR admin_users ?
MemberSetT who = (*all_++).second;
- cout << "[" << when.first() << " - " << when.last() << "]"
+ cout << "[" << first(when) << " - " << last(when) << "]"
<< ": " << who << endl;
}
@@ -150,10 +150,10 @@
cout << "----- Membership of super users: intersection(med,admin) ------------\n";
while(super_ != super_users.end())
{
- interval<date> when = (*super_).first;
+ discrete_interval<date> when = (*super_).first;
// Who is member of group med_users AND admin_users ?
MemberSetT who = (*super_++).second;
- cout << "[" << when.first() << " - " << when.last() << "]"
+ cout << "[" << first(when) << " - " << last(when) << "]"
<< ": " << who << endl;
}
Modified: sandbox/itl/libs/itl/test/Jamfile.v2
==============================================================================
--- sandbox/itl/libs/itl/test/Jamfile.v2 (original)
+++ sandbox/itl/libs/itl/test/Jamfile.v2 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -17,7 +17,7 @@
test-suite "itl"
:
# interval
- [ run fastest_itl_interval_/fastest_itl_interval.cpp ]
+ #[ run fastest_itl_interval_/fastest_itl_interval.cpp ]
# sets
[ run fastest_interval_set_/fastest_interval_set.cpp ]
Modified: sandbox/itl/libs/itl/test/fastest_itl_map_/fastest_itl_map_cases.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_itl_map_/fastest_itl_map_cases.hpp (original)
+++ sandbox/itl/libs/itl/test/fastest_itl_map_/fastest_itl_map_cases.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -9,11 +9,18 @@
#define BOOST_ITL_TEST_ITL_MAP_CASES_HPP_JOFA_090701
BOOST_AUTO_TEST_CASE
+(fastest_itl_itl_map_contains_4_bicremental_types)
+{ itl_map_contains_4_bicremental_types<discrete_type_1, int, partial_absorber, INTERVAL_MAP>();}
+
+BOOST_AUTO_TEST_CASE
(fastest_itl_itl_map_find_4_bicremental_types)
{ itl_map_find_4_bicremental_types<discrete_type_1, int, partial_absorber, INTERVAL_MAP>();}
-BOOST_AUTO_TEST_CASE
-(fastest_itl_itl_map_inclusion_compare_4_bicremental_types)
-{ itl_map_inclusion_compare_4_bicremental_types<discrete_type_1, int, partial_absorber, INTERVAL_MAP>();}
+//CL or repair
+//BOOST_AUTO_TEST_CASE
+//(fastest_itl_itl_map_inclusion_compare_4_bicremental_types)
+//{ itl_map_inclusion_compare_4_bicremental_types<discrete_type_1, int, partial_absorber, INTERVAL_MAP>();}
+
+
#endif // BOOST_ITL_TEST_ITL_MAP_CASES_HPP_JOFA_090701
Modified: sandbox/itl/libs/itl/test/fastest_partial_interval_quantifier_/fastest_partial_interval_quantifier.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_partial_interval_quantifier_/fastest_partial_interval_quantifier.cpp (original)
+++ sandbox/itl/libs/itl/test/fastest_partial_interval_quantifier_/fastest_partial_interval_quantifier.cpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -18,6 +18,7 @@
#include <boost/itl/interval_map.hpp>
#include <boost/itl/split_interval_map.hpp>
+#include <boost/itl/detail/interval_morphism.hpp>
using namespace std;
using namespace boost;
Modified: sandbox/itl/libs/itl/test/fastest_partial_interval_quantifier_cases.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_partial_interval_quantifier_cases.hpp (original)
+++ sandbox/itl/libs/itl/test/fastest_partial_interval_quantifier_cases.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -5,60 +5,60 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef BOOST_ITL_FASTEST_PARTIAL_INTERVAL_QUANTIFIER_CASES_HPP_JOFA_090703
-#define BOOST_ITL_FASTEST_PARTIAL_INTERVAL_QUANTIFIER_CASES_HPP_JOFA_090703
+#ifndef BOOST_ICL_FASTEST_PARTIAL_ICL_QUANTIFIER_CASES_HPP_JOFA_100819
+#define BOOST_ICL_FASTEST_PARTIAL_ICL_QUANTIFIER_CASES_HPP_JOFA_100819
//------------------------------------------------------------------------------
// partial_absorber
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE
-(fastest_itl_partial_quantifier_map_check_monoid_plus_4_bicremental_types)
-{ quantifier_map_check_monoid_plus_4_bicremental_types<bicremental_type_1, std::string, partial_absorber, INTERVAL_MAP>();}
+(fastest_itl_partial_itv_quantifier_check_monoid_plus_4_bicremental_types)
+{ itv_quantifier_check_monoid_plus_4_bicremental_types<bicremental_type_1, std::string, partial_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE
-(fastest_itl_partial_quantifier_map_check_monoid_et_4_bicremental_types)
-{ quantifier_map_check_monoid_et_4_bicremental_types<bicremental_type_2, int, partial_absorber, INTERVAL_MAP>();}
+(fastest_itl_partial_itv_quantifier_check_monoid_et_4_bicremental_types)
+{ itv_quantifier_check_monoid_et_4_bicremental_types<bicremental_type_2, int, partial_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE
-(fastest_itl_partial_quantifier_map_check_abelian_monoid_plus_4_bicremental_types)
-{ quantifier_map_check_abelian_monoid_plus_4_bicremental_types<bicremental_type_3, std::string, partial_absorber, INTERVAL_MAP>();}
+(fastest_itl_partial_itv_quantifier_check_abelian_monoid_plus_4_bicremental_types)
+{ itv_quantifier_check_abelian_monoid_plus_4_bicremental_types<bicremental_type_3, std::string, partial_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE
-(fastest_itl_partial_quantifier_map_check_abelian_monoid_et_4_bicremental_types)
-{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<bicremental_type_4, int, partial_absorber, INTERVAL_MAP>();}
+(fastest_itl_partial_itv_quantifier_check_abelian_monoid_et_4_bicremental_types)
+{ itv_quantifier_check_abelian_monoid_et_4_bicremental_types<bicremental_type_4, int, partial_absorber, INTERVAL_MAP>();}
// x - x = 0 | partial absorber
BOOST_AUTO_TEST_CASE
-(fastest_itl_partial_quantifier_map_check_partial_invertive_monoid_plus_4_bicremental_types)
-{ quantifier_map_check_partial_invertive_monoid_plus_4_bicremental_types<bicremental_type_5, int, partial_absorber, INTERVAL_MAP>();}
+(fastest_itl_partial_itv_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types)
+{ itv_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types<bicremental_type_5, int, partial_absorber, INTERVAL_MAP>();}
//------------------------------------------------------------------------------
// partial_enricher
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE
-(fastest_itl_partial_enricher_quantifier_map_check_monoid_plus_4_bicremental_types)
-{ quantifier_map_check_monoid_plus_4_bicremental_types<bicremental_type_6, std::string, partial_enricher, INTERVAL_MAP>();}
+(fastest_itl_partial_enricher_itv_quantifier_check_monoid_plus_4_bicremental_types)
+{ itv_quantifier_check_monoid_plus_4_bicremental_types<bicremental_type_6, std::string, partial_enricher, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE
-(fastest_itl_partial_enricher_quantifier_map_check_monoid_et_4_bicremental_types)
-{ quantifier_map_check_monoid_et_4_bicremental_types<bicremental_type_7, int, partial_enricher, INTERVAL_MAP>();}
+(fastest_itl_partial_enricher_itv_quantifier_check_monoid_et_4_bicremental_types)
+{ itv_quantifier_check_monoid_et_4_bicremental_types<bicremental_type_7, int, partial_enricher, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE
-(fastest_itl_partial_enricher_quantifier_map_check_abelian_monoid_plus_4_bicremental_types)
-{ quantifier_map_check_abelian_monoid_plus_4_bicremental_types<bicremental_type_8, std::string, partial_enricher, INTERVAL_MAP>();}
+(fastest_itl_partial_enricher_itv_quantifier_check_abelian_monoid_plus_4_bicremental_types)
+{ itv_quantifier_check_abelian_monoid_plus_4_bicremental_types<bicremental_type_8, std::string, partial_enricher, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE
-(fastest_itl_partial_enricher_quantifier_map_check_abelian_monoid_et_4_bicremental_types)
-{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<bicremental_type_1, int, partial_enricher, INTERVAL_MAP>();}
+(fastest_itl_partial_enricher_itv_quantifier_check_abelian_monoid_et_4_bicremental_types)
+{ itv_quantifier_check_abelian_monoid_et_4_bicremental_types<bicremental_type_1, int, partial_enricher, INTERVAL_MAP>();}
// x - x =p= 0 | partial enricher
BOOST_AUTO_TEST_CASE
-(fastest_itl_partial_enricher_quantifier_map_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types)
-{ quantifier_map_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types<bicremental_type_2, int, partial_enricher, INTERVAL_MAP>();}
+(fastest_itl_partial_enricher_itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types)
+{ itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types<bicremental_type_2, int, partial_enricher, INTERVAL_MAP>();}
// absorber enricher
// partial x - x == 0 x - x =p= 0 partiality of subtraction
// total (-x)+ x == 0 (-x)+ x =p= 0 totality of subtraction
-#endif // BOOST_ITL_FASTEST_PARTIAL_INTERVAL_QUANTIFIER_CASES_HPP_JOFA_090703
+#endif // BOOST_ICL_FASTEST_PARTIAL_ICL_QUANTIFIER_CASES_HPP_JOFA_100819
Modified: sandbox/itl/libs/itl/test/fastest_total_interval_quantifier_cases.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/fastest_total_interval_quantifier_cases.hpp (original)
+++ sandbox/itl/libs/itl/test/fastest_total_interval_quantifier_cases.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -12,65 +12,65 @@
// total_absorber
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE
-(fastest_itl_total_quantifier_map_check_monoid_plus_4_bicremental_types)
-{ quantifier_map_check_monoid_plus_4_bicremental_types<bicremental_type_1, std::string, total_absorber, INTERVAL_MAP>();}
+(fastest_itl_total_itv_quantifier_check_monoid_plus_4_bicremental_types)
+{ itv_quantifier_check_monoid_plus_4_bicremental_types<bicremental_type_1, std::string, total_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE
-(fastest_itl_total_quantifier_map_check_monoid_et_4_bicremental_types)
-{ quantifier_map_check_monoid_et_4_bicremental_types<bicremental_type_2, int, total_absorber, INTERVAL_MAP>();}
+(fastest_itl_total_itv_quantifier_check_monoid_et_4_bicremental_types)
+{ itv_quantifier_check_monoid_et_4_bicremental_types<bicremental_type_2, int, total_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE
-(fastest_itl_total_quantifier_map_check_abelian_monoid_plus_4_bicremental_types)
-{ quantifier_map_check_abelian_monoid_plus_4_bicremental_types<bicremental_type_3, std::string, total_absorber, INTERVAL_MAP>();}
+(fastest_itl_total_itv_quantifier_check_abelian_monoid_plus_4_bicremental_types)
+{ itv_quantifier_check_abelian_monoid_plus_4_bicremental_types<bicremental_type_3, std::string, total_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE
-(fastest_itl_total_quantifier_map_check_abelian_monoid_et_4_bicremental_types)
-{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<bicremental_type_4, float, total_absorber, INTERVAL_MAP>();}
+(fastest_itl_total_itv_quantifier_check_abelian_monoid_et_4_bicremental_types)
+{ itv_quantifier_check_abelian_monoid_et_4_bicremental_types<bicremental_type_4, float, total_absorber, INTERVAL_MAP>();}
// (0-x) + x = 0 | total absorber
BOOST_AUTO_TEST_CASE
-(fastest_itl_total_quantifier_map_check_abelian_group_plus_4_bicremental_domain_and_discrete_codomain)
-{ quantifier_map_check_abelian_group_plus_4_bicremental_types<bicremental_type_5, int, total_absorber, INTERVAL_MAP>();}
+(fastest_itl_total_itv_quantifier_check_abelian_group_plus_4_bicremental_domain_and_discrete_codomain)
+{ itv_quantifier_check_abelian_group_plus_4_bicremental_types<bicremental_type_5, int, total_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE
-(fastest_itl_total_quantifier_map_check_abelian_group_plus_4_bicremental_domain_and_continuous_codomain_1)
-{ quantifier_map_check_abelian_group_plus_4_bicremental_types<bicremental_type_5, double, total_absorber, INTERVAL_MAP>();}
+(fastest_itl_total_itv_quantifier_check_abelian_group_plus_4_bicremental_domain_and_continuous_codomain_1)
+{ itv_quantifier_check_abelian_group_plus_4_bicremental_types<bicremental_type_5, double, total_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE
-(fastest_itl_total_quantifier_map_check_abelian_group_plus_4_bicremental_domain_and_continuous_codomain_2)
-{ quantifier_map_check_abelian_group_plus_4_bicremental_types<bicremental_type_5, boost::rational<int>, total_absorber, INTERVAL_MAP>();}
+(fastest_itl_total_itv_quantifier_check_abelian_group_plus_4_bicremental_domain_and_continuous_codomain_2)
+{ itv_quantifier_check_abelian_group_plus_4_bicremental_types<bicremental_type_5, boost::rational<int>, total_absorber, INTERVAL_MAP>();}
//------------------------------------------------------------------------------
// total_enricher
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE
-(fastest_itl_total_enricher_quantifier_map_check_monoid_plus_4_bicremental_types)
-{ quantifier_map_check_monoid_plus_4_bicremental_types<bicremental_type_6, std::string, total_enricher, INTERVAL_MAP>();}
+(fastest_itl_total_enricher_itv_quantifier_check_monoid_plus_4_bicremental_types)
+{ itv_quantifier_check_monoid_plus_4_bicremental_types<bicremental_type_6, std::string, total_enricher, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE
-(fastest_itl_total_enricher_quantifier_map_check_monoid_et_4_bicremental_types)
-{ quantifier_map_check_monoid_et_4_bicremental_types<bicremental_type_7, int, total_enricher, INTERVAL_MAP>();}
+(fastest_itl_total_enricher_itv_quantifier_check_monoid_et_4_bicremental_types)
+{ itv_quantifier_check_monoid_et_4_bicremental_types<bicremental_type_7, int, total_enricher, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE
-(fastest_itl_total_enricher_quantifier_map_check_abelian_monoid_plus_4_bicremental_types)
-{ quantifier_map_check_abelian_monoid_plus_4_bicremental_types<bicremental_type_8, std::string, total_enricher, INTERVAL_MAP>();}
+(fastest_itl_total_enricher_itv_quantifier_check_abelian_monoid_plus_4_bicremental_types)
+{ itv_quantifier_check_abelian_monoid_plus_4_bicremental_types<bicremental_type_8, std::string, total_enricher, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE
-(fastest_itl_total_enricher_quantifier_map_check_abelian_monoid_et_4_bicremental_types)
-{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<bicremental_type_1, double, total_enricher, INTERVAL_MAP>();}
+(fastest_itl_total_enricher_itv_quantifier_check_abelian_monoid_et_4_bicremental_types)
+{ itv_quantifier_check_abelian_monoid_et_4_bicremental_types<bicremental_type_1, double, total_enricher, INTERVAL_MAP>();}
// (0-x) + x =p= 0 | total absorber
BOOST_AUTO_TEST_CASE
-(fastest_itl_total_enricher_quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_domain_discrete_codomain)
-{ quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types<bicremental_type_2, int, total_enricher, INTERVAL_MAP>();}
+(fastest_itl_total_enricher_itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_domain_discrete_codomain)
+{ itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types<bicremental_type_2, int, total_enricher, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE
-(fastest_itl_total_enricher_quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_domain_continuous_codomain_1)
-{ quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types<bicremental_type_3, float, total_enricher, INTERVAL_MAP>();}
+(fastest_itl_total_enricher_itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_domain_continuous_codomain_1)
+{ itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types<bicremental_type_3, float, total_enricher, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE
-(fastest_itl_total_enricher_quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_domain_continuous_codomain_2)
-{ quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types<bicremental_type_4, boost::rational<int>, total_enricher, INTERVAL_MAP>();}
+(fastest_itl_total_enricher_itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_domain_continuous_codomain_2)
+{ itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types<bicremental_type_4, boost::rational<int>, total_enricher, INTERVAL_MAP>();}
// absorber enricher
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-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -371,7 +371,7 @@
BOOST_CHECK_EQUAL( contains(join_map, I_D(0,7)), false );
// Map types
- BOOST_CHECK_EQUAL( contains(join_map, K_v(1,2)), true );
+ BOOST_CHECK_EQUAL( contains(join_map, K_v(1,2)), true );
BOOST_CHECK_EQUAL( contains(join_map, K_v(5,1)), true );
BOOST_CHECK_EQUAL( contains(join_map, K_v(9,2)), true );
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-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -5,8 +5,36 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef __test_itl_quantifier_map_shared_h_JOFA_090119__
-#define __test_itl_quantifier_map_shared_h_JOFA_090119__
+#ifndef __TEST_INTERVAL_QUANTIFIER_SHARED_H_JOFA_090119__
+#define __TEST_INTERVAL_QUANTIFIER_SHARED_H_JOFA_090119__
+
+
+template <class T, class U, class Trt,
+ template<class T, class U,
+ class Traits = Trt,
+ ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
+ ITL_ALLOC Alloc = std::allocator
+ >class IntervalMap
+ >
+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)
+{
+ typedef IntervalMap<T,U,Trt> IntervalMapT;
+
+ itv_map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
+ itv_map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
+ itv_map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
+
+ val_pair = IDv(6,9,1);
+ map_pair = K_v(5,1);
+}
//------------------------------------------------------------------------------
@@ -22,17 +50,13 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_monoid_plus_4_bicremental_types()
+void itv_quantifier_check_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
-
IntervalMapT map_a, map_b, map_c;
- map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
- mapping_pair<T,U> map_pair = K_v(5,1);
+ typename IntervalMapT::interval_mapping_type val_pair;
+ mapping_pair<T,U> map_pair;
+ make_3_itv_maps_and_derivatives_1(map_a, map_b, map_c, val_pair, map_pair);
CHECK_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
CHECK_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);
@@ -49,17 +73,13 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_monoid_et_4_bicremental_types()
+void itv_quantifier_check_monoid_et_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
-
IntervalMapT map_a, map_b, map_c;
- map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
- mapping_pair<T,U> map_pair = K_v(5,1);
+ typename IntervalMapT::interval_mapping_type val_pair;
+ mapping_pair<T,U> map_pair;
+ make_3_itv_maps_and_derivatives_1(map_a, map_b, map_c, val_pair, map_pair);
CHECK_MONOID_INSTANCE_WRT(et) (map_a, map_b, map_c, val_pair, map_pair);
CHECK_MONOID_INSTANCE_WRT(caret)(map_a, map_b, map_c, val_pair, map_pair);
@@ -79,17 +99,13 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_abelian_monoid_plus_4_bicremental_types()
+void itv_quantifier_check_abelian_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
-
IntervalMapT map_a, map_b, map_c;
- map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
- mapping_pair<T,U> map_pair = K_v(5,1);
+ typename IntervalMapT::interval_mapping_type val_pair;
+ mapping_pair<T,U> map_pair;
+ make_3_itv_maps_and_derivatives_1(map_a, map_b, map_c, val_pair, map_pair);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);
@@ -106,17 +122,13 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_abelian_monoid_et_4_bicremental_types()
+void itv_quantifier_check_abelian_monoid_et_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
-
IntervalMapT map_a, map_b, map_c;
- map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
- mapping_pair<T,U> map_pair = K_v(5,1);
+ typename IntervalMapT::interval_mapping_type val_pair;
+ mapping_pair<T,U> map_pair;
+ make_3_itv_maps_and_derivatives_1(map_a, map_b, map_c, val_pair, map_pair);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(et) (map_a, map_b, map_c, val_pair, map_pair);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(caret)(map_a, map_b, map_c, val_pair, map_pair);
@@ -136,17 +148,13 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_partial_invertive_monoid_plus_4_bicremental_types()
+void itv_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
-
IntervalMapT map_a, map_b, map_c;
- map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
- mapping_pair<T,U> map_pair = K_v(5,1);
+ typename IntervalMapT::interval_mapping_type val_pair;
+ mapping_pair<T,U> map_pair;
+ make_3_itv_maps_and_derivatives_1(map_a, map_b, map_c, val_pair, map_pair);
CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);
@@ -165,17 +173,13 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
+void itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
-
IntervalMapT map_a, map_b, map_c;
- map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
- mapping_pair<T,U> map_pair = K_v(5,1);
+ typename IntervalMapT::interval_mapping_type val_pair;
+ mapping_pair<T,U> map_pair;
+ make_3_itv_maps_and_derivatives_1(map_a, map_b, map_c, val_pair, map_pair);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus)(map_a, map_b, map_c, val_pair, map_pair);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe)(map_a, map_b, map_c, val_pair, map_pair);
@@ -198,17 +202,13 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_abelian_group_plus_4_bicremental_types()
+void itv_quantifier_check_abelian_group_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
-
IntervalMapT map_a, map_b, map_c;
- map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
- mapping_pair<T,U> map_pair = K_v(5,1);
+ typename IntervalMapT::interval_mapping_type val_pair;
+ mapping_pair<T,U> map_pair;
+ make_3_itv_maps_and_derivatives_1(map_a, map_b, map_c, val_pair, map_pair);
CHECK_ABELIAN_GROUP_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
CHECK_ABELIAN_GROUP_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);
@@ -227,20 +227,16 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types()
+void itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types()
{
// check abelian group wrt. + and inverability wrt. protonic equality =p= :
// (1) (IntervalMapT, +) is an abelian group and
// (2) The inverability law: (0 - x) + x =p= 0 holds.
typedef IntervalMap<T,U,Trt> IntervalMapT;
-
IntervalMapT map_a, map_b, map_c;
- map_a.add(IDv(3,6,1)).add(IIv(5,7,1));
- map_b.add(CDv(1,3,1)).add(IDv(8,9,1));
- map_c.add(IDv(0,9,2)).add(IIv(3,6,1)).add(IDv(5,7,1));
-
- typename IntervalMapT::interval_mapping_type val_pair = IDv(6,9,1);
- mapping_pair<T,U> map_pair = K_v(5,1);
+ typename IntervalMapT::interval_mapping_type val_pair;
+ mapping_pair<T,U> map_pair;
+ make_3_itv_maps_and_derivatives_1(map_a, map_b, map_c, val_pair, map_pair);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(plus) (map_a, map_b, map_c, val_pair, map_pair);
CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (map_a, map_b, map_c, val_pair, map_pair);
@@ -250,5 +246,5 @@
}
-#endif // __test_itl_quantifier_map_shared_h_JOFA_090119__
+#endif // __TEST_INTERVAL_QUANTIFIER_SHARED_H_JOFA_090119__
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-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -19,6 +19,43 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
+void itl_map_contains_4_bicremental_types()
+{
+ 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;
+
+ IntervalMapT itv_map_a;
+ itv_map_a.add(IDv(2,4,1)).add(IIv(6,7,3));
+
+ MapT map_a;
+ segmental::atomize(map_a, itv_map_a);
+
+ 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));
+ BOOST_CHECK( contains(map_a, key_value_pair) );
+ BOOST_CHECK( within(key_value_pair, map_a) );
+
+ //found = map_a.find(MK_v(5));
+
+ //BOOST_CHECK_EQUAL( found == map_a.end(), true );
+ //BOOST_CHECK_EQUAL( map_a(MK_v(5)), MK_u(0) );
+}
+
+
+template <class T, class U, class Trt,
+ template<class T, class U,
+ class Traits = Trt,
+ ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, U),
+ ITL_COMBINE Combine = ITL_COMBINE_INSTANCE(itl::inplace_plus, U),
+ ITL_SECTION Section = ITL_SECTION_INSTANCE(itl::inter_section, U),
+ ITL_INTERVAL(ITL_COMPARE) Interval = ITL_INTERVAL_INSTANCE(ITL_INTERVAL_DEFAULT, T, Compare),
+ ITL_ALLOC Alloc = std::allocator
+ >class IntervalMap
+ >
void itl_map_find_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
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-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -23,6 +23,12 @@
// Associativity
//------------------------------------------------------------------------------
+// The definition of a boost test via a macro, that allows to be instantiated for
+// different operator signs 'op_sign'. For every 'op_sign' a separate function
+// template is generated by appending the suffic 'op_tag' to the function
+// name.
+// So this is the function template via macro that checks the law
+// associativity for an operator 'op_sign'
#define DEFINE_ASSOCIATIVITY_CHECK_WRT(op_tag, op_sign) \
template<class Type, class TypeB, class TypeC> \
void check_associativity_wrt_##op_tag(const Type& a, const TypeB& b, const TypeC& c) \
@@ -43,9 +49,13 @@
BOOST_CHECK_EQUAL((*equal)(left,right), true); \
}
+// Here we define the call of the test function thats definition
+// template has been generated by the macro above.
#define CHECK_ASSOCIATIVITY_WRT(op_tag) check_associativity_wrt_##op_tag
#define CHECK_ASSOCIATIVITY_WRT_EQUAL(op_tag) check_associativity_wrt_equal_##op_tag
+// Here we actually generate function templates by calling the defining
+// macros.
DEFINE_ASSOCIATIVITY_CHECK_WRT (plus, + );
DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(plus, + );
DEFINE_ASSOCIATIVITY_CHECK_WRT (pipe, | );
@@ -214,6 +224,30 @@
DEFINE_INVERSE_CHECK_WRT_EQUAL(pipe, | );
//------------------------------------------------------------------------------
+// Containedness laws
+//------------------------------------------------------------------------------
+
+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);
+}
+
+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);
+}
+
+//==============================================================================
+// Law tests are now combined to test algebraic concepts.
+//------------------------------------------------------------------------------
// Monodid EAN
//------------------------------------------------------------------------------
Modified: sandbox/itl/libs/itl/test/test_partial_interval_quantifier_cases.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_partial_interval_quantifier_cases.hpp (original)
+++ sandbox/itl/libs/itl/test/test_partial_interval_quantifier_cases.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -12,49 +12,49 @@
// partial_absorber
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_partial_quantifier_map_check_monoid_plus_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_monoid_plus_4_bicremental_types<T, std::string, partial_absorber, INTERVAL_MAP>();}
+(test_itl_partial_itv_quantifier_check_monoid_plus_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_monoid_plus_4_bicremental_types<T, std::string, partial_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_partial_quantifier_map_check_monoid_et_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_monoid_et_4_bicremental_types<T, int, partial_absorber, INTERVAL_MAP>();}
+(test_itl_partial_itv_quantifier_check_monoid_et_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_monoid_et_4_bicremental_types<T, int, partial_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_partial_quantifier_map_check_abelian_monoid_plus_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_abelian_monoid_plus_4_bicremental_types<T, std::string, partial_absorber, INTERVAL_MAP>();}
+(test_itl_partial_itv_quantifier_check_abelian_monoid_plus_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_abelian_monoid_plus_4_bicremental_types<T, std::string, partial_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_partial_quantifier_map_check_abelian_monoid_et_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<T, int, partial_absorber, INTERVAL_MAP>();}
+(test_itl_partial_itv_quantifier_check_abelian_monoid_et_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_abelian_monoid_et_4_bicremental_types<T, int, partial_absorber, INTERVAL_MAP>();}
// x - x = 0 | partial absorber
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_partial_quantifier_map_check_partial_invertive_monoid_plus_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_partial_invertive_monoid_plus_4_bicremental_types<T, int, partial_absorber, INTERVAL_MAP>();}
+(test_itl_partial_itv_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types<T, int, partial_absorber, INTERVAL_MAP>();}
//------------------------------------------------------------------------------
// partial_enricher
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_partial_enricher_quantifier_map_check_monoid_plus_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_monoid_plus_4_bicremental_types<T, std::string, partial_enricher, INTERVAL_MAP>();}
+(test_itl_partial_enricher_itv_quantifier_check_monoid_plus_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_monoid_plus_4_bicremental_types<T, std::string, partial_enricher, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_partial_enricher_quantifier_map_check_monoid_et_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_monoid_et_4_bicremental_types<T, int, partial_enricher, INTERVAL_MAP>();}
+(test_itl_partial_enricher_itv_quantifier_check_monoid_et_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_monoid_et_4_bicremental_types<T, int, partial_enricher, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_partial_enricher_quantifier_map_check_abelian_monoid_plus_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_abelian_monoid_plus_4_bicremental_types<T, std::string, partial_enricher, INTERVAL_MAP>();}
+(test_itl_partial_enricher_itv_quantifier_check_abelian_monoid_plus_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_abelian_monoid_plus_4_bicremental_types<T, std::string, partial_enricher, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_partial_enricher_quantifier_map_check_abelian_monoid_et_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<T, int, partial_enricher, INTERVAL_MAP>();}
+(test_itl_partial_enricher_itv_quantifier_check_abelian_monoid_et_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_abelian_monoid_et_4_bicremental_types<T, int, partial_enricher, INTERVAL_MAP>();}
// x - x =p= 0 | partial enricher
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_partial_enricher_quantifier_map_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types<T, int, partial_enricher, INTERVAL_MAP>();}
+(test_itl_partial_enricher_itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types<T, int, partial_enricher, INTERVAL_MAP>();}
// absorber enricher
// partial x - x == 0 x - x =p= 0 partiality of subtraction
Modified: sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp (original)
+++ sandbox/itl/libs/itl/test/test_quantifier_itl_map.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -22,7 +22,7 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_monoid_plus_4_bicremental_types()
+void itv_quantifier_check_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
typedef itl::map<T,U,Trt> MapT;
@@ -55,7 +55,7 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_monoid_et_4_bicremental_types()
+void itv_quantifier_check_monoid_et_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
typedef itl::map<T,U,Trt> MapT;
@@ -91,7 +91,7 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_abelian_monoid_plus_4_bicremental_types()
+void itv_quantifier_check_abelian_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
typedef itl::map<T,U,Trt> MapT;
@@ -124,7 +124,7 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_abelian_monoid_et_4_bicremental_types()
+void itv_quantifier_check_abelian_monoid_et_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
typedef itl::map<T,U,Trt> MapT;
@@ -160,7 +160,7 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_partial_invertive_monoid_plus_4_bicremental_types()
+void itv_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
typedef itl::map<T,U,Trt> MapT;
@@ -195,7 +195,7 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
+void itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
typedef itl::map<T,U,Trt> MapT;
@@ -234,7 +234,7 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_abelian_group_plus_4_bicremental_types()
+void itv_quantifier_check_abelian_group_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
typedef itl::map<T,U,Trt> MapT;
@@ -269,7 +269,7 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types()
+void itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
typedef itl::map<T,U,Trt> MapT;
Modified: sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_quantifier_map_shared.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -5,8 +5,8 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef __test_itl_quantifier_map_shared_h_JOFA_090119__
-#define __test_itl_quantifier_map_shared_h_JOFA_090119__
+#ifndef __test_itl_itv_quantifier_shared_h_JOFA_090119__
+#define __test_itl_itv_quantifier_shared_h_JOFA_090119__
//------------------------------------------------------------------------------
@@ -22,7 +22,7 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_monoid_plus_4_bicremental_types()
+void itv_quantifier_check_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -49,7 +49,7 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_monoid_et_4_bicremental_types()
+void itv_quantifier_check_monoid_et_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -79,7 +79,7 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_abelian_monoid_plus_4_bicremental_types()
+void itv_quantifier_check_abelian_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -106,7 +106,7 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_abelian_monoid_et_4_bicremental_types()
+void itv_quantifier_check_abelian_monoid_et_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -136,7 +136,7 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_partial_invertive_monoid_plus_4_bicremental_types()
+void itv_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -165,7 +165,7 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
+void itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -198,7 +198,7 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_abelian_group_plus_4_bicremental_types()
+void itv_quantifier_check_abelian_group_plus_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -227,7 +227,7 @@
ITL_ALLOC Alloc = std::allocator
>class IntervalMap
>
-void quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types()
+void itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -247,5 +247,5 @@
}
-#endif // __test_itl_quantifier_map_shared_h_JOFA_090119__
+#endif // __test_itl_itv_quantifier_shared_h_JOFA_090119__
Modified: sandbox/itl/libs/itl/test/test_total_interval_quantifier_cases.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_total_interval_quantifier_cases.hpp (original)
+++ sandbox/itl/libs/itl/test/test_total_interval_quantifier_cases.hpp 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -12,65 +12,65 @@
// total_absorber
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_total_quantifier_map_check_monoid_plus_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_monoid_plus_4_bicremental_types<T, std::string, total_absorber, INTERVAL_MAP>();}
+(test_itl_total_itv_quantifier_check_monoid_plus_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_monoid_plus_4_bicremental_types<T, std::string, total_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_total_quantifier_map_check_monoid_et_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_monoid_et_4_bicremental_types<T, double, total_absorber, INTERVAL_MAP>();}
+(test_itl_total_itv_quantifier_check_monoid_et_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_monoid_et_4_bicremental_types<T, double, total_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_total_quantifier_map_check_abelian_monoid_plus_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_abelian_monoid_plus_4_bicremental_types<T, std::string, total_absorber, INTERVAL_MAP>();}
+(test_itl_total_itv_quantifier_check_abelian_monoid_plus_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_abelian_monoid_plus_4_bicremental_types<T, std::string, total_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_total_quantifier_map_check_abelian_monoid_et_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<T, int, total_absorber, INTERVAL_MAP>();}
+(test_itl_total_itv_quantifier_check_abelian_monoid_et_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_abelian_monoid_et_4_bicremental_types<T, int, total_absorber, INTERVAL_MAP>();}
// (0-x) + x = 0 | total absorber
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_total_quantifier_map_check_abelian_group_plus_4_bicremental_domain_and_discrete_codomain, T, bicremental_types)
-{ quantifier_map_check_abelian_group_plus_4_bicremental_types<T, int, total_absorber, INTERVAL_MAP>();}
+(test_itl_total_itv_quantifier_check_abelian_group_plus_4_bicremental_domain_and_discrete_codomain, T, bicremental_types)
+{ itv_quantifier_check_abelian_group_plus_4_bicremental_types<T, int, total_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_total_quantifier_map_check_abelian_group_plus_4_bicremental_domain_and_continuous_codomain_1, T, bicremental_types)
-{ quantifier_map_check_abelian_group_plus_4_bicremental_types<T, float, total_absorber, INTERVAL_MAP>();}
+(test_itl_total_itv_quantifier_check_abelian_group_plus_4_bicremental_domain_and_continuous_codomain_1, T, bicremental_types)
+{ itv_quantifier_check_abelian_group_plus_4_bicremental_types<T, float, total_absorber, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_total_quantifier_map_check_abelian_group_plus_4_bicremental_domain_and_continuous_codomain_2, T, bicremental_types)
-{ quantifier_map_check_abelian_group_plus_4_bicremental_types<T, boost::rational<int>, total_absorber, INTERVAL_MAP>();}
+(test_itl_total_itv_quantifier_check_abelian_group_plus_4_bicremental_domain_and_continuous_codomain_2, T, bicremental_types)
+{ itv_quantifier_check_abelian_group_plus_4_bicremental_types<T, boost::rational<int>, total_absorber, INTERVAL_MAP>();}
//------------------------------------------------------------------------------
// total_enricher
//------------------------------------------------------------------------------
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_total_enricher_quantifier_map_check_monoid_plus_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_monoid_plus_4_bicremental_types<T, std::string, total_enricher, INTERVAL_MAP>();}
+(test_itl_total_enricher_itv_quantifier_check_monoid_plus_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_monoid_plus_4_bicremental_types<T, std::string, total_enricher, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_total_enricher_quantifier_map_check_monoid_et_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_monoid_et_4_bicremental_types<T, int, total_enricher, INTERVAL_MAP>();}
+(test_itl_total_enricher_itv_quantifier_check_monoid_et_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_monoid_et_4_bicremental_types<T, int, total_enricher, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_total_enricher_quantifier_map_check_abelian_monoid_plus_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_abelian_monoid_plus_4_bicremental_types<T, std::string, total_enricher, INTERVAL_MAP>();}
+(test_itl_total_enricher_itv_quantifier_check_abelian_monoid_plus_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_abelian_monoid_plus_4_bicremental_types<T, std::string, total_enricher, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_total_enricher_quantifier_map_check_abelian_monoid_et_4_bicremental_types, T, bicremental_types)
-{ quantifier_map_check_abelian_monoid_et_4_bicremental_types<T, float, total_enricher, INTERVAL_MAP>();}
+(test_itl_total_enricher_itv_quantifier_check_abelian_monoid_et_4_bicremental_types, T, bicremental_types)
+{ itv_quantifier_check_abelian_monoid_et_4_bicremental_types<T, float, total_enricher, INTERVAL_MAP>();}
// (0-x) + x =p= 0 | total absorber
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_total_enricher_quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_domain_and_discrete_codomain, T, bicremental_types)
-{ quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types<T, int, total_enricher, INTERVAL_MAP>();}
+(test_itl_total_enricher_itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_domain_and_discrete_codomain, T, bicremental_types)
+{ itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types<T, int, total_enricher, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_total_enricher_quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_domain_and_continuous_codomain_1, T, bicremental_types)
-{ quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types<T, double, total_enricher, INTERVAL_MAP>();}
+(test_itl_total_enricher_itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_domain_and_continuous_codomain_1, T, bicremental_types)
+{ itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types<T, double, total_enricher, INTERVAL_MAP>();}
BOOST_AUTO_TEST_CASE_TEMPLATE
-(test_itl_total_enricher_quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_domain_and_continuous_codomain_2, T, bicremental_types)
-{ quantifier_map_check_abelian_group_plus_prot_inv_4_bicremental_types<T, boost::rational<int>, total_enricher, INTERVAL_MAP>();}
+(test_itl_total_enricher_itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_domain_and_continuous_codomain_2, T, bicremental_types)
+{ itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types<T, boost::rational<int>, total_enricher, INTERVAL_MAP>();}
// absorber enricher
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-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -23,6 +23,17 @@
}
*/
+struct mono
+{
+ mono(){};
+ mono& operator ++ (){ return *this; }
+ mono& operator -- (){ return *this; }
+ mono& operator += (const mono&){ return *this; }
+};
+
+bool operator == (const mono&, const mono&){ return true; }
+bool operator < (const mono&, const mono&){ return false; }
+
template <class BicrementableT>
BicrementableT make(int n)
{
Modified: sandbox/itl/libs/itl/test/vc9_fast_tests.sln
==============================================================================
--- sandbox/itl/libs/itl/test/vc9_fast_tests.sln (original)
+++ sandbox/itl/libs/itl/test/vc9_fast_tests.sln 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -37,6 +37,12 @@
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_fastest_split_interval_set", "fastest_split_interval_set_\vc9_fastest_split_interval_set.vcproj", "{EE61B7EF-EC45-4165-8B49-FD5B7D4A915C}"
EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_fastest_partial_icl_quantifier", "fastest_partial_icl_quantifier_\vc9_fastest_partial_icl_quantifier.vcproj", "{EE61B7EF-EC45-4165-8B4A-FD5B7D3A909F}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_fastest_total_icl_quantifier", "fastest_total_icl_quantifier_\vc9_fastest_total_icl_quantifier.vcproj", "{EE61B7EF-EC45-4165-8B4B-FD5B7D4A917F}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_fastest_interval_map_mixed", "fastest_interval_map_mixed_\vc9_fastest_interval_map_mixed.vcproj", "{EE61B7EF-EC45-4165-8B49-FD5B8D3A904F}"
+EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
@@ -115,6 +121,18 @@
{EE61B7EF-EC45-4165-8B49-FD5B7D4A915C}.Debug|Win32.Build.0 = Debug|Win32
{EE61B7EF-EC45-4165-8B49-FD5B7D4A915C}.Release|Win32.ActiveCfg = Release|Win32
{EE61B7EF-EC45-4165-8B49-FD5B7D4A915C}.Release|Win32.Build.0 = Release|Win32
+ {EE61B7EF-EC45-4165-8B4A-FD5B7D3A909F}.Debug|Win32.ActiveCfg = Debug|Win32
+ {EE61B7EF-EC45-4165-8B4A-FD5B7D3A909F}.Debug|Win32.Build.0 = Debug|Win32
+ {EE61B7EF-EC45-4165-8B4A-FD5B7D3A909F}.Release|Win32.ActiveCfg = Release|Win32
+ {EE61B7EF-EC45-4165-8B4A-FD5B7D3A909F}.Release|Win32.Build.0 = Release|Win32
+ {EE61B7EF-EC45-4165-8B4B-FD5B7D4A917F}.Debug|Win32.ActiveCfg = Debug|Win32
+ {EE61B7EF-EC45-4165-8B4B-FD5B7D4A917F}.Debug|Win32.Build.0 = Debug|Win32
+ {EE61B7EF-EC45-4165-8B4B-FD5B7D4A917F}.Release|Win32.ActiveCfg = Release|Win32
+ {EE61B7EF-EC45-4165-8B4B-FD5B7D4A917F}.Release|Win32.Build.0 = Release|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B8D3A904F}.Debug|Win32.ActiveCfg = Debug|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B8D3A904F}.Debug|Win32.Build.0 = Debug|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B8D3A904F}.Release|Win32.ActiveCfg = Release|Win32
+ {EE61B7EF-EC45-4165-8B49-FD5B8D3A904F}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
Modified: sandbox/itl/libs/itl/test/vc9_slow_tests.sln
==============================================================================
--- sandbox/itl/libs/itl/test/vc9_slow_tests.sln (original)
+++ sandbox/itl/libs/itl/test/vc9_slow_tests.sln 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -45,6 +45,10 @@
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_test_continuous_interval", "test_continuous_interval_\vc9_test_continuous_interval.vcproj", "{EE61B7EF-EC45-4165-8B49-FD5B7D2B9F8C}"
EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_test_partial_icl_quantifier", "test_partial_icl_quantifier_\vc9_test_partial_icl_quantifier.vcproj", "{EE61B7EF-EC45-4165-8B4A-FD5B7D5A9F9F}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_test_total_icl_quantifier", "test_total_icl_quantifier_\vc9_test_total_icl_quantifier.vcproj", "{EE61B7EF-EC45-4165-8B4B-FD5B7D5A9F9F}"
+EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
@@ -139,6 +143,14 @@
{EE61B7EF-EC45-4165-8B49-FD5B7D2B9F8C}.Debug|Win32.Build.0 = Debug|Win32
{EE61B7EF-EC45-4165-8B49-FD5B7D2B9F8C}.Release|Win32.ActiveCfg = Release|Win32
{EE61B7EF-EC45-4165-8B49-FD5B7D2B9F8C}.Release|Win32.Build.0 = Release|Win32
+ {EE61B7EF-EC45-4165-8B4A-FD5B7D5A9F9F}.Debug|Win32.ActiveCfg = Debug|Win32
+ {EE61B7EF-EC45-4165-8B4A-FD5B7D5A9F9F}.Debug|Win32.Build.0 = Debug|Win32
+ {EE61B7EF-EC45-4165-8B4A-FD5B7D5A9F9F}.Release|Win32.ActiveCfg = Release|Win32
+ {EE61B7EF-EC45-4165-8B4A-FD5B7D5A9F9F}.Release|Win32.Build.0 = Release|Win32
+ {EE61B7EF-EC45-4165-8B4B-FD5B7D5A9F9F}.Debug|Win32.ActiveCfg = Debug|Win32
+ {EE61B7EF-EC45-4165-8B4B-FD5B7D5A9F9F}.Debug|Win32.Build.0 = Debug|Win32
+ {EE61B7EF-EC45-4165-8B4B-FD5B7D5A9F9F}.Release|Win32.ActiveCfg = Release|Win32
+ {EE61B7EF-EC45-4165-8B4B-FD5B7D5A9F9F}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
Modified: sandbox/itl/libs/validate/example/vc9_validate_examples.sln
==============================================================================
--- sandbox/itl/libs/validate/example/vc9_validate_examples.sln (original)
+++ sandbox/itl/libs/validate/example/vc9_validate_examples.sln 2010-08-26 13:09:26 EDT (Thu, 26 Aug 2010)
@@ -45,6 +45,8 @@
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_boostcon_abelian_monoids", "boostcon_abelian_monoids_\vc9_boostcon_abelian_monoids.vcproj", "{BF42574F-66E2-42DD-90D9-3A8FCE6F4733}"
EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vc9_fastest_itl_map", "..\..\itl\test\fastest_itl_map_\vc9_fastest_itl_map.vcproj", "{DD9C9854-3882-42B9-BFA1-C6CEBFCE309B}"
+EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
@@ -139,6 +141,10 @@
{BF42574F-66E2-42DD-90D9-3A8FCE6F4733}.Debug|Win32.Build.0 = Debug|Win32
{BF42574F-66E2-42DD-90D9-3A8FCE6F4733}.Release|Win32.ActiveCfg = Release|Win32
{BF42574F-66E2-42DD-90D9-3A8FCE6F4733}.Release|Win32.Build.0 = Release|Win32
+ {DD9C9854-3882-42B9-BFA1-C6CEBFCE309B}.Debug|Win32.ActiveCfg = Debug|Win32
+ {DD9C9854-3882-42B9-BFA1-C6CEBFCE309B}.Debug|Win32.Build.0 = Debug|Win32
+ {DD9C9854-3882-42B9-BFA1-C6CEBFCE309B}.Release|Win32.ActiveCfg = Release|Win32
+ {DD9C9854-3882-42B9-BFA1-C6CEBFCE309B}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk