Subject: [Boost-commit] svn:boost r56021 - in sandbox/itl: boost/itl boost/itl/detail boost/itl/type_traits boost/itl_xt boost/validate/gentor boost/validate/laws libs/itl/doc libs/itl/example/overlap_counter_ libs/itl/test libs/itl/test/test_casual_ libs/validate/example/labat_collector_ libs/validate/example/labat_itl_morphic_ libs/validate/example/labat_itl_order_ libs/validate/example/labat_itl_set_ libs/validate/example/labat_polygon_ libs/validate/example/labat_signed_quantifier_ libs/validate/example/labat_single_ libs/validate/example/labat_unsigned_quantifier_ libs/validate/example/labat_val_relations_ libs/validate/src/gentor
From: afojgo_at_[hidden]
Date: 2009-09-04 17:27:42
Author: jofaber
Date: 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
New Revision: 56021
URL: http://svn.boost.org/trac/boost/changeset/56021
Log:
Boostifying. Replaced tabs. Corrections in docs. Stable {msvc-9.0r+d, gcc-3.4.4, inspected}
Removed:
sandbox/itl/boost/itl/interval_map_algo.hpp
Text files modified:
sandbox/itl/boost/itl/detail/interval_subset_comparer.hpp | 92 ++++----
sandbox/itl/boost/itl/detail/subset_comparer.hpp | 100 ++++----
sandbox/itl/boost/itl/functions.hpp | 12
sandbox/itl/boost/itl/interval.hpp | 4
sandbox/itl/boost/itl/interval_base_map.hpp | 106 ++++----
sandbox/itl/boost/itl/interval_base_set.hpp | 30 +-
sandbox/itl/boost/itl/interval_set.hpp | 14
sandbox/itl/boost/itl/interval_set_algo.hpp | 66 +++---
sandbox/itl/boost/itl/map.hpp | 130 ++++++------
sandbox/itl/boost/itl/map_algo.hpp | 70 +++---
sandbox/itl/boost/itl/predicates.hpp | 2
sandbox/itl/boost/itl/separate_interval_set.hpp | 10
sandbox/itl/boost/itl/set.hpp | 28 +-
sandbox/itl/boost/itl/type_traits/is_concept_equivalent.hpp | 14
sandbox/itl/boost/itl/type_traits/is_element_container.hpp | 20
sandbox/itl/boost/itl/type_traits/is_interval_container.hpp | 30 +-
sandbox/itl/boost/itl_xt/itvgentor.hpp | 2
sandbox/itl/boost/itl_xt/list.hpp | 18
sandbox/itl/boost/validate/gentor/gentorprofile.hpp | 2
sandbox/itl/boost/validate/gentor/randomgentor.hpp | 36 +-
sandbox/itl/boost/validate/laws/minor_set_laws.hpp | 144 ++++++------
sandbox/itl/libs/itl/doc/concepts.qbk | 51 ++++
sandbox/itl/libs/itl/doc/examples.qbk | 28 +
sandbox/itl/libs/itl/doc/functions.qbk | 12
sandbox/itl/libs/itl/doc/functions_addition.qbk | 24 ++
sandbox/itl/libs/itl/doc/functions_equivs_orderings.qbk | 4
sandbox/itl/libs/itl/doc/functions_erasure.qbk | 9
sandbox/itl/libs/itl/doc/functions_insertion.qbk | 2
sandbox/itl/libs/itl/doc/functions_intersection.qbk | 26 ++
sandbox/itl/libs/itl/doc/functions_streaming.qbk | 9
sandbox/itl/libs/itl/doc/functions_subtraction.qbk | 19 +
sandbox/itl/libs/itl/doc/functions_symmetric_difference.qbk | 10
sandbox/itl/libs/itl/doc/interface.qbk | 9
sandbox/itl/libs/itl/doc/introduction.qbk | 8
sandbox/itl/libs/itl/doc/semantics.qbk | 4
sandbox/itl/libs/itl/example/overlap_counter_/overlap_counter.cpp | 28 +-
sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp | 86 ++++----
sandbox/itl/libs/itl/test/test_interval_map_mixed.hpp | 426 ++++++++++++++++++++--------------------
sandbox/itl/libs/itl/test/test_interval_map_shared.hpp | 109 +++++----
sandbox/itl/libs/itl/test/test_itl_map.hpp | 72 +++---
sandbox/itl/libs/itl/test/test_value_maker.hpp | 2
sandbox/itl/libs/validate/example/labat_collector_/labat_collector.cpp | 2
sandbox/itl/libs/validate/example/labat_itl_morphic_/labat_itl_morphic.cpp | 2
sandbox/itl/libs/validate/example/labat_itl_order_/labat_itl_order.cpp | 2
sandbox/itl/libs/validate/example/labat_itl_set_/labat_itl_set.cpp | 2
sandbox/itl/libs/validate/example/labat_polygon_/labat_polygon.cpp | 102 ++++----
sandbox/itl/libs/validate/example/labat_polygon_/point_gentor.hpp | 32 +-
sandbox/itl/libs/validate/example/labat_polygon_/polygon_gentor.hpp | 24 +-
sandbox/itl/libs/validate/example/labat_polygon_/polygon_laws.hpp | 66 +++---
sandbox/itl/libs/validate/example/labat_signed_quantifier_/labat_signed_quantifier.cpp | 2
sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp | 30 +-
sandbox/itl/libs/validate/example/labat_unsigned_quantifier_/labat_unsigned_quantifier.cpp | 2
sandbox/itl/libs/validate/example/labat_val_relations_/labat_val_relations.cpp | 2
sandbox/itl/libs/validate/src/gentor/gentorprofile.cpp | 4
54 files changed, 1154 insertions(+), 986 deletions(-)
Modified: sandbox/itl/boost/itl/detail/interval_subset_comparer.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/interval_subset_comparer.hpp (original)
+++ sandbox/itl/boost/itl/detail/interval_subset_comparer.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -27,52 +27,52 @@
template<class LeftT, class RightT>
struct settic_codomain_compare
{
- static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
- {
- return inclusion_compare( LeftT::codomain_value(left_),
- RightT::codomain_value(right_));
- }
+ static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
+ {
+ return inclusion_compare( LeftT::codomain_value(left_),
+ RightT::codomain_value(right_));
+ }
};
template<class LeftT, class RightT>
struct atomic_codomain_compare
{
- static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
- {
- if(LeftT::codomain_value(left_) == RightT::codomain_value(right_))
- return inclusion::equal;
- else
- return inclusion::unrelated;
- }
+ static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
+ {
+ if(LeftT::codomain_value(left_) == RightT::codomain_value(right_))
+ return inclusion::equal;
+ else
+ return inclusion::unrelated;
+ }
};
template<class LeftT, class RightT>
struct empty_codomain_compare
{
- static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
- {
- return inclusion::equal;
- }
+ static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
+ {
+ return inclusion::equal;
+ }
};
template<class LeftT, class RightT>
struct map_codomain_compare
{
- static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
- {
- using namespace boost::mpl;
- typedef typename LeftT::codomain_type LeftCodomainT;
- typedef typename RightT::codomain_type RightCodomainT;
-
- return
- if_<
- bool_<is_concept_equivalent<is_set,LeftCodomainT,
- RightCodomainT>::value>,
- settic_codomain_compare<LeftT,RightT>,
- atomic_codomain_compare<LeftT,RightT>
- >
- ::type::apply(left_, right_);
- }
+ static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
+ {
+ using namespace boost::mpl;
+ typedef typename LeftT::codomain_type LeftCodomainT;
+ typedef typename RightT::codomain_type RightCodomainT;
+
+ return
+ if_<
+ bool_<is_concept_equivalent<is_set,LeftCodomainT,
+ RightCodomainT>::value>,
+ settic_codomain_compare<LeftT,RightT>,
+ atomic_codomain_compare<LeftT,RightT>
+ >
+ ::type::apply(left_, right_);
+ }
};
@@ -113,13 +113,13 @@
int co_compare(LeftIterT& left, RightIterT& right)
{
- using namespace boost::mpl;
+ using namespace boost::mpl;
- return
- if_<
+ return
+ if_<
bool_<is_concept_equivalent<is_interval_map,LeftT,RightT>::value>,
- map_codomain_compare<LeftT,RightT>,
- empty_codomain_compare<LeftT,RightT>
+ map_codomain_compare<LeftT,RightT>,
+ empty_codomain_compare<LeftT,RightT>
>
::type::apply(left,right);
}
@@ -212,8 +212,8 @@
// left and right have intervals with nonempty intersection:
if(compare_codomain())
- if(unrelated == restrict_result(co_compare(left,right)))
- return stop;
+ if(unrelated == restrict_result(co_compare(left,right)))
+ return stop;
// examine left borders only. Right borders are checked in proceed
if(LeftT::key_value(left).lower_less(RightT::key_value(right)))
@@ -256,15 +256,15 @@
//else ..) [...
// [..
if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right)) )
- if(unrelated == restrict_result(co_compare(left,right)))
- return stop;
+ if(unrelated == restrict_result(co_compare(left,right)))
+ return stop;
}
else
{ // left: ..)[.. left could be subset
// right:.......)
if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right)) )
- if(unrelated == restrict_result(co_compare(left,right)))
- return stop;
+ if(unrelated == restrict_result(co_compare(left,right)))
+ return stop;
}
return proceed(left, right);
@@ -291,14 +291,14 @@
//else [....)
// ..) [..
if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right)) )
- if(unrelated == restrict_result(co_compare(left,right)))
- return stop;
+ if(unrelated == restrict_result(co_compare(left,right)))
+ return stop;
}
else
{
if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right)) )
- if(unrelated == restrict_result(co_compare(left,right)))
- return stop;
+ if(unrelated == restrict_result(co_compare(left,right)))
+ return stop;
}
return proceed(left, right);
Modified: sandbox/itl/boost/itl/detail/subset_comparer.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/subset_comparer.hpp (original)
+++ sandbox/itl/boost/itl/detail/subset_comparer.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -26,52 +26,52 @@
template<class LeftT, class RightT>
struct settic_codomain_compare
{
- static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
- {
- return inclusion_compare( LeftT::codomain_value(left_),
- RightT::codomain_value(right_));
- }
+ static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
+ {
+ return inclusion_compare( LeftT::codomain_value(left_),
+ RightT::codomain_value(right_));
+ }
};
template<class LeftT, class RightT>
struct atomic_codomain_compare
{
- static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
- {
- if(LeftT::codomain_value(left_) == RightT::codomain_value(right_))
- return inclusion::equal;
- else
- return inclusion::unrelated;
- }
+ static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
+ {
+ if(LeftT::codomain_value(left_) == RightT::codomain_value(right_))
+ return inclusion::equal;
+ else
+ return inclusion::unrelated;
+ }
};
template<class LeftT, class RightT>
struct empty_codomain_compare
{
- static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
- {
- return inclusion::equal;
- }
+ static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
+ {
+ return inclusion::equal;
+ }
};
template<class LeftT, class RightT>
struct map_codomain_compare
{
- static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
- {
- using namespace boost::mpl;
- typedef typename LeftT::codomain_type LeftCodomainT;
- typedef typename RightT::codomain_type RightCodomainT;
-
- return
- if_<
- bool_<is_concept_equivalent<is_set,LeftCodomainT,
- RightCodomainT>::value>,
- settic_codomain_compare<LeftT,RightT>,
- atomic_codomain_compare<LeftT,RightT>
- >
- ::type::apply(left_, right_);
- }
+ static int apply(typename LeftT::const_iterator& left_, typename RightT::const_iterator& right_)
+ {
+ using namespace boost::mpl;
+ typedef typename LeftT::codomain_type LeftCodomainT;
+ typedef typename RightT::codomain_type RightCodomainT;
+
+ return
+ if_<
+ bool_<is_concept_equivalent<is_set,LeftCodomainT,
+ RightCodomainT>::value>,
+ settic_codomain_compare<LeftT,RightT>,
+ atomic_codomain_compare<LeftT,RightT>
+ >
+ ::type::apply(left_, right_);
+ }
};
@@ -112,15 +112,15 @@
int co_compare(LeftIterT& left, RightIterT& right)
{
- using namespace boost::mpl;
- typedef typename LeftT::codomain_type LeftCodomainT;
- typedef typename RightT::codomain_type RightCodomainT;
+ using namespace boost::mpl;
+ typedef typename LeftT::codomain_type LeftCodomainT;
+ typedef typename RightT::codomain_type RightCodomainT;
- return
- if_<
+ return
+ if_<
bool_<is_concept_equivalent<is_element_map,LeftT,RightT>::value>,
- map_codomain_compare<LeftT,RightT>,
- empty_codomain_compare<LeftT,RightT>
+ map_codomain_compare<LeftT,RightT>,
+ empty_codomain_compare<LeftT,RightT>
>
::type::apply(left,right);
}
@@ -151,7 +151,7 @@
{
LeftIterT joint_ = _left.lower_bound(RightT::key_value(right));
if( joint_ == _left.end()
- || typename LeftT::domain_compare()(RightT::key_value(right), LeftT::key_value(joint_)))
+ || typename LeftT::domain_compare()(RightT::key_value(right), LeftT::key_value(joint_)))
{
_result = unrelated;
return stop;
@@ -170,7 +170,7 @@
{
RightIterT joint_ = _right.lower_bound(LeftT::key_value(left));
if( joint_ == _right.end()
- || typename LeftT::domain_compare()(LeftT::key_value(left), RightT::key_value(joint_)))
+ || typename LeftT::domain_compare()(LeftT::key_value(left), RightT::key_value(joint_)))
{
_result = unrelated;
return stop;
@@ -182,11 +182,11 @@
// left =key= right
if(compare_codomain())
- if(unrelated == restrict_result(co_compare(left,right)))
- return stop;
+ if(unrelated == restrict_result(co_compare(left,right)))
+ return stop;
- ++left;
- ++right;
+ ++left;
+ ++right;
return nextboth;
}
@@ -234,12 +234,12 @@
template<class LeftT, class RightT>
int subset_compare(const LeftT& left, const RightT& right)
{
- return subset_compare
- (
- left, right,
- left.begin(), left.end(),
- right.begin(), right.end()
- );
+ return subset_compare
+ (
+ left, right,
+ left.begin(), left.end(),
+ right.begin(), right.end()
+ );
}
Modified: sandbox/itl/boost/itl/functions.hpp
==============================================================================
--- sandbox/itl/boost/itl/functions.hpp (original)
+++ sandbox/itl/boost/itl/functions.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -57,8 +57,8 @@
inclusion_compare(const LeftT& left, const RightT& right)
{
return Interval_Set::subset_compare(left, right,
- left.begin(), left.end(),
- right.begin(), right.end());
+ left.begin(), left.end(),
+ right.begin(), right.end());
}
template<class LeftT, class RightT>
@@ -67,8 +67,8 @@
inclusion_compare(const LeftT& left, const RightT& right)
{
return Set::subset_compare(left, right,
- left.begin(), left.end(),
- right.begin(), right.end());
+ left.begin(), left.end(),
+ right.begin(), right.end());
}
//------------------------------------------------------------------------------
@@ -379,8 +379,8 @@
bool>::type
intersects(const LeftT& left, const RightT& right)
{
- if(is_total<LeftT>::value || is_total<RightT>::value)
- return true;
+ if(is_total<LeftT>::value || is_total<RightT>::value)
+ return true;
LeftT intersection;
Modified: sandbox/itl/boost/itl/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval.hpp (original)
+++ sandbox/itl/boost/itl/interval.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -1071,8 +1071,8 @@
template<class DomainT>
struct value_size<itl::interval<DomainT> >
{
- static std::size_t value_size::apply(const itl::interval<DomainT>& value)
- { return 2; }
+ static std::size_t value_size::apply(const itl::interval<DomainT>& value)
+ { return 2; }
};
Modified: sandbox/itl/boost/itl/interval_base_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_map.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -203,30 +203,30 @@
/** Does the map contain the interval \c sub_interval ? */
bool contains(const interval_type& sub_interval)const
- {
- if(Traits::is_total || sub_interval.empty())
- return true;
-
- std::pair<const_iterator, const_iterator> exterior = equal_range(sub_interval);
- if(exterior.first == exterior.second)
- return false;
-
- const_iterator last_overlap = prior(exterior.second);
-
- return
- hull(exterior.first->KEY_VALUE, last_overlap->KEY_VALUE).contains(sub_interval)
- && Interval_Set::is_dense(*this, exterior.first, last_overlap);
- }
+ {
+ if(Traits::is_total || sub_interval.empty())
+ return true;
+
+ std::pair<const_iterator, const_iterator> exterior = equal_range(sub_interval);
+ if(exterior.first == exterior.second)
+ return false;
+
+ const_iterator last_overlap = prior(exterior.second);
+
+ return
+ hull(exterior.first->KEY_VALUE, last_overlap->KEY_VALUE).contains(sub_interval)
+ && Interval_Set::is_dense(*this, exterior.first, last_overlap);
+ }
/** Does the map contain the key key set \c sub_set ? */
- template<class SetType>
+ template<class SetType>
bool contains(const interval_base_set<SetType,DomainT,Compare,Interval,Alloc>& sub_set)const
- {
- if(Traits::is_total || sub_set.empty())
- return true;
+ {
+ if(Traits::is_total || sub_set.empty())
+ return true;
return Interval_Set::is_contained_in(sub_set, *this);
- }
+ }
/** Does the map contain the <tt>key_value_pair = (key,value)</tt>? */
bool contains(const element_type& key_value_pair)const
@@ -240,17 +240,17 @@
bool contains(const segment_type& interval_value_pair)const;
/** Does <tt>*this</tt> container contain <tt>sub</tt>? */
- template<class MapType>
+ template<class MapType>
bool contains(const interval_base_map<MapType,DomainT,CodomainT,Traits,
- Compare,Combine,Section,Interval,Alloc>& sub)const
+ Compare,Combine,Section,Interval,Alloc>& sub)const
{
- return sub.contained_in(*this);
- }
+ return sub.contained_in(*this);
+ }
/** <tt>*this</tt> is subset of <tt>super</tt>? */
- template<class MapType>
+ template<class MapType>
bool contained_in(const interval_base_map<MapType,DomainT,CodomainT,Traits,
- Compare,Combine,Section,Interval,Alloc>& super)const
+ Compare,Combine,Section,Interval,Alloc>& super)const
{
return Interval_Set::is_contained_in(*this, super);
}
@@ -510,7 +510,7 @@
{
typedef IntervalSet<DomainT,Compare,Interval,Alloc> sectant_type;
if(sectant.empty())
- return;
+ return;
typename sectant_type::const_iterator common_lwb;
typename sectant_type::const_iterator common_upb;
@@ -545,36 +545,36 @@
Complexity: logarithmic. */
bool intersects(const domain_type& key)const
{
- return contains(key);
- }
+ return contains(key);
+ }
/** Returns \c true, if \c inter_val intersects with \c *this map.
Complexity: Logarithmic in iterative size. */
bool intersects(const interval_type& inter_val)const
{
- if(Traits::is_total)
- return true;
- std::pair<const_iterator,const_iterator> overlap = equal_range(inter_val);
- return overlap.first == overlap.second;
- }
+ if(Traits::is_total)
+ return true;
+ std::pair<const_iterator,const_iterator> overlap = equal_range(inter_val);
+ return overlap.first == overlap.second;
+ }
/** Returns \c true, if \c key_value_pair is found in \c *this map.
Complexity: logarithmic. */
bool intersects(const element_type& key_value_pair)const
{
- return intersects(segment_type(interval_type(key_value_pair.key), key_value_pair.data));
+ return intersects(segment_type(interval_type(key_value_pair.key), key_value_pair.data));
}
/** Returns \c true, if \c interval_value_pair intersects with \c *this map:
Complexity: Linear in iterative_size. */
bool intersects(const segment_type& interval_value_pair)const
{
- if(traits::is_total)
- return true;
+ if(traits::is_total)
+ return true;
- type intersection;
- add_intersection(intersection, interval_value_pair);
- return !intersection.empty();
+ type intersection;
+ add_intersection(intersection, interval_value_pair);
+ return !intersection.empty();
}
@@ -703,7 +703,7 @@
template<typename LeftIterT, typename RightIterT>
static bool key_less(LeftIterT left_, RightIterT right_)
- { return key_compare()((*left_).first, (*right_).first); }
+ { 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); }
@@ -802,18 +802,18 @@
if(sub_interval.empty())
return true;
- std::pair<const_iterator, const_iterator> exterior = equal_range(sub_interval);
- if(exterior.first == exterior.second)
- return false;
-
- const_iterator last_overlap = prior(exterior.second);
-
- if(!(sub_segment.CONT_VALUE == exterior.first->CONT_VALUE) )
- return false;
-
- return
- hull(exterior.first->KEY_VALUE, last_overlap->KEY_VALUE).contains(sub_interval)
- && Interval_Set::is_joinable(*this, exterior.first, last_overlap);
+ std::pair<const_iterator, const_iterator> exterior = equal_range(sub_interval);
+ if(exterior.first == exterior.second)
+ return false;
+
+ const_iterator last_overlap = prior(exterior.second);
+
+ if(!(sub_segment.CONT_VALUE == exterior.first->CONT_VALUE) )
+ return false;
+
+ return
+ hull(exterior.first->KEY_VALUE, last_overlap->KEY_VALUE).contains(sub_interval)
+ && Interval_Set::is_joinable(*this, exterior.first, last_overlap);
}
@@ -972,7 +972,7 @@
::interval_type& sectant_interval)const
{
if(sectant_interval.empty())
- return;
+ return;
typename ImplMapT::const_iterator first_ = _map.lower_bound(sectant_interval);
typename ImplMapT::const_iterator end_ = _map.upper_bound(sectant_interval);
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 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -153,20 +153,20 @@
/** Does the container contain the interval \c sub_interval ? */
bool contains(const segment_type& sub_interval)const
- {
- if(sub_interval.empty())
- return true;
-
- std::pair<const_iterator, const_iterator> exterior = equal_range(sub_interval);
- if(exterior.first == exterior.second)
- return false;
-
- const_iterator last_overlap = prior(exterior.second);
-
- return
- hull(*(exterior.first), *last_overlap).contains(sub_interval)
- && Interval_Set::is_joinable(*this, exterior.first, last_overlap);
- }
+ {
+ if(sub_interval.empty())
+ return true;
+
+ std::pair<const_iterator, const_iterator> exterior = equal_range(sub_interval);
+ if(exterior.first == exterior.second)
+ return false;
+
+ const_iterator last_overlap = prior(exterior.second);
+
+ return
+ hull(*(exterior.first), *last_overlap).contains(sub_interval)
+ && Interval_Set::is_joinable(*this, exterior.first, last_overlap);
+ }
/** Does the container contain the subcontainer \c sub ? */
@@ -442,7 +442,7 @@
iterator prior(iterator it_)
{ return it_ == this->_set.begin() ? this->_set.end() : --it_; }
- const_iterator prior(const_iterator it_)const
+ const_iterator prior(const_iterator it_)const
{ return it_ == this->_set.begin() ? this->_set.end() : --it_; }
iterator gap_insert(iterator prior_, const interval_type& inter_val)
Deleted: sandbox/itl/boost/itl/interval_map_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map_algo.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
+++ (empty file)
@@ -1,17 +0,0 @@
-/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
-+------------------------------------------------------------------------------+
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENCE.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt)
-+-----------------------------------------------------------------------------*/
-#ifndef __itl_interval_map_algo_JOFA_081026_H__
-#define __itl_interval_map_algo_JOFA_081026_H__
-
-#include <boost/itl/detail/notate.hpp>
-#include <boost/itl/type_traits/neutron.hpp>
-
-//CL complete
-
-#endif
-
Modified: sandbox/itl/boost/itl/interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_set.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -99,8 +99,8 @@
explicit interval_set
(const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
{
- assign(src);
- }
+ assign(src);
+ }
/// Constructor for a single element
explicit interval_set(const domain_type& value): base_type()
@@ -108,17 +108,17 @@
/// Constructor for a single interval
explicit interval_set(const interval_type& itv): base_type()
{
- add(itv);
- }
+ add(itv);
+ }
/// Assignment operator
template<class SubType>
interval_set& operator =
(const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
{
- assign(src);
- return *this;
- }
+ assign(src);
+ return *this;
+ }
/// Assignment from a base interval_set.
Modified: sandbox/itl/boost/itl/interval_set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set_algo.hpp (original)
+++ sandbox/itl/boost/itl/interval_set_algo.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -150,51 +150,51 @@
template<class IntervalContainerT>
bool is_joinable(const IntervalContainerT& container,
- typename IntervalContainerT::const_iterator first,
- typename IntervalContainerT::const_iterator past)
+ typename IntervalContainerT::const_iterator first,
+ typename IntervalContainerT::const_iterator past)
{
- if(first == container.end())
- return true;
+ if(first == container.end())
+ return true;
- typename IntervalContainerT::const_iterator it_ = first, next_ = first;
- ++next_;
+ typename IntervalContainerT::const_iterator it_ = first, next_ = first;
+ ++next_;
- if(is_interval_map<IntervalContainerT>::value)
- {
- const typename IntervalContainerT::codomain_type& co_value
- = IntervalContainerT::codomain_value(first);
- while(it_ != past)
- {
- if(IntervalContainerT::codomain_value(next_) != co_value)
- return false;
- if(!IntervalContainerT::key_value(it_++).touches(IntervalContainerT::key_value(next_++)))
- return false;
- }
- }
- else
- while(next_ != container.end() && it_ != past)
- if(!IntervalContainerT::key_value(it_++).touches(IntervalContainerT::key_value(next_++)))
- return false;
+ if(is_interval_map<IntervalContainerT>::value)
+ {
+ const typename IntervalContainerT::codomain_type& co_value
+ = IntervalContainerT::codomain_value(first);
+ while(it_ != past)
+ {
+ if(IntervalContainerT::codomain_value(next_) != co_value)
+ return false;
+ if(!IntervalContainerT::key_value(it_++).touches(IntervalContainerT::key_value(next_++)))
+ return false;
+ }
+ }
+ else
+ while(next_ != container.end() && it_ != past)
+ if(!IntervalContainerT::key_value(it_++).touches(IntervalContainerT::key_value(next_++)))
+ return false;
- return true;
+ return true;
}
template<class IntervalContainerT>
bool is_dense(const IntervalContainerT& container,
- typename IntervalContainerT::const_iterator first,
- typename IntervalContainerT::const_iterator past)
+ typename IntervalContainerT::const_iterator first,
+ typename IntervalContainerT::const_iterator past)
{
- if(first == container.end())
- return true;
+ if(first == container.end())
+ return true;
- typename IntervalContainerT::const_iterator it_ = first, next_ = first;
- ++next_;
+ typename IntervalContainerT::const_iterator it_ = first, next_ = first;
+ ++next_;
- while(next_ != container.end() && it_ != past)
- if(!IntervalContainerT::key_value(it_++).touches(IntervalContainerT::key_value(next_++)))
- return false;
+ while(next_ != container.end() && it_ != past)
+ if(!IntervalContainerT::key_value(it_++).touches(IntervalContainerT::key_value(next_++)))
+ return false;
- return true;
+ return true;
}
} // namespace Interval_Set
Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -177,10 +177,10 @@
/** 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;
- }
+ {
+ const_iterator found_ = find(key_value_pair.first);
+ return found_ != end() && found_->second == key_value_pair.second;
+ }
/** Is <tt>*this</tt> contained in <tt>super</tt>? */
bool contained_in(const map& super)const
@@ -274,16 +274,16 @@
/** 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;
+ /** 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;
//==========================================================================
//= Symmetric difference
@@ -353,13 +353,13 @@
template<class Predicate>
map& assign_if(const map& src, const Predicate&);
- /** Copy the key values of the map to \c domain_set. Complexity: Linear. */
- void domain(set_type& domain_set)const
- {
- typename set_type::iterator prior_ = domain_set.end();
- const_FORALL_THIS(it_)
- prior_ = domain_set.insert(prior_, it_->KEY_VALUE);
- }
+ /** Copy the key values of the map to \c domain_set. Complexity: Linear. */
+ void domain(set_type& domain_set)const
+ {
+ typename set_type::iterator prior_ = domain_set.end();
+ const_FORALL_THIS(it_)
+ prior_ = domain_set.insert(prior_, it_->KEY_VALUE);
+ }
private:
template<class Combiner>
@@ -558,21 +558,21 @@
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
+ ::intersects(const domain_type& key)const
{
- return traits::is_total || contains(key);
+ 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;
+ if(traits::is_total)
+ return true;
- type intersection;
- add_intersection(intersection, key_value_pair);
- return !intersection.empty();
+ type intersection;
+ add_intersection(intersection, key_value_pair);
+ return !intersection.empty();
}
@@ -881,7 +881,7 @@
{
typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object_type;
if(Traits::is_total)
- return object += operand;
+ return object += operand;
else
{
object_type section;
@@ -935,75 +935,75 @@
//------------------------------------------------------------------------------
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)
+ const typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::domain_type& key)
{
- return object.intersects(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 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);
+ 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)
+ const typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::element_type& key_value_pair)
{
- return object.intersects(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 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);
+ 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)
+ 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);
+ 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 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);
+ 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)
+ 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);
+ 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,
@@ -1013,7 +1013,7 @@
>, bool>
is_disjoint(const LeftT& left, const RightT& right)
{
- return !intersects(left, right);
+ return !intersects(left, right);
}
Modified: sandbox/itl/boost/itl/map_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/map_algo.hpp (original)
+++ sandbox/itl/boost/itl/map_algo.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -47,7 +47,7 @@
template<class MapType>
bool contained_in(const typename MapType::set_type& sub, const MapType& super)
{
- typedef typename MapType::set_type SetType;
+ typedef typename MapType::set_type SetType;
if(sub.empty()) return true;
if(super.empty()) return false;
@@ -61,7 +61,7 @@
return false;
typename SetType::const_iterator sub_ = sub.begin();
- typename MapType::const_iterator super_;
+ typename MapType::const_iterator super_;
while(sub_ != sub.end())
{
super_ = super.find(*sub_++);
@@ -75,33 +75,33 @@
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;
+ 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;
+ return false;
}
template <class ObjectT, class CoObjectT>
bool key_intersects(const ObjectT& left, const CoObjectT& right)
{
- typename CoObjectT::const_iterator right_common_lower_;
- typename CoObjectT::const_iterator right_common_upper_;
- if(!Set::common_range(right_common_lower_, right_common_upper_, right, left))
- return false;
-
- typename CoObjectT::const_iterator right_ = right_common_lower_;
- while(right_ != right_common_upper_)
- if(left.intersects(CoObjectT::key_value(right_++)))
- return true;
+ typename CoObjectT::const_iterator right_common_lower_;
+ typename CoObjectT::const_iterator right_common_upper_;
+ if(!Set::common_range(right_common_lower_, right_common_upper_, right, left))
+ return false;
- return false;
+ typename CoObjectT::const_iterator right_ = right_common_lower_;
+ while(right_ != right_common_upper_)
+ if(left.intersects(CoObjectT::key_value(right_++)))
+ return true;
+
+ return false;
}
//----------------------------------------------------------------------
@@ -222,10 +222,10 @@
int co_compare(LeftIterT& left, RightIterT& right)
{
- using namespace boost::mpl;
+ using namespace boost::mpl;
- return
- if_<
+ return
+ if_<
bool_<is_concept_equivalent<is_interval_map,LeftT,RightT>::value>,
map_codomain_compare<LeftT,RightT>,
empty_codomain_compare<LeftT,RightT>
@@ -321,8 +321,8 @@
// left and right have intervals with nonempty intersection:
if(compare_codomain())
- if(unrelated == restrict_result(co_compare(left,right)))
- return stop;
+ if(unrelated == restrict_result(co_compare(left,right)))
+ return stop;
// examine left borders only. Right borders are checked in proceed
if(LeftT::key_value(left).lower_less(RightT::key_value(right)))
@@ -365,15 +365,15 @@
//else ..) [...
// [..
if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right)) )
- if(unrelated == restrict_result(co_compare(left,right)))
- return stop;
+ if(unrelated == restrict_result(co_compare(left,right)))
+ return stop;
}
else
{ // left: ..)[.. left could be subset
// right:.......)
if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right)) )
- if(unrelated == restrict_result(co_compare(left,right)))
- return stop;
+ if(unrelated == restrict_result(co_compare(left,right)))
+ return stop;
}
return proceed(left, right);
@@ -400,14 +400,14 @@
//else [....)
// ..) [..
if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right)) )
- if(unrelated == restrict_result(co_compare(left,right)))
- return stop;
+ if(unrelated == restrict_result(co_compare(left,right)))
+ return stop;
}
else
{
if(compare_codomain() && !LeftT::key_value(left).is_disjoint(RightT::key_value(right)) )
- if(unrelated == restrict_result(co_compare(left,right)))
- return stop;
+ if(unrelated == restrict_result(co_compare(left,right)))
+ return stop;
}
return proceed(left, right);
Modified: sandbox/itl/boost/itl/predicates.hpp
==============================================================================
--- sandbox/itl/boost/itl/predicates.hpp (original)
+++ sandbox/itl/boost/itl/predicates.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -70,7 +70,7 @@
}
};
- //-----------------------------------------------------------------------------
+ //-----------------------------------------------------------------------------
template<>
inline std::string unary_template_to_string<itl::std_equal>::apply()
Modified: sandbox/itl/boost/itl/separate_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/separate_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/separate_interval_set.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -99,8 +99,8 @@
separate_interval_set
(const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
{
- assign(src);
- }
+ assign(src);
+ }
/// Constructor for a single element
explicit separate_interval_set(const domain_type& elem): base_type() { add(elem); }
@@ -112,9 +112,9 @@
separate_interval_set& operator =
(const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
{
- assign(src);
- return *this;
- }
+ assign(src);
+ return *this;
+ }
/// Assignment from a base interval_set.
template<class SubType>
Modified: sandbox/itl/boost/itl/set.hpp
==============================================================================
--- sandbox/itl/boost/itl/set.hpp (original)
+++ sandbox/itl/boost/itl/set.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -183,10 +183,10 @@
to \c section. */
void add_intersection(set& section, const set& sectant)const;
- /** Returns true, if there is an intersection of \c element and \c *this set.
- Functions \c intersects and \c contains are identical on arguments
- of type \c element_type. Complexity: Logarithmic in container size. */
- bool intersects(const element_type& element)const { return contains(element); }
+ /** Returns true, if there is an intersection of \c element and \c *this set.
+ Functions \c intersects and \c contains are identical on arguments
+ of type \c element_type. Complexity: Logarithmic in container size. */
+ bool intersects(const element_type& element)const { return contains(element); }
/** If \c *this set contains \c element it is erased, otherwise it is added. */
set& flip(const element_type& element);
@@ -536,27 +536,27 @@
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
bool intersects(const itl::set<DomainT,Compare,Alloc>& object,
- const typename itl::set<DomainT,Compare,Alloc>::element_type& element)
+ const typename itl::set<DomainT,Compare,Alloc>::element_type& element)
{
- return object.intersects(element);
+ return object.intersects(element);
}
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
bool intersects(
- const typename itl::set<DomainT,Compare,Alloc>::element_type& element,
+ const typename itl::set<DomainT,Compare,Alloc>::element_type& element,
const itl::set<DomainT,Compare,Alloc>& object)
{
- return object.intersects(element);
+ return object.intersects(element);
}
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
bool intersects(const itl::set<DomainT,Compare,Alloc>& left,
- const itl::set<DomainT,Compare,Alloc>& right)
+ const itl::set<DomainT,Compare,Alloc>& right)
{
- if(left.iterative_size() < right.iterative_size())
- return Set::intersects(right, left);
- else
- return Set::intersects(left, right);
+ if(left.iterative_size() < right.iterative_size())
+ return Set::intersects(right, left);
+ else
+ return Set::intersects(left, right);
}
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc,
@@ -566,7 +566,7 @@
>, bool>
is_disjoint(const LeftT& left, const RightT& right)
{
- return !intersects(left,right);
+ return !intersects(left,right);
}
Modified: sandbox/itl/boost/itl/type_traits/is_concept_equivalent.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_concept_equivalent.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_concept_equivalent.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -13,13 +13,13 @@
namespace boost{ namespace itl
{
- template<template<class>class IsConcept, class LeftT, class RightT>
- struct is_concept_equivalent
- {
- typedef is_concept_equivalent<IsConcept, LeftT, RightT> type;
- static const bool value =
- mpl::and_<IsConcept<LeftT>, IsConcept<RightT> >::value;
- };
+ template<template<class>class IsConcept, class LeftT, class RightT>
+ struct is_concept_equivalent
+ {
+ typedef is_concept_equivalent<IsConcept, LeftT, RightT> type;
+ static const bool value =
+ mpl::and_<IsConcept<LeftT>, IsConcept<RightT> >::value;
+ };
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_element_container.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_element_container.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_element_container.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -17,20 +17,20 @@
namespace boost{ namespace itl
{
template <class Type>
- struct is_element_container
+ struct is_element_container
{
typedef is_element_container<Type> type;
- static const bool value =
- mpl::and_<is_set<Type>, mpl::not_<is_interval_container<Type> > >::value;
+ static const bool value =
+ mpl::and_<is_set<Type>, mpl::not_<is_interval_container<Type> > >::value;
};
- template<class Type>
- struct is_element_map
- {
- typedef is_element_map<Type> type;
- static const bool value =
- mpl::and_<is_map<Type>, mpl::not_<is_interval_container<Type> > >::value;
- };
+ template<class Type>
+ struct is_element_map
+ {
+ typedef is_element_map<Type> type;
+ static const bool value =
+ mpl::and_<is_map<Type>, mpl::not_<is_interval_container<Type> > >::value;
+ };
}} // namespace boost itl
Modified: sandbox/itl/boost/itl/type_traits/is_interval_container.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_interval_container.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_interval_container.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -16,21 +16,21 @@
static const bool value = false;
};
- template<class Type>
- struct is_interval_map
- {
- typedef is_interval_map<Type> type;
- static const bool value =
- is_interval_container<Type>::value && is_map<Type>::value;
- };
-
- template<class Type>
- struct is_interval_set
- {
- typedef is_interval_set<Type> type;
- static const bool value =
- is_interval_container<Type>::value && !is_interval_map<Type>::value;
- };
+ template<class Type>
+ struct is_interval_map
+ {
+ typedef is_interval_map<Type> type;
+ static const bool value =
+ is_interval_container<Type>::value && is_map<Type>::value;
+ };
+
+ template<class Type>
+ struct is_interval_set
+ {
+ typedef is_interval_set<Type> type;
+ static const bool value =
+ is_interval_container<Type>::value && !is_interval_map<Type>::value;
+ };
}} // namespace boost itl
Modified: sandbox/itl/boost/itl_xt/itvgentor.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/itvgentor.hpp (original)
+++ sandbox/itl/boost/itl_xt/itvgentor.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -47,7 +47,7 @@
public:
virtual void some(ItvTV& x);
- void setRange(const itl::interval<ItvDomTV>& range)
+ void setRange(const itl::interval<ItvDomTV>& range)
{ m_valueRange = range; }
void setValueRange(ItvDomTV low, ItvDomTV up)
Modified: sandbox/itl/boost/itl_xt/list.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/list.hpp (original)
+++ sandbox/itl/boost/itl_xt/list.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -138,7 +138,7 @@
sublist in the list \c super */
bool contained_in(const list& super)const { return is_subsequence(super); }
- size_t iterative_size()const{ return size(); }
+ size_t iterative_size()const{ return size(); }
//JODO concept InplaceAddable
/// Add a list \c tail to this list.
@@ -424,7 +424,7 @@
if(it == end()) return std::string("");
else
{
- std::string y = "{"+to_string<DataT>::apply(*it);
+ std::string y = "{"+to_string<DataT>::apply(*it);
it++;
while(it != end())
{
@@ -432,17 +432,17 @@
y += to_string<DataT>::apply(*it);
it++;
}
- y += "}";
+ y += "}";
return y;
}
}
- template <class Type>
- struct type_to_string<itl::list<Type> >
- {
- static std::string apply()
- { return "list<"+ type_to_string<Type>::apply() +">"; }
- };
+ template <class Type>
+ struct type_to_string<itl::list<Type> >
+ {
+ static std::string apply()
+ { return "list<"+ type_to_string<Type>::apply() +">"; }
+ };
}} // namespace itl boost
Modified: sandbox/itl/boost/validate/gentor/gentorprofile.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/gentorprofile.hpp (original)
+++ sandbox/itl/boost/validate/gentor/gentorprofile.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -137,7 +137,7 @@
void set_std_profile(int unit, int factor) { return m_profile.set_std_profile(unit, factor); }
void set_polygon_profile(int max_polygon_set_size, int max_polygon_size, int min_coord, int max_coord)
- { return m_profile.set_polygon_profile(max_polygon_set_size, max_polygon_size, min_coord, max_coord); }
+ { return m_profile.set_polygon_profile(max_polygon_set_size, max_polygon_size, min_coord, max_coord); }
private:
Modified: sandbox/itl/boost/validate/gentor/randomgentor.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/randomgentor.hpp (original)
+++ sandbox/itl/boost/validate/gentor/randomgentor.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -40,9 +40,9 @@
template <> class RandomGentor<double> : public NumberGentorT<double> {};
// -------------------------------------------------------------------------
- template <class DomainT>
- class RandomGentor<itl::interval<DomainT> > :
- public ItvGentorT<DomainT> {};
+ template <class DomainT>
+ class RandomGentor<itl::interval<DomainT> > :
+ public ItvGentorT<DomainT> {};
#ifdef LAW_BASED_TEST_BOOST_POLYGON
// -------------------------------------------------------------------------
@@ -179,7 +179,7 @@
template <>
- struct Calibrater<itl::interval<int>, RandomGentor>
+ struct Calibrater<itl::interval<int>, RandomGentor>
{
static void apply(RandomGentor<itl::interval<int> >& gentor)
{
@@ -190,11 +190,11 @@
#ifdef LAW_BASED_TEST_BOOST_POLYGON
- //--------------------------------------------------------------------------
- // boost::polygon
- //--------------------------------------------------------------------------
+ //--------------------------------------------------------------------------
+ // boost::polygon
+ //--------------------------------------------------------------------------
template <>
- struct Calibrater<itl::point<int>, RandomGentor>
+ struct Calibrater<itl::point<int>, RandomGentor>
{
static void apply(RandomGentor<itl::point<int> >& gentor)
{
@@ -204,39 +204,39 @@
};
template <>
- struct Calibrater<itl::list<point<int> >, RandomGentor>
+ struct Calibrater<itl::list<point<int> >, RandomGentor>
{
static void apply(RandomGentor<itl::list<point<int> > >& gentor)
{
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_codomain_ContainerSize());
- point_gentor<int>* pointGentor = new point_gentor<int>;
+ point_gentor<int>* pointGentor = new point_gentor<int>;
pointGentor->setRange(GentorProfileSgl::it()->range_int());
gentor.setDomainGentor(pointGentor);
- gentor.setUnique(true);
+ gentor.setUnique(true);
}
};
template <>
- struct Calibrater<itl::list<list<point<int> > >, RandomGentor>
+ struct Calibrater<itl::list<list<point<int> > >, RandomGentor>
{
static void apply(RandomGentor<itl::list<list<point<int> > > >& gentor)
{
- point_gentor<int>* pointGentor = new point_gentor<int>;
+ point_gentor<int>* pointGentor = new point_gentor<int>;
pointGentor->setRange(GentorProfileSgl::it()->range_int());
- polygon_gentor<list<point<int> > >* polyGentor = new polygon_gentor<list<point<int> > >;
+ polygon_gentor<list<point<int> > >* polyGentor = new polygon_gentor<list<point<int> > >;
polyGentor->setDomainGentor(pointGentor);
polyGentor->setRangeOfSampleSize(GentorProfileSgl::it()->range_codomain_ContainerSize());
- polyGentor->setUnique(true);
+ polyGentor->setUnique(true);
gentor.setDomainGentor(polyGentor);
gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
}
};
- //--------------------------------------------------------------------------
- // nogylop::tsoob
- //--------------------------------------------------------------------------
+ //--------------------------------------------------------------------------
+ // nogylop::tsoob
+ //--------------------------------------------------------------------------
#endif // LAW_BASED_TEST_BOOST_POLYGON
template <>
Modified: sandbox/itl/boost/validate/laws/minor_set_laws.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/minor_set_laws.hpp (original)
+++ sandbox/itl/boost/validate/laws/minor_set_laws.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -39,56 +39,56 @@
bool holds()
{
- // is_total<T> || intersects(a, b) == !(a & b).empty()
+ // is_total<T> || intersects(a, b) == !(a & b).empty()
// --- left hand side ------------------------
bool a_intersects_b
- = intersects(this->template getInputValue<operand_a>(),
- this->template getInputValue<operand_b>());
+ = intersects(this->template getInputValue<operand_a>(),
+ this->template getInputValue<operand_b>());
// --- right hand side ------------------------
- Type a_sec_b = this->template getInputValue<operand_a>();
- a_sec_b &= this->template getInputValue<operand_b>();
+ Type a_sec_b = this->template getInputValue<operand_a>();
+ a_sec_b &= this->template getInputValue<operand_b>();
- bool a_sec_b_non_empty = !a_sec_b.empty();
+ bool a_sec_b_non_empty = !a_sec_b.empty();
this->template setOutputValue<lhs_result>(a_intersects_b);
this->template setOutputValue<rhs_result>(a_sec_b_non_empty);
- if(is_total<Type>::value)
- // For a total map y, y.empty() does not mean that y is empty
- // it means that y is a null vector. In this sense total maps
- // always intersect with themselves and with key sets.
- return a_intersects_b == true;
- else
- return a_intersects_b == a_sec_b_non_empty;
- }
+ if(is_total<Type>::value)
+ // For a total map y, y.empty() does not mean that y is empty
+ // it means that y is a null vector. In this sense total maps
+ // always intersect with themselves and with key sets.
+ return a_intersects_b == true;
+ else
+ return a_intersects_b == a_sec_b_non_empty;
+ }
bool debug_holds()
- {
- // intersects(a, b) == !(a & b).empty() : Definition of intersects predicate
+ {
+ // intersects(a, b) == !(a & b).empty() : Definition of intersects predicate
// --- left hand side ------------------------
- Type value_a = this->template getInputValue<operand_a>();
- Type value_b = this->template getInputValue<operand_b>();
- cout << "a = " << value_a << endl;
- cout << "b = " << value_b << endl;
- cout << "a&b = " << (value_a & value_b) << endl;
+ Type value_a = this->template getInputValue<operand_a>();
+ Type value_b = this->template getInputValue<operand_b>();
+ cout << "a = " << value_a << endl;
+ cout << "b = " << value_b << endl;
+ cout << "a&b = " << (value_a & value_b) << endl;
bool a_intersects_b
- = intersects(this->template getInputValue<operand_a>(),
- this->template getInputValue<operand_b>());
+ = intersects(this->template getInputValue<operand_a>(),
+ this->template getInputValue<operand_b>());
// --- right hand side ------------------------
- Type a_sec_b = this->template getInputValue<operand_a>();
- a_sec_b &= this->template getInputValue<operand_b>();
+ Type a_sec_b = this->template getInputValue<operand_a>();
+ a_sec_b &= this->template getInputValue<operand_b>();
- bool a_sec_b_non_empty = !a_sec_b.empty();
+ bool a_sec_b_non_empty = !a_sec_b.empty();
this->template setOutputValue<lhs_result>(a_intersects_b);
this->template setOutputValue<rhs_result>(a_sec_b_non_empty);
- if(is_total<Type>::value)
- return a_intersects_b == true;
- else
- return a_intersects_b == a_sec_b_non_empty;
- }
+ if(is_total<Type>::value)
+ return a_intersects_b == true;
+ else
+ return a_intersects_b == a_sec_b_non_empty;
+ }
size_t size()const
{
@@ -119,29 +119,29 @@
bool holds()
{
- // a.contains(a & b)
- Type value_a = this->template getInputValue<operand_a>();
- CoType value_b = this->template getInputValue<operand_b>();
- return value_a.contains(value_a & value_b);
- }
+ // a.contains(a & b)
+ Type value_a = this->template getInputValue<operand_a>();
+ CoType value_b = this->template getInputValue<operand_b>();
+ return value_a.contains(value_a & value_b);
+ }
bool debug_holds()
- {
- // a.contains(a & b)
- Type value_a = this->template getInputValue<operand_a>();
- CoType value_b = this->template getInputValue<operand_b>();
- Type a_sec_b = value_a & value_b;
- bool result = value_a.contains(value_a & value_b);
+ {
+ // a.contains(a & b)
+ Type value_a = this->template getInputValue<operand_a>();
+ CoType value_b = this->template getInputValue<operand_b>();
+ Type a_sec_b = value_a & value_b;
+ bool result = value_a.contains(value_a & value_b);
// -------------------------------------------
- cout << "a = " << value_a << endl;
- cout << "b = " << value_b << endl;
- cout << "a&b = " << a_sec_b << endl;
- cout << "a.contains(a&b) = " << result << endl;
+ cout << "a = " << value_a << endl;
+ cout << "b = " << value_b << endl;
+ cout << "a&b = " << a_sec_b << endl;
+ cout << "a.contains(a&b) = " << result << endl;
// -------------------------------------------
- value_a.contains(a_sec_b);
+ value_a.contains(a_sec_b);
- return result;
- }
+ return result;
+ }
size_t size()const
{
@@ -174,31 +174,31 @@
bool holds()
{
// (a + i).contains(i)
- Type value_a = this->template getInputValue<operand_a>();
- CoType value_i = this->template getInputValue<operand_b>();
- return (value_a + value_i).contains(value_i);
- }
+ Type value_a = this->template getInputValue<operand_a>();
+ CoType value_i = this->template getInputValue<operand_b>();
+ return (value_a + value_i).contains(value_i);
+ }
bool debug_holds()
- {
- return holds();
- /*
- // a.contains(a & b)
- Type value_a = this->template getInputValue<operand_a>();
- CoType value_b = this->template getInputValue<operand_b>();
- Type a_sec_b = value_a & value_b;
- bool result = value_a.contains(value_a & value_b);
- // -------------------------------------------
- cout << "a = " << value_a << endl;
- cout << "b = " << value_b << endl;
- cout << "a&b = " << a_sec_b << endl;
- cout << "a.contains(a&b) = " << result << endl;
- // -------------------------------------------
- value_a.contains(a_sec_b);
-
- return result;
- */
- }
+ {
+ return holds();
+ /*
+ // a.contains(a & b)
+ Type value_a = this->template getInputValue<operand_a>();
+ CoType value_b = this->template getInputValue<operand_b>();
+ Type a_sec_b = value_a & value_b;
+ bool result = value_a.contains(value_a & value_b);
+ // -------------------------------------------
+ cout << "a = " << value_a << endl;
+ cout << "b = " << value_b << endl;
+ cout << "a&b = " << a_sec_b << endl;
+ cout << "a.contains(a&b) = " << result << endl;
+ // -------------------------------------------
+ value_a.contains(a_sec_b);
+
+ return result;
+ */
+ }
size_t size()const
{
Modified: sandbox/itl/libs/itl/doc/concepts.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/concepts.qbk (original)
+++ sandbox/itl/libs/itl/doc/concepts.qbk 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -8,6 +8,49 @@
[section Concepts]
+[section Naming]
+
+The *itl* is about sets and maps and a useful
+implementation of sets and maps usings intervals.
+In the documentation of the *itl* the different
+set and map types are grouped in various ways.
+In order to distinguish those groups we use
+a naming convention.
+
+Names of concepts start with a capital letter.
+So `Set` and `Map` stand for the concepts of
+a set and a map as defined in the *itl*.
+When we talk about `Sets` and `Maps` though,
+most of the time we do not not talk about the
+concepts themselves but the set of types
+that implement those concepts in the *itl*.
+The main groups ['*itl containers*] can be
+devided in are summarized in the next table:
+
+[table
+[[] [] [] ]
+[[] [`Set`] [`Map`] ]
+[[element container] [__itl_set__] [__itl_map__]]
+[[interval container][__itv_set__, __sep_itv_set__, __spl_itv_set__][__itv_map__, __spl_itv_map__]]
+]
+
+* Containers __itl_set__, __itv_set__, __sep_itv_set__, __spl_itv_set__
+ are models of concept `Set`.
+* Containers __itl_map__, __itv_map__, __spl_itv_map__
+ are models of concept `Map`.
+* Containers that are ['*implemented*] using elements or element value pairs
+ are called ['*element containers*].
+* Containers that are ['*implemented*] using intervals or interval value pairs
+ (also called segments) are called ['*interval containers*].
+* When we talk about `Sets` or `Maps` we abstract from the way they are implemented.
+* When we talk about /element containers/ or /interval containers/
+ we refer to the way they are implemented.
+* The *itl's* element containers
+ are always denoted qualified as __itl_set__ of __itl_map__
+ to avoid confusion with `std::set` and `std::map`.
+
+[endsect][/ Naming]
+
[section Aspects]
There are two major ['*aspects*] or ['*views*] of itl containers. The first and predominant
@@ -104,11 +147,11 @@
[[empty map ] [] [`Map::Map()`] ]
[[subset relation] [] [`bool Map::contained_in(const Map& s2)const`] ]
[[equality ] [] [`bool is_element_equal(const Map& s1, const Map& s2)`]]
-[[set union] [inplace][`Map& operator += (Map& s1, const Map& s2)`] ]
+[[map union] [inplace][`Map& operator += (Map& s1, const Map& s2)`] ]
[[] [] [`Map operator + (const Map& s1, const Map& s2)`]]
-[[set difference] [inplace][`Map& operator -= (Map& s1, const Map& s2)`] ]
+[[map difference] [inplace][`Map& operator -= (Map& s1, const Map& s2)`] ]
[[] [] [`Map operator - (const Map& s1, const Map& s2)`]]
-[[set intersection][inplace][`Map& operator &= (Map& s1, const Map& s2)`] ]
+[[map intersection][inplace][`Map& operator &= (Map& s1, const Map& s2)`] ]
[[] [] [`Map operator & (const Map& s1, const Map& s2)`]]
]
@@ -128,7 +171,7 @@
[section Addability, Subtractability and Aggregate on Overlap]
While ['*addition*] and ['*subtraction*] on `Sets`
-are implemented as ['*set union*] and ['*set difference],
+are implemented as ['*set union*] and ['*set difference*],
for `Maps` we want to implement ['*aggregation*] on
the associated values for the case of collision (of key elements)
or overlap (of key intervals), which has been refered to as
Modified: sandbox/itl/libs/itl/doc/examples.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/examples.qbk (original)
+++ sandbox/itl/libs/itl/doc/examples.qbk 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -64,12 +64,10 @@
As time goes by, groups of people join the party and leave later in the evening.
So we add a time interval and a name set to the __itv_map__ for the attendance
of each group of people, that come together and leave together.
-
On every overlap of intervals, the corresponding name sets are accumulated. At
the points of overlap the intervals are split. The accumulation of content
is done via an operator += that has to be implemented
for the content parameter of the __itv_map__.
-
Finally the interval_map contains the history of attendance and all points in
time, where the group of party guests changed.
@@ -77,7 +75,6 @@
['*aggregate on overlap (aggrovering)*]:
On insertion a value associated to the interval is aggregated with those
values in the interval_map that overlap with the inserted value.
-
There are two behavioral aspects to ['*aggrovering*]: a ['*decompositional
behavior*] and an ['*accumulative behavior*].
@@ -89,12 +86,29 @@
an insertion for the associated values.
The aggregation function is += by default. Different aggregations can
-be used, if desired. In the example the history of the tallest party guest's
-height is calculated using [classref boost::itl::inplace_max inplace_max]
-as aggregation function.
+be used, if desired.
+
[example_boost_party]
-[endsect]
+
+[caution
+
+We are introducing __itv_maps__ using an
+['interval map ['*of sets of strings*]],
+because of it's didactical advantages. The party example is
+used to give an immediate and depictive access to the basic ideas of
+interval maps and /aggregate on overlap/.
+For real world applications, an interval_map of sets is
+not necessarily recommended.
+It has the same efficiency problems as
+a `std::map` of `std::sets`.
+There is a big realm though of using
+interval_maps with numerical and other
+efficient codomain types.
+]
+
+[endsect] [/ Party]
+
[section Interval]
Modified: sandbox/itl/libs/itl/doc/functions.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions.qbk 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -25,7 +25,6 @@
refer to this section that describes the polymorphic function families of the itl
in detail.
-[/ JODO placeholders again]
[h5 Placeholders]
For a concise representation the same __eiS_phs__ will be used that have been
@@ -34,11 +33,10 @@
[h5 More specific function documentation]
This section covers the most important polymorphical and namespace global
-functions of the *itl*. More specific functions are may be looked up
+functions of the *itl*. More specific functions can be looked up
in the doxygen generated
[link interval_template_library_reference reference documentation].
-[/ JODO introducing overload tables. ==========================================]
[section Overload tables]
Many of the *itl's* functions are overloaded for
@@ -87,7 +85,6 @@
[endsect][/ Overload tables]
-[/ JODO Si Mj and segmentational fineness. ====================================]
[section Segmentational Fineness]
For overloading tables on infix operators, we need to
@@ -105,7 +102,7 @@
The indices *i* of *Si* and *Mi* represent a property
called ['*segmentational fineness*] or short ['*fineness*],
-which is a ['*type trait] on interval containers.
+which is a ['*type trait*] on interval containers.
[table
[[]]
@@ -180,7 +177,6 @@
[endsect][/ Segmentational Fineness]
-[/ JODO introducing key types. ================================================]
[section Key Types]
In an *stl* map `map<K,D>` the first parameter type of the map
@@ -201,8 +197,8 @@
[[__s: __itl_set__ ][ ][ interval map ]]
]
-__biLSubtraction__, __biLerasure__, __biLintersection__,
-which is a generalized find
+__biLSubtraction__, __biLerasure__, __biLintersection__
+[/ , which is a generalized find ]
and __biLcontainedness__ predicates
can be used with those kinds of key types.
For instance, the overload table for intersection
Modified: sandbox/itl/libs/itl/doc/functions_addition.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_addition.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_addition.qbk 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -23,10 +23,30 @@
Functions and operators that implement ['*Addition*] on *itl* objects
are given in the table above.
-
-[note `operator |=` and `operator |` are implemented just as `operator +=` and `operator +`.
+`operator |=` and `operator |` are identical to `operator +=` and `operator +`.
This is a redundancy that has been introduced deliberately, because
a /set union/ semantics is often attached `operators |=` and `|`.
+
+[table
+[[] [Description of Addition]]
+[[`Sets`][Addition on Sets implements ['*set union*]]]
+[[`Maps`][Addition on Maps implements a ['*map union*] function similar to /set union/.
+ If, on insertion of an element value pair `(k,v)` it's key `k` is in the map
+ already, the addition function is propagated to the associated value.
+ This functionality has been introduced as /aggregate on collision/
+ for element maps and /aggregate on overlap/ for interval maps.
+
+ Find more on
+ [link boost_itl.concepts.addability__subtractability_and_aggregate_on_overlap ['addability of maps]]
+ and related
+ [link boost_itl.semantics.maps ['semantical issues]]
+ following the links.
+
+ Examples, demonstrating Addition on interval containers are
+ [link boost_itl.examples.overlap_counter ['overlap counter]],
+ [link boost_itl.examples.party ['party]] and
+ [link boost_itl.examples.partys_height_average ['party's height average.]]
+ ]]
]
[endsect][/ Synopsis]
Modified: sandbox/itl/libs/itl/doc/functions_equivs_orderings.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_equivs_orderings.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_equivs_orderings.qbk 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -42,7 +42,7 @@
the equality of template parameter `Compare`.
Equality and compare operators are defined for all *itl*
-objects but there are no overload between different types.
+objects but there are no overloads between different types.
Containers of different segmentation are different,
even if their elements are the same:
@@ -104,7 +104,7 @@
two maps are sequential element equal except for value
pairs whose associated values are neutral elements.
-[*Complexity] is linear is the `iterative_size` of the
+[*Complexity] is linear in the `iterative_size` of the
larger container to compare.
[endsect]
Modified: sandbox/itl/libs/itl/doc/functions_erasure.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_erasure.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_erasure.qbk 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -22,15 +22,16 @@
[h5 Erasure]
-[/ JODO Does not apply to iterator based erasure]
The effects of ['*erasure*] implemented by `erase` and ['*subtraction*]
implemented by `subtract` and `operator -=` are identical for all Set-types of
the *itl*.
For Map-types, `erase` provides the *stl* semantics of erasure in
-contrast to `add` and `operator +=`, that implement a generalized subtraction,
-that performs inverse aggregations if key values collode or key intervals overlap.
+contrast to `subtract` and `operator -=`, that implement a generalized subtraction,
+that performs inverse aggregations if key values collide or key intervals overlap.
+Using iterators it is possible to erase objects or ranges of
+objects the iterator is pointing at from itl Sets and Maps.
[endsect][/ Synopsis Erasure]
@@ -71,7 +72,7 @@
element containers: interval containers:
erase | e b s m erase | e i b p S M
- ---+-------- ---+------------
+------+-------- ------+------------
s | s s S | S S S
m | m m m m M | M M M M M M
``
Modified: sandbox/itl/libs/itl/doc/functions_insertion.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_insertion.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_insertion.qbk 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -27,7 +27,7 @@
For Map-types, `insert` provides the *stl* semantics of insertion in
contrast to `add` and `operator +=`, that implement a generalized addition,
-that performs aggregations if key values collode or key intervals overlap.
+that performs aggregations if key values collide or key intervals overlap.
`insert` on Maps does not alter a maps content at the points, where
the keys of the object to inserted overlap or collide with keys that
are already in the map.
Modified: sandbox/itl/libs/itl/doc/functions_intersection.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_intersection.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_intersection.qbk 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -22,6 +22,32 @@
Functions and operators that implement ['*intersection*] on *itl* objects
are given in the table above.
+
+[table
+[[] [Description of Intersection]]
+[[`Sets`][Intersection on Sets implements ['*set intersection*]]]
+[[`Maps`][Intersection on Maps implements a ['*map intersection*] function similar to /set intersection/.
+ If, on intersection, an element value pair `(k,v)` it's key `k` is in the map
+ already, the intersection function is propagated to the associated value,
+ if it exists for the Map's codomain_type.
+
+ If the codomain_type has no intersection operation, associated
+ values are combined using addition. For partial map types this
+ results in an addition on the intersection of the domains of
+ the intersected sets. For total maps intersection and
+ addition are identical in this case.
+
+ See also
+ [link boost_itl.semantics.quantifiers__maps_of_numbers.intersection_on_quantifiers ['intersection on Maps of numbers]].
+
+ A Map can be intersected with key types: an element
+ (an interval for interval_maps) and and a Set. This
+ results in the selection of a submap, and can be
+ defined as a generalized selection function on Maps.
+ ]]
+]
+
+
[endsect][/ Synopsis Intersection]
Modified: sandbox/itl/libs/itl/doc/functions_streaming.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_streaming.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_streaming.qbk 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -12,10 +12,17 @@
[table
[[['*Streaming, conversion*]] [interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map] ]
-[[`std::basic_ostream operator << (...)`] [1] [1] [1] [1] [1] ]
+[[`std::basic_ostream operator << (basic_ostream&, const T&)`] [1] [1] [1] [1] [1] ]
[[`std::string T::as_string()`] [1] [1] [1] [1] [1] ]
]
+[table
+[[['*Streaming, conversion*]] [Desctription] ]
+[[`std::basic_ostream operator << (basic_ostream&, const T&)`]
+ [Serializes the argument of type T to an output stream] ]
+[[`std::string T::as_string()`] [Returns a string representation of the object of type `T`]]
+]
+
[endsect][/ Streaming, conversion]
Modified: sandbox/itl/libs/itl/doc/functions_subtraction.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_subtraction.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_subtraction.qbk 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -22,6 +22,25 @@
Functions and operators that implement ['*Subtraction*] on *itl* objects
are given in the table above.
+[table
+[[] [Description of Subtraction]]
+[[`Sets`][Subtraction on Sets implements ['*set difference*]]]
+[[`Maps`][Subtraction on Maps implements a ['*map difference*] function similar to /set difference/.
+ If, on subtraction of an element value pair `(k,v)` it's key `k` is in the map
+ already, the subtraction function is propagated to the associated value.
+ On the associated value an aggregation is performed, that reverses
+ the effect of the corresponding addition function.
+
+ Find more on
+ [link boost_itl.concepts.addability__subtractability_and_aggregate_on_overlap ['subtractability of maps]]
+ and related
+ [link boost_itl.semantics.maps ['semantical issues]]
+ following the links.
+
+ ]]
+]
+
+
[endsect][/ Synopsis]
Modified: sandbox/itl/libs/itl/doc/functions_symmetric_difference.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/functions_symmetric_difference.qbk (original)
+++ sandbox/itl/libs/itl/doc/functions_symmetric_difference.qbk 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -22,6 +22,16 @@
Functions and operators that implement ['*symmetric difference*] on *itl* objects
are given in the table above.
+[table
+[[] [Description of symmetric difference]]
+[[`Sets`][`operator ^` implements ['*set symmetric difference*]]]
+[[`Maps`][`operator ^` implements a ['*map symmetric difference*]
+ function similar to /set symmetric difference/.
+ All pairs that are common to both arguments are removed. All others unified.
+ ]]
+]
+
+
[endsect][/ Synopsis Symmetric difference]
[section Member functions][/ Symmetric difference]
Modified: sandbox/itl/libs/itl/doc/interface.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/interface.qbk (original)
+++ sandbox/itl/libs/itl/doc/interface.qbk 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -123,10 +123,6 @@
std::set<string, german_compare<string> > words; // 2nd parameter is a type
``
-[/ This choice has been made, because template parameters have to be
-instantiated with different types inside itl class templates. This problem
-is described in detail in section JODO.]
-
[endsect][/ Class templates]
[section Required Concepts]
@@ -436,7 +432,7 @@
[[__biLConsCopyDest__] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
[[`T::T()`] [1] [1] [1] [1] [1] [1] [1]]
[[`T::T(const P&)`] [A] [__eiS] [__bpM] [1] [1] [1] [1]]
-[/ JODO [`T::T(...)`] [3] [ ] [ ] [3] [3] [3] [3]]
+[/ FYI [`T::T(...)`] [3] [ ] [ ] [3] [3] [3] [3]]
[[`T& T::operator=(const P&)`] [A] [__S] [__M] [1] [1] [1] [1]]
[[`void T::swap(T&)`] [ ] [1] [1] [1] [1] [1] [1]]
@@ -522,7 +518,8 @@
[[`pair<J,J> T::equal_range(const key_value&)`][ ] [2] [2] [2] [2] [2] [2]]
[[__biLStreaming__] [interval][__ch_itv_sets__][__ch_itv_maps__][itl::set][itl::map][std::set][std::map]]
-[[`std::basic_ostream operator << (...)`] [1] [1] [1] [1] [1] [1] [1]]
+[[`std::basic_ostream operator << (basic_ostream&, const T&)`]
+ [1] [1] [1] [1] [1] [1] [1]]
[[`std::string T::as_string()`] [1] [1] [1] [1] [1] [ ] [ ]]
]
Modified: sandbox/itl/libs/itl/doc/introduction.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/introduction.qbk (original)
+++ sandbox/itl/libs/itl/doc/introduction.qbk 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -8,6 +8,14 @@
[section Introduction]
+[note [* This is not an official boost library]
+
+The /Interval Template Library/ is currently submitted
+for a formal review on the boost developer's list.
+Depending on the review's result the library might or
+might not become a boost library.
+]
+
Intervals are almost ubiquitous in software development. Yet they are
very easily coded into user defined classes by a pair of numbers
so they are only /implicitly/ used most of the time. The meaning of
Modified: sandbox/itl/libs/itl/doc/semantics.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/semantics.qbk (original)
+++ sandbox/itl/libs/itl/doc/semantics.qbk 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -157,7 +157,7 @@
Commutativity<S,&,== >: S a,b; a&b == b&a
``
-[/ JODO
+[/ FYI
Neutrality has *not* been validated to avoid
additional requirements on the sets template
parameters.]
@@ -298,7 +298,7 @@
values.
This is less magical as it might seem at first glance.
-If for instance, if we instantiate an __itv_map__ to
+If, for instance, we instantiate an __itv_map__ to
collect and concatenate
`std::strings` associated to intervals,
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 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -33,44 +33,46 @@
using namespace boost::itl;
-/* A interval_map<int, int> is a map<Interval<int>, int> that maps intervals
- to int values. On overlap of intervals it sums up the associated int
- values. */
-typedef interval_map<int, int> OverlapCounterTD;
+/* The most simple example of an interval_map is an overlap counter.
+ If intervals are added that are associated with the value 1,
+ all overlaps of added intervals are counted as a result in the
+ associated values.
+*/
+typedef interval_map<int, int> OverlapCounterT;
-void print_overlaps(const OverlapCounterTD& counter)
+void print_overlaps(const OverlapCounterT& counter)
{
- for(OverlapCounterTD::const_iterator it = counter.begin(); it != counter.end(); it++)
+ for(OverlapCounterT::const_iterator it = counter.begin(); it != counter.end(); it++)
{
- interval<int> itv = (*it).first;
+ interval<int> itv = (*it).first;
int overlaps_count = (*it).second;
if(overlaps_count == 1)
- cout << "in interval " << itv.as_string() << " intervals do not overlap" << endl;
+ cout << "in interval " << itv << " intervals do not overlap" << endl;
else
- cout << "in interval " << itv.as_string() << ": "<< overlaps_count << " intervals overlap" << endl;
+ cout << "in interval " << itv << ": "<< overlaps_count << " intervals overlap" << endl;
}
}
void overlap_counter()
{
- OverlapCounterTD overlap_counter;
+ OverlapCounterT overlap_counter;
interval<int> itv;
itv = interval<int>::rightopen(4,8);
cout << "-- adding " << itv.as_string() << " -----------------------------------------" << endl;
- overlap_counter += make_pair(itv, 1);
+ overlap_counter += make_pair(interval<int>::rightopen(4,8), 1);
print_overlaps(overlap_counter);
cout << "-----------------------------------------------------------" << endl;
itv = interval<int>::rightopen(6,9);
cout << "-- adding " << itv.as_string() << " -----------------------------------------" << endl;
- overlap_counter += make_pair(itv, 1);
+ overlap_counter += make_pair(interval<int>::rightopen(6,9), 1);
print_overlaps(overlap_counter);
cout << "-----------------------------------------------------------" << endl;
itv = interval<int>::rightopen(1,9);
cout << "-- adding " << itv.as_string() << " -----------------------------------------" << endl;
- overlap_counter += make_pair(itv, 1);
+ overlap_counter += make_pair(interval<int>::rightopen(1,9), 1);
print_overlaps(overlap_counter);
cout << "-----------------------------------------------------------" << endl;
Modified: sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp (original)
+++ sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -45,51 +45,51 @@
const bool test = is_same<SplitIntervalSetT::key_type, SplitIntervalSetT::interval_type>::value;
BOOST_CHECK_EQUAL(test, true);
- SplitIntervalSetT spliss;
- spliss.add(I_D(1,3)).add(I_D(3,4)).add(I_D(4,6)).add(I_D(6,8));
- spliss.contains(I_D(2,5));
+ SplitIntervalSetT spliss;
+ spliss.add(I_D(1,3)).add(I_D(3,4)).add(I_D(4,6)).add(I_D(6,8));
+ spliss.contains(I_D(2,5));
BOOST_CHECK_EQUAL(spliss.contains(I_D(2,7)), true);
-
- ItlMapT map_a(make_pair(1,1));
- ItlSetT set_a(1);
- map_a.add(make_pair(2,1));
- set_a.add(2);
- bool its = Map::intersects(map_a, map_a);
-
- erase(map_a, set_a);
- BOOST_CHECK_EQUAL(erase(map_a, set_a), ItlMapT());
- BOOST_CHECK_EQUAL(erase(map_a, map_a), ItlMapT());
-
- itl::map<int,int,total_absorber> tomp_a, tomp_b, tomp_c;
- tomp_a.add(make_pair(1,1)).add(make_pair(2,1));
-
- BOOST_CHECK_EQUAL((tomp_a & tomp_b).empty(), false);
- BOOST_CHECK_EQUAL((tomp_b & tomp_c).empty(), true);
-
- interval_map<int, interval_set<int> > maose, maose2;
- interval_set<int> inse;
- inse.add(I_I(1,4));
-
- maose.add(make_pair(I_I(1,4), inse));
- maose2 = maose;
- maose2.add(make_pair(I_I(5,6), inse));
-
-
- BOOST_CHECK_EQUAL(maose2.contains(maose), true);
-
- itl::set<int> eleset_a, eleset_a2, eleset_b, eleset_c;
- //eleset_a.add(1).add(2).add(5).add(8).add(11);
- eleset_a.add(8).add(11);
- eleset_a2 = eleset_a;
- eleset_b.add(8).add(2).add(11);
- eleset_c.add(9);
-
- //BOOST_CHECK_EQUAL(Set::inclusion_compare(eleset_a, eleset_a2), inclusion::equal);
- //BOOST_CHECK_EQUAL(Set::inclusion_compare(eleset_a, eleset_b), inclusion::superset);
- //BOOST_CHECK_EQUAL(Set::inclusion_compare(eleset_b, eleset_a), inclusion::subset);
+
+ ItlMapT map_a(make_pair(1,1));
+ ItlSetT set_a(1);
+ map_a.add(make_pair(2,1));
+ set_a.add(2);
+ bool its = Map::intersects(map_a, map_a);
+
+ erase(map_a, set_a);
+ BOOST_CHECK_EQUAL(erase(map_a, set_a), ItlMapT());
+ BOOST_CHECK_EQUAL(erase(map_a, map_a), ItlMapT());
+
+ itl::map<int,int,total_absorber> tomp_a, tomp_b, tomp_c;
+ tomp_a.add(make_pair(1,1)).add(make_pair(2,1));
+
+ BOOST_CHECK_EQUAL((tomp_a & tomp_b).empty(), false);
+ BOOST_CHECK_EQUAL((tomp_b & tomp_c).empty(), true);
+
+ interval_map<int, interval_set<int> > maose, maose2;
+ interval_set<int> inse;
+ inse.add(I_I(1,4));
+
+ maose.add(make_pair(I_I(1,4), inse));
+ maose2 = maose;
+ maose2.add(make_pair(I_I(5,6), inse));
+
+
+ BOOST_CHECK_EQUAL(maose2.contains(maose), true);
+
+ itl::set<int> eleset_a, eleset_a2, eleset_b, eleset_c;
+ //eleset_a.add(1).add(2).add(5).add(8).add(11);
+ eleset_a.add(8).add(11);
+ eleset_a2 = eleset_a;
+ eleset_b.add(8).add(2).add(11);
+ eleset_c.add(9);
+
+ //BOOST_CHECK_EQUAL(Set::inclusion_compare(eleset_a, eleset_a2), inclusion::equal);
+ //BOOST_CHECK_EQUAL(Set::inclusion_compare(eleset_a, eleset_b), inclusion::superset);
+ //BOOST_CHECK_EQUAL(Set::inclusion_compare(eleset_b, eleset_a), inclusion::subset);
- inclusion_compare(eleset_a, eleset_c);
- BOOST_CHECK_EQUAL(inclusion_compare(eleset_a, eleset_c), inclusion::unrelated);
+ inclusion_compare(eleset_a, eleset_c);
+ BOOST_CHECK_EQUAL(inclusion_compare(eleset_a, eleset_c), inclusion::unrelated);
}
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 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -204,243 +204,243 @@
template <class T, class U, class Trt>
void partial_interval_map_mixed_inclusion_compare_4_bicremental_types()
{
- typedef interval_map<T,U,Trt> IntervalMapT;
- //--------------------------------------------------------------------------
- // equalities
- // { 0 1 2 3 4 5 8 9 }
- // {[0,2)[2,3](3,6) (7,9]}
- // ->2 ->1 ->1 ->2
- split_interval_map<T,U,Trt> split_map;
- interval_map<T,U,Trt> join_map;
- split_interval_set<T> split_set;
- separate_interval_set<T> sep_set;
- interval_set<T> join_set;
-
- split_map.add(IDv(0,2,2)).add(IIv(2,3,1)).add(CDv(3,6,1)).add(CIv(7,9,2));
- join_map = split_map;
- split_map.domain(split_set);
- split_map.domain(sep_set);
- split_map.domain(join_set);
-
- BOOST_CHECK_EQUAL( split_map.iterative_size(), 4 );
- BOOST_CHECK_EQUAL( join_map.iterative_size(), 3 );
- BOOST_CHECK_EQUAL( split_set.iterative_size(), 4 );
- BOOST_CHECK_EQUAL( sep_set.iterative_size(), 4 );
- BOOST_CHECK_EQUAL( join_set.iterative_size(), 2 );
-
- BOOST_CHECK_EQUAL( inclusion_compare(split_map, join_map), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(join_map, split_map), inclusion::equal );
-
- BOOST_CHECK_EQUAL( inclusion_compare(split_map, split_set), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(split_map, sep_set ), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(split_map, join_set ), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(join_map , split_set), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(join_map , sep_set ), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(join_map , join_set ), inclusion::equal );
-
- BOOST_CHECK_EQUAL( inclusion_compare(split_set, split_map), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(sep_set , split_map), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(join_set , split_map), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(split_set, join_map ), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(sep_set , join_map ), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(join_set , join_map ), inclusion::equal );
-
- //--------------------------------------------------------------------------
- // inclusions
- // { 0 1 2 3 4 5 8 9 }
- // {[0, 2)[2, 3](3, 6) (7, 9]}
- // ->2 ->1 ->1 ->2
- // {[0, 2) [3,3](3, 6) (7, 9]}
- // ->2 ->1 ->1 ->2
+ typedef interval_map<T,U,Trt> IntervalMapT;
+ //--------------------------------------------------------------------------
+ // equalities
+ // { 0 1 2 3 4 5 8 9 }
+ // {[0,2)[2,3](3,6) (7,9]}
+ // ->2 ->1 ->1 ->2
+ split_interval_map<T,U,Trt> split_map;
+ interval_map<T,U,Trt> join_map;
+ split_interval_set<T> split_set;
+ separate_interval_set<T> sep_set;
+ interval_set<T> join_set;
+
+ split_map.add(IDv(0,2,2)).add(IIv(2,3,1)).add(CDv(3,6,1)).add(CIv(7,9,2));
+ join_map = split_map;
+ split_map.domain(split_set);
+ split_map.domain(sep_set);
+ split_map.domain(join_set);
+
+ BOOST_CHECK_EQUAL( split_map.iterative_size(), 4 );
+ BOOST_CHECK_EQUAL( join_map.iterative_size(), 3 );
+ BOOST_CHECK_EQUAL( split_set.iterative_size(), 4 );
+ BOOST_CHECK_EQUAL( sep_set.iterative_size(), 4 );
+ BOOST_CHECK_EQUAL( join_set.iterative_size(), 2 );
+
+ BOOST_CHECK_EQUAL( inclusion_compare(split_map, join_map), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(join_map, split_map), inclusion::equal );
+
+ BOOST_CHECK_EQUAL( inclusion_compare(split_map, split_set), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(split_map, sep_set ), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(split_map, join_set ), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(join_map , split_set), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(join_map , sep_set ), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(join_map , join_set ), inclusion::equal );
+
+ BOOST_CHECK_EQUAL( inclusion_compare(split_set, split_map), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(sep_set , split_map), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(join_set , split_map), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(split_set, join_map ), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(sep_set , join_map ), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(join_set , join_map ), inclusion::equal );
+
+ //--------------------------------------------------------------------------
+ // inclusions
+ // { 0 1 2 3 4 5 8 9 }
+ // {[0, 2)[2, 3](3, 6) (7, 9]}
+ // ->2 ->1 ->1 ->2
+ // {[0, 2) [3,3](3, 6) (7, 9]}
+ // ->2 ->1 ->1 ->2
split_interval_map<T,U,Trt> split_sub_map1 = split_map;
- split_sub_map1.erase(MK_v(2));
- BOOST_CHECK_EQUAL( split_sub_map1.contains(MK_v(2)), false );
+ split_sub_map1.erase(MK_v(2));
+ BOOST_CHECK_EQUAL( split_sub_map1.contains(MK_v(2)), false );
- interval_map<T,U,Trt> join_sub_map2;
- join_sub_map2 = split_map;
- join_sub_map2.erase(MK_v(1));
- BOOST_CHECK_EQUAL( join_sub_map2.contains(MK_v(1)), false );
-
- split_interval_set<T> split_sub_set1;
- separate_interval_set<T> sep_sub_set1;
- interval_set<T> join_sub_set1;
-
- split_sub_map1.domain(split_sub_set1);
- split_sub_map1.domain(sep_sub_set1);
- split_sub_map1.domain(join_sub_set1);
-
- BOOST_CHECK_EQUAL( inclusion_compare(split_sub_map1, split_map), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare( join_sub_map2, split_map), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare(split_sub_map1, join_map), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare( join_sub_map2, join_map), inclusion::subset );
-
- BOOST_CHECK_EQUAL( inclusion_compare(split_sub_set1, split_map), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare( sep_sub_set1, split_map), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare( join_sub_set1, split_map), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare(split_sub_set1, join_map), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare( sep_sub_set1, join_map), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare( join_sub_set1, join_map), inclusion::subset );
-
- BOOST_CHECK_EQUAL( inclusion_compare(split_map, split_sub_map1), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare(split_map, join_sub_map2), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare( join_map, split_sub_map1), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare( join_map, join_sub_map2), inclusion::superset );
-
- BOOST_CHECK_EQUAL( inclusion_compare(split_map, split_sub_set1), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare(split_map, sep_sub_set1), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare(split_map, join_sub_set1), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare( join_map, split_sub_set1), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare( join_map, sep_sub_set1), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare( join_map, join_sub_set1), inclusion::superset );
+ interval_map<T,U,Trt> join_sub_map2;
+ join_sub_map2 = split_map;
+ join_sub_map2.erase(MK_v(1));
+ BOOST_CHECK_EQUAL( join_sub_map2.contains(MK_v(1)), false );
+
+ split_interval_set<T> split_sub_set1;
+ separate_interval_set<T> sep_sub_set1;
+ interval_set<T> join_sub_set1;
+
+ split_sub_map1.domain(split_sub_set1);
+ split_sub_map1.domain(sep_sub_set1);
+ split_sub_map1.domain(join_sub_set1);
+
+ BOOST_CHECK_EQUAL( inclusion_compare(split_sub_map1, split_map), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare( join_sub_map2, split_map), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare(split_sub_map1, join_map), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare( join_sub_map2, join_map), inclusion::subset );
+
+ BOOST_CHECK_EQUAL( inclusion_compare(split_sub_set1, split_map), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare( sep_sub_set1, split_map), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare( join_sub_set1, split_map), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare(split_sub_set1, join_map), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare( sep_sub_set1, join_map), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare( join_sub_set1, join_map), inclusion::subset );
+
+ BOOST_CHECK_EQUAL( inclusion_compare(split_map, split_sub_map1), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare(split_map, join_sub_map2), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare( join_map, split_sub_map1), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare( join_map, join_sub_map2), inclusion::superset );
+
+ BOOST_CHECK_EQUAL( inclusion_compare(split_map, split_sub_set1), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare(split_map, sep_sub_set1), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare(split_map, join_sub_set1), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare( join_map, split_sub_set1), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare( join_map, sep_sub_set1), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare( join_map, join_sub_set1), inclusion::superset );
split_interval_map<T,U,Trt> split_unrel_map11 = split_sub_map1;
- split_unrel_map11.set(CIv(7,9,1));
- BOOST_CHECK_EQUAL( split_unrel_map11(MK_v(8)), MK_u(1) );
+ split_unrel_map11.set(CIv(7,9,1));
+ BOOST_CHECK_EQUAL( split_unrel_map11(MK_v(8)), MK_u(1) );
interval_map<T,U,Trt> join_unrel_map21 = join_sub_map2;
- join_unrel_map21.set(K_v(0,1));
- BOOST_CHECK_EQUAL( join_unrel_map21(MK_v(0)), MK_u(1) );
+ join_unrel_map21.set(K_v(0,1));
+ BOOST_CHECK_EQUAL( join_unrel_map21(MK_v(0)), MK_u(1) );
- BOOST_CHECK_EQUAL( inclusion_compare(split_unrel_map11, split_map), inclusion::unrelated );
- BOOST_CHECK_EQUAL( inclusion_compare( join_unrel_map21, split_map), inclusion::unrelated );
- BOOST_CHECK_EQUAL( inclusion_compare(split_unrel_map11, join_map), inclusion::unrelated );
- BOOST_CHECK_EQUAL( inclusion_compare( join_unrel_map21, join_map), inclusion::unrelated );
-
- BOOST_CHECK_EQUAL( inclusion_compare(split_map, split_unrel_map11), inclusion::unrelated );
- BOOST_CHECK_EQUAL( inclusion_compare(split_map, join_unrel_map21), inclusion::unrelated );
- BOOST_CHECK_EQUAL( inclusion_compare( join_map, split_unrel_map11), inclusion::unrelated );
- BOOST_CHECK_EQUAL( inclusion_compare( join_map, join_unrel_map21), inclusion::unrelated );
+ BOOST_CHECK_EQUAL( inclusion_compare(split_unrel_map11, split_map), inclusion::unrelated );
+ BOOST_CHECK_EQUAL( inclusion_compare( join_unrel_map21, split_map), inclusion::unrelated );
+ BOOST_CHECK_EQUAL( inclusion_compare(split_unrel_map11, join_map), inclusion::unrelated );
+ BOOST_CHECK_EQUAL( inclusion_compare( join_unrel_map21, join_map), inclusion::unrelated );
+
+ BOOST_CHECK_EQUAL( inclusion_compare(split_map, split_unrel_map11), inclusion::unrelated );
+ BOOST_CHECK_EQUAL( inclusion_compare(split_map, join_unrel_map21), inclusion::unrelated );
+ BOOST_CHECK_EQUAL( inclusion_compare( join_map, split_unrel_map11), inclusion::unrelated );
+ BOOST_CHECK_EQUAL( inclusion_compare( join_map, join_unrel_map21), inclusion::unrelated );
split_interval_map<T,U,Trt> split_unrel_map1 = split_sub_map1;
- split_unrel_map1.add(IDv(11,12,1));
- BOOST_CHECK_EQUAL( split_unrel_map1(MK_v(11)), MK_u(1) );
+ split_unrel_map1.add(IDv(11,12,1));
+ BOOST_CHECK_EQUAL( split_unrel_map1(MK_v(11)), MK_u(1) );
interval_map<T,U,Trt> join_unrel_map2 = join_sub_map2;
- join_unrel_map2.add(K_v(6,1));
- BOOST_CHECK_EQUAL( join_unrel_map2(MK_v(6)), MK_u(1) );
+ join_unrel_map2.add(K_v(6,1));
+ BOOST_CHECK_EQUAL( join_unrel_map2(MK_v(6)), MK_u(1) );
}
template <class T, class U, class Trt>
void partial_interval_map_mixed_contains_4_bicremental_types()
{
- typedef interval_map<T,U,Trt> IntervalMapT;
- //--------------------------------------------------------------------------
- // { 0 1 2 3 4 5 8 9 }
- // {[0,2)[2,3](3,6) (7,9]}
- // ->2 ->1 ->1 ->2
- split_interval_map<T,U,Trt> split_map;
- interval_map<T,U,Trt> join_map;
- split_interval_set<T> split_set;
- separate_interval_set<T> sep_set;
- interval_set<T> join_set;
-
- split_map.add(IDv(0,2,2)).add(IIv(2,3,1)).add(CDv(3,6,1)).add(CIv(7,9,2));
- join_map = split_map;
- split_map.domain(split_set);
- split_map.domain(sep_set);
- split_map.domain(join_set);
-
- BOOST_CHECK_EQUAL( split_map.iterative_size(), 4 );
- BOOST_CHECK_EQUAL( join_map.iterative_size(), 3 );
- BOOST_CHECK_EQUAL( split_set.iterative_size(), 4 );
- BOOST_CHECK_EQUAL( sep_set.iterative_size(), 4 );
- BOOST_CHECK_EQUAL( join_set.iterative_size(), 2 );
-
- // Key types
- BOOST_CHECK_EQUAL( split_map.contains(MK_v(0)), true );
- BOOST_CHECK_EQUAL( split_map.contains(MK_v(5)), true );
- BOOST_CHECK_EQUAL( split_map.contains(MK_v(9)), true );
-
- BOOST_CHECK_EQUAL( split_map.contains(I_D(2,3)), true );
- BOOST_CHECK_EQUAL( split_map.contains(I_D(0,6)), true );
- BOOST_CHECK_EQUAL( split_map.contains(I_D(0,7)), false );
- BOOST_CHECK_EQUAL( join_map.contains(I_D(2,3)), true );
- BOOST_CHECK_EQUAL( join_map.contains(I_D(0,6)), true );
- BOOST_CHECK_EQUAL( join_map.contains(I_D(0,7)), false );
-
- // Map types
- BOOST_CHECK_EQUAL( join_map.contains(K_v(1,2)), true );
- BOOST_CHECK_EQUAL( join_map.contains(K_v(5,1)), true );
- BOOST_CHECK_EQUAL( join_map.contains(K_v(9,2)), true );
-
- BOOST_CHECK_EQUAL( split_map.contains(IDv(2,6,1)), true );
- BOOST_CHECK_EQUAL( split_map.contains(IDv(1,6,1)), false );
- BOOST_CHECK_EQUAL( split_map.contains(IIv(8,9,2)), true );
- BOOST_CHECK_EQUAL( split_map.contains(IIv(8,9,3)), false );
- BOOST_CHECK_EQUAL( join_map.contains(IDv(2,6,1)), true );
- BOOST_CHECK_EQUAL( join_map.contains(IDv(1,6,1)), false );
- BOOST_CHECK_EQUAL( join_map.contains(IIv(8,9,2)), true );
- BOOST_CHECK_EQUAL( join_map.contains(IIv(8,9,3)), false );
-
- BOOST_CHECK_EQUAL( split_map.contains(join_map), true );
- BOOST_CHECK_EQUAL( join_map.contains(split_map), true );
- BOOST_CHECK_EQUAL( split_map.contained_in(join_map), true );
- BOOST_CHECK_EQUAL( join_map.contained_in(split_map), true );
-
- //--------------------------------------------------------------------------
- // inclusions
- // { 0 1 2 3 4 5 8 9 }
- // {[0, 2)[2, 3](3, 6) (7, 9]}
- // ->2 ->1 ->1 ->2
- // {[0, 2) [3,3](3, 6) (7, 9]}
- // ->2 ->1 ->1 ->2
+ typedef interval_map<T,U,Trt> IntervalMapT;
+ //--------------------------------------------------------------------------
+ // { 0 1 2 3 4 5 8 9 }
+ // {[0,2)[2,3](3,6) (7,9]}
+ // ->2 ->1 ->1 ->2
+ split_interval_map<T,U,Trt> split_map;
+ interval_map<T,U,Trt> join_map;
+ split_interval_set<T> split_set;
+ separate_interval_set<T> sep_set;
+ interval_set<T> join_set;
+
+ split_map.add(IDv(0,2,2)).add(IIv(2,3,1)).add(CDv(3,6,1)).add(CIv(7,9,2));
+ join_map = split_map;
+ split_map.domain(split_set);
+ split_map.domain(sep_set);
+ split_map.domain(join_set);
+
+ BOOST_CHECK_EQUAL( split_map.iterative_size(), 4 );
+ BOOST_CHECK_EQUAL( join_map.iterative_size(), 3 );
+ BOOST_CHECK_EQUAL( split_set.iterative_size(), 4 );
+ BOOST_CHECK_EQUAL( sep_set.iterative_size(), 4 );
+ BOOST_CHECK_EQUAL( join_set.iterative_size(), 2 );
+
+ // Key types
+ BOOST_CHECK_EQUAL( split_map.contains(MK_v(0)), true );
+ BOOST_CHECK_EQUAL( split_map.contains(MK_v(5)), true );
+ BOOST_CHECK_EQUAL( split_map.contains(MK_v(9)), true );
+
+ BOOST_CHECK_EQUAL( split_map.contains(I_D(2,3)), true );
+ BOOST_CHECK_EQUAL( split_map.contains(I_D(0,6)), true );
+ BOOST_CHECK_EQUAL( split_map.contains(I_D(0,7)), false );
+ BOOST_CHECK_EQUAL( join_map.contains(I_D(2,3)), true );
+ BOOST_CHECK_EQUAL( join_map.contains(I_D(0,6)), true );
+ BOOST_CHECK_EQUAL( join_map.contains(I_D(0,7)), false );
+
+ // Map types
+ BOOST_CHECK_EQUAL( join_map.contains(K_v(1,2)), true );
+ BOOST_CHECK_EQUAL( join_map.contains(K_v(5,1)), true );
+ BOOST_CHECK_EQUAL( join_map.contains(K_v(9,2)), true );
+
+ BOOST_CHECK_EQUAL( split_map.contains(IDv(2,6,1)), true );
+ BOOST_CHECK_EQUAL( split_map.contains(IDv(1,6,1)), false );
+ BOOST_CHECK_EQUAL( split_map.contains(IIv(8,9,2)), true );
+ BOOST_CHECK_EQUAL( split_map.contains(IIv(8,9,3)), false );
+ BOOST_CHECK_EQUAL( join_map.contains(IDv(2,6,1)), true );
+ BOOST_CHECK_EQUAL( join_map.contains(IDv(1,6,1)), false );
+ BOOST_CHECK_EQUAL( join_map.contains(IIv(8,9,2)), true );
+ BOOST_CHECK_EQUAL( join_map.contains(IIv(8,9,3)), false );
+
+ BOOST_CHECK_EQUAL( split_map.contains(join_map), true );
+ BOOST_CHECK_EQUAL( join_map.contains(split_map), true );
+ BOOST_CHECK_EQUAL( split_map.contained_in(join_map), true );
+ BOOST_CHECK_EQUAL( join_map.contained_in(split_map), true );
+
+ //--------------------------------------------------------------------------
+ // inclusions
+ // { 0 1 2 3 4 5 8 9 }
+ // {[0, 2)[2, 3](3, 6) (7, 9]}
+ // ->2 ->1 ->1 ->2
+ // {[0, 2) [3,3](3, 6) (7, 9]}
+ // ->2 ->1 ->1 ->2
split_interval_map<T,U,Trt> split_sub_map1 = split_map;
- split_sub_map1.erase(MK_v(2));
- BOOST_CHECK_EQUAL( split_sub_map1.contains(MK_v(2)), false );
+ split_sub_map1.erase(MK_v(2));
+ BOOST_CHECK_EQUAL( split_sub_map1.contains(MK_v(2)), false );
- interval_map<T,U,Trt> join_sub_map2;
- join_sub_map2 = split_map;
- join_sub_map2.erase(MK_v(1));
- BOOST_CHECK_EQUAL( join_sub_map2.contains(MK_v(1)), false );
-
- split_interval_set<T> split_sub_set1;
- separate_interval_set<T> sep_sub_set1;
- interval_set<T> join_sub_set1;
-
- split_sub_map1.domain(split_sub_set1);
- split_sub_map1.domain(sep_sub_set1);
- split_sub_map1.domain(join_sub_set1);
-
- BOOST_CHECK_EQUAL( split_sub_map1.contained_in(split_map), true );
- BOOST_CHECK_EQUAL( join_sub_map2.contained_in(split_map), true );
- BOOST_CHECK_EQUAL( split_sub_map1.contained_in(join_map ), true );
- BOOST_CHECK_EQUAL( join_sub_map2.contained_in(join_map ), true );
-
- BOOST_CHECK_EQUAL( split_map.contains(split_sub_map1), true );
- BOOST_CHECK_EQUAL( split_map.contains( join_sub_map2), true );
- BOOST_CHECK_EQUAL( join_map.contains(split_sub_map1), true );
- BOOST_CHECK_EQUAL( join_map.contains( join_sub_map2), true );
-
- BOOST_CHECK_EQUAL( split_map.contains(split_sub_set1), true );
- BOOST_CHECK_EQUAL( split_map.contains( sep_sub_set1), true );
- BOOST_CHECK_EQUAL( split_map.contains( join_sub_set1), true );
- BOOST_CHECK_EQUAL( join_map.contains(split_sub_set1), true );
- BOOST_CHECK_EQUAL( join_map.contains( sep_sub_set1), true );
- BOOST_CHECK_EQUAL( join_map.contains( join_sub_set1), true );
+ interval_map<T,U,Trt> join_sub_map2;
+ join_sub_map2 = split_map;
+ join_sub_map2.erase(MK_v(1));
+ BOOST_CHECK_EQUAL( join_sub_map2.contains(MK_v(1)), false );
+
+ split_interval_set<T> split_sub_set1;
+ separate_interval_set<T> sep_sub_set1;
+ interval_set<T> join_sub_set1;
+
+ split_sub_map1.domain(split_sub_set1);
+ split_sub_map1.domain(sep_sub_set1);
+ split_sub_map1.domain(join_sub_set1);
+
+ BOOST_CHECK_EQUAL( split_sub_map1.contained_in(split_map), true );
+ BOOST_CHECK_EQUAL( join_sub_map2.contained_in(split_map), true );
+ BOOST_CHECK_EQUAL( split_sub_map1.contained_in(join_map ), true );
+ BOOST_CHECK_EQUAL( join_sub_map2.contained_in(join_map ), true );
+
+ BOOST_CHECK_EQUAL( split_map.contains(split_sub_map1), true );
+ BOOST_CHECK_EQUAL( split_map.contains( join_sub_map2), true );
+ BOOST_CHECK_EQUAL( join_map.contains(split_sub_map1), true );
+ BOOST_CHECK_EQUAL( join_map.contains( join_sub_map2), true );
+
+ BOOST_CHECK_EQUAL( split_map.contains(split_sub_set1), true );
+ BOOST_CHECK_EQUAL( split_map.contains( sep_sub_set1), true );
+ BOOST_CHECK_EQUAL( split_map.contains( join_sub_set1), true );
+ BOOST_CHECK_EQUAL( join_map.contains(split_sub_set1), true );
+ BOOST_CHECK_EQUAL( join_map.contains( sep_sub_set1), true );
+ BOOST_CHECK_EQUAL( join_map.contains( join_sub_set1), true );
split_interval_map<T,U,Trt> split_unrel_map11 = split_sub_map1;
- split_unrel_map11.set(CIv(7,9,1));
- BOOST_CHECK_EQUAL( split_unrel_map11(MK_v(8)), MK_u(1) );
+ split_unrel_map11.set(CIv(7,9,1));
+ BOOST_CHECK_EQUAL( split_unrel_map11(MK_v(8)), MK_u(1) );
interval_map<T,U,Trt> join_unrel_map21 = join_sub_map2;
- join_unrel_map21.set(K_v(0,1));
- BOOST_CHECK_EQUAL( join_unrel_map21(MK_v(0)), MK_u(1) );
+ join_unrel_map21.set(K_v(0,1));
+ BOOST_CHECK_EQUAL( join_unrel_map21(MK_v(0)), MK_u(1) );
- BOOST_CHECK_EQUAL( split_unrel_map11.contains(split_map), false );
- BOOST_CHECK_EQUAL( join_unrel_map21.contains(split_map), false );
- BOOST_CHECK_EQUAL( split_unrel_map11.contains( join_map), false );
- BOOST_CHECK_EQUAL( join_unrel_map21.contains( join_map), false );
-
- BOOST_CHECK_EQUAL( split_unrel_map11.contained_in(split_map), false );
- BOOST_CHECK_EQUAL( join_unrel_map21.contained_in(split_map), false );
- BOOST_CHECK_EQUAL( split_unrel_map11.contained_in( join_map), false );
- BOOST_CHECK_EQUAL( join_unrel_map21.contained_in( join_map), false );
-
- BOOST_CHECK_EQUAL( split_map.contains(split_unrel_map11), false );
- BOOST_CHECK_EQUAL( split_map.contains( join_unrel_map21), false );
- BOOST_CHECK_EQUAL( join_map.contains(split_unrel_map11), false );
- BOOST_CHECK_EQUAL( join_map.contains( join_unrel_map21), false );
+ BOOST_CHECK_EQUAL( split_unrel_map11.contains(split_map), false );
+ BOOST_CHECK_EQUAL( join_unrel_map21.contains(split_map), false );
+ BOOST_CHECK_EQUAL( split_unrel_map11.contains( join_map), false );
+ BOOST_CHECK_EQUAL( join_unrel_map21.contains( join_map), false );
+
+ BOOST_CHECK_EQUAL( split_unrel_map11.contained_in(split_map), false );
+ BOOST_CHECK_EQUAL( join_unrel_map21.contained_in(split_map), false );
+ BOOST_CHECK_EQUAL( split_unrel_map11.contained_in( join_map), false );
+ BOOST_CHECK_EQUAL( join_unrel_map21.contained_in( join_map), false );
+
+ BOOST_CHECK_EQUAL( split_map.contains(split_unrel_map11), false );
+ BOOST_CHECK_EQUAL( split_map.contains( join_unrel_map21), false );
+ BOOST_CHECK_EQUAL( join_map.contains(split_unrel_map11), false );
+ BOOST_CHECK_EQUAL( join_map.contains( join_unrel_map21), false );
}
Modified: sandbox/itl/libs/itl/test/test_interval_map_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_shared.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -422,13 +422,23 @@
void interval_map_contains_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
+ typedef typename IntervalMapT::set_type IntervalSetT;
IntervalMapT itv_map; itv_map.add(K_v(3,1));
+ BOOST_CHECK_EQUAL( itv_map.contains(MK_v(3)), true );
BOOST_CHECK_EQUAL( itv_map.contains(K_v(3,1)), true );
BOOST_CHECK_EQUAL( IntervalMapT().add(K_v(3,1)).contains(K_v(3,1)), true );
+ BOOST_CHECK_EQUAL( IntervalMapT().add(K_v(3,1)).contains(MK_v(3)), true );
BOOST_CHECK_EQUAL( IntervalMapT().insert(K_v(3,1)).contains(K_v(3,1)), true );
itv_map.clear();
BOOST_CHECK_EQUAL( (itv_map += IIv(3,7,1)).contains(IIv(3,7,1)), true );
+ BOOST_CHECK_EQUAL( itv_map.contains(IIv(3,7,2)), false );
+ BOOST_CHECK_EQUAL( itv_map.contains(I_I(3,7)), true );
+ BOOST_CHECK_EQUAL( itv_map.contains(I_I(4,6)), true );
+ BOOST_CHECK_EQUAL( (itv_map += CIv(7,9,1)).contains(IIv(3,9,1)), true );
+ BOOST_CHECK_EQUAL( itv_map.contains(I_I(4,8)), true );
+ BOOST_CHECK_EQUAL( (itv_map += IIv(11,12,1)).contains(IIv(3,12,1)), false );
+ BOOST_CHECK_EQUAL( itv_map.contains(I_I(4,11)), false );
IntervalMapT itv_map0 = itv_map;
@@ -437,6 +447,9 @@
itv_map2.add(K_v(9,1)).add(K_v(11,1));
itv_map += itv_map2;
BOOST_CHECK_EQUAL( itv_map.contains(itv_map2), true );
+ IntervalSetT itv_set2;
+ itv_map2.domain(itv_set2);
+ BOOST_CHECK_EQUAL( itv_map.contains(itv_set2), true );
}
template <template<class T, class U,
@@ -451,29 +464,29 @@
void interval_map_contains_key_objects_4_bicremental_types()
{
typedef IntervalMap<T,U> IntervalMapT;
- typedef typename IntervalMapT::set_type IntervalSetT;
+ typedef typename IntervalMapT::set_type IntervalSetT;
IntervalMapT itv_map;
- itv_map.add(IDv(1,3,1));
+ itv_map.add(IDv(1,3,1));
BOOST_CHECK_EQUAL( itv_map.contains(MK_v(0)), false );
BOOST_CHECK_EQUAL( itv_map.contains(MK_v(2)), true );
BOOST_CHECK_EQUAL( itv_map.contains(MK_v(3)), false );
- itv_map.add(IDv(3,6,2));
+ itv_map.add(IDv(3,6,2));
BOOST_CHECK_EQUAL( itv_map.contains(I_I(0,0)), false );
BOOST_CHECK_EQUAL( itv_map.contains(I_I(2,4)), true );
BOOST_CHECK_EQUAL( itv_map.contains(I_I(6,6)), false );
- itv_map.add(IDv(8,9,2));
+ itv_map.add(IDv(8,9,2));
- IntervalSetT itv_set;
- itv_set.add(C_I(1,2)).add(C_D(2,6)).add(I_I(8,8));
+ IntervalSetT itv_set;
+ itv_set.add(C_I(1,2)).add(C_D(2,6)).add(I_I(8,8));
BOOST_CHECK_EQUAL( itv_map.contains(itv_set), true );
- itv_set.add(I_I(1,4));
+ itv_set.add(I_I(1,4));
BOOST_CHECK_EQUAL( itv_map.contains(itv_set), true );
- itv_set.add(I_I(1,4));
+ itv_set.add(I_I(1,4));
BOOST_CHECK_EQUAL( itv_map.contains(itv_set), true );
- itv_set.add(I_I(7,7));
+ itv_set.add(I_I(7,7));
BOOST_CHECK_EQUAL( itv_map.contains(itv_set), false );
}
@@ -1108,61 +1121,61 @@
void interval_map_inclusion_compare_4_bicremental_types()
{
typedef IntervalMap<T,U,Trt> IntervalMapT;
- typedef typename IntervalMap<T,U,Trt>::set_type IntervalSetT;
+ typedef typename IntervalMap<T,U,Trt>::set_type IntervalSetT;
typedef itl::map<T,U,Trt> MapT;
typedef itl::set<T> SetT;
IntervalMapT itv_map_sub_a, itv_map_a, itv_map_a2, itv_map_super_a,
- itv_map_b, itv_map_c;
+ itv_map_b, itv_map_c;
itv_map_sub_a.add(IDv(2,4,1)).add(IIv(6,7,3));
itv_map_a = itv_map_sub_a;
- itv_map_a.add(IIv(9,9,1));
- itv_map_a2 = itv_map_a;
- itv_map_c = itv_map_sub_a;
- itv_map_c.erase(MK_v(7)).add(IIv(11,11,2));
- itv_map_b = itv_map_a;
- itv_map_b.set(IIv(6,7,2));
-
-
- BOOST_CHECK_EQUAL( inclusion_compare(IntervalMapT(), IntervalMapT()), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, itv_map_a), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, itv_map_a2), inclusion::equal );
-
- BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, IntervalMapT()), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, itv_map_sub_a), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare(IntervalMapT(), itv_map_a), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare(itv_map_sub_a, itv_map_a), inclusion::subset );
+ itv_map_a.add(IIv(9,9,1));
+ itv_map_a2 = itv_map_a;
+ itv_map_c = itv_map_sub_a;
+ itv_map_c.erase(MK_v(7)).add(IIv(11,11,2));
+ itv_map_b = itv_map_a;
+ itv_map_b.set(IIv(6,7,2));
+
+
+ BOOST_CHECK_EQUAL( inclusion_compare(IntervalMapT(), IntervalMapT()), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, itv_map_a), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, itv_map_a2), inclusion::equal );
+
+ BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, IntervalMapT()), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, itv_map_sub_a), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare(IntervalMapT(), itv_map_a), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare(itv_map_sub_a, itv_map_a), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, itv_map_b), inclusion::unrelated );
- BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, itv_map_c), inclusion::unrelated );
+ BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, itv_map_b), inclusion::unrelated );
+ BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, itv_map_c), inclusion::unrelated );
IntervalSetT set_sub_a, set_a, set_a2, set_b, set_c;
- itv_map_a.domain(set_a);
- itv_map_a2.domain(set_a2);
- itv_map_sub_a.domain(set_sub_a);
+ itv_map_a.domain(set_a);
+ itv_map_a2.domain(set_a2);
+ itv_map_sub_a.domain(set_sub_a);
- BOOST_CHECK_EQUAL( inclusion_compare(IntervalMapT(), IntervalSetT()), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(IntervalSetT(), IntervalMapT()), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(IntervalSetT(), IntervalSetT()), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(IntervalMapT(), IntervalSetT()), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(IntervalSetT(), IntervalMapT()), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(IntervalSetT(), IntervalSetT()), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, set_a), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(set_a, itv_map_a), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(set_a, set_a2), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, set_a), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(set_a, itv_map_a), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(set_a, set_a2), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, IntervalSetT()), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, set_sub_a), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, IntervalSetT()), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare(itv_map_a, set_sub_a), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare(IntervalSetT(), itv_map_a), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare(set_sub_a, itv_map_a), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare(IntervalSetT(), itv_map_a), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare(set_sub_a, itv_map_a), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare(set_a, IntervalSetT()), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare(set_a, set_sub_a), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare(set_a, IntervalSetT()), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare(set_a, set_sub_a), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare(IntervalSetT(), set_a), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare(set_sub_a, set_a), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare(IntervalSetT(), set_a), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare(set_sub_a, set_a), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare(set_a, itv_map_c), inclusion::unrelated );
- BOOST_CHECK_EQUAL( inclusion_compare(itv_map_c, set_a), inclusion::unrelated );
+ BOOST_CHECK_EQUAL( inclusion_compare(set_a, itv_map_c), inclusion::unrelated );
+ BOOST_CHECK_EQUAL( inclusion_compare(itv_map_c, set_a), inclusion::unrelated );
}
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 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -59,14 +59,14 @@
typedef itl::set<T> SetT;
IntervalMapT itv_map_sub_a, itv_map_a, itv_map_super_a,
- itv_map_b, itv_map_c;
+ itv_map_b, itv_map_c;
itv_map_sub_a.add(IDv(2,4,1)).add(IIv(6,7,3));
itv_map_a = itv_map_sub_a;
- itv_map_a.add(IIv(9,9,1));
- itv_map_c = itv_map_sub_a;
- itv_map_c.erase(MK_v(7)).add(IIv(11,11,2));
- itv_map_b = itv_map_a;
- itv_map_b.set(IIv(6,7,2));
+ itv_map_a.add(IIv(9,9,1));
+ itv_map_c = itv_map_sub_a;
+ itv_map_c.erase(MK_v(7)).add(IIv(11,11,2));
+ itv_map_b = itv_map_a;
+ itv_map_b.set(IIv(6,7,2));
MapT map_sub_a, map_a, map_a2, map_b, map_c;
Interval::atomize(map_a, itv_map_a);
@@ -74,46 +74,46 @@
Interval::atomize(map_c, itv_map_c);
Interval::atomize(map_sub_a, itv_map_sub_a);
- map_a2 = map_a;
- BOOST_CHECK_EQUAL( inclusion_compare(MapT(), MapT()), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(map_a, map_a), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(map_a, map_a2), inclusion::equal );
-
- BOOST_CHECK_EQUAL( inclusion_compare(map_a, MapT()), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare(map_a, map_sub_a), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare(MapT(), map_a), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare(map_sub_a, map_a), inclusion::subset );
+ map_a2 = map_a;
+ BOOST_CHECK_EQUAL( inclusion_compare(MapT(), MapT()), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(map_a, map_a), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(map_a, map_a2), inclusion::equal );
+
+ BOOST_CHECK_EQUAL( inclusion_compare(map_a, MapT()), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare(map_a, map_sub_a), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare(MapT(), map_a), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare(map_sub_a, map_a), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare(map_a, map_b), inclusion::unrelated );
- BOOST_CHECK_EQUAL( inclusion_compare(map_a, map_c), inclusion::unrelated );
+ BOOST_CHECK_EQUAL( inclusion_compare(map_a, map_b), inclusion::unrelated );
+ BOOST_CHECK_EQUAL( inclusion_compare(map_a, map_c), inclusion::unrelated );
SetT set_sub_a, set_a, set_a2, set_b, set_c;
- map_a.domain(set_a);
- map_a2.domain(set_a2);
- map_sub_a.domain(set_sub_a);
+ map_a.domain(set_a);
+ map_a2.domain(set_a2);
+ map_sub_a.domain(set_sub_a);
- BOOST_CHECK_EQUAL( inclusion_compare(MapT(), SetT()), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(SetT(), MapT()), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(SetT(), SetT()), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(MapT(), SetT()), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(SetT(), MapT()), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(SetT(), SetT()), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(map_a, set_a), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(set_a, map_a), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(set_a, set_a2), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(map_a, set_a), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(set_a, map_a), inclusion::equal );
+ BOOST_CHECK_EQUAL( inclusion_compare(set_a, set_a2), inclusion::equal );
- BOOST_CHECK_EQUAL( inclusion_compare(map_a, SetT()), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare(map_a, set_sub_a), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare(map_a, SetT()), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare(map_a, set_sub_a), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare(SetT(), map_a), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare(set_sub_a, map_a), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare(SetT(), map_a), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare(set_sub_a, map_a), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare(set_a, SetT()), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare(set_a, set_sub_a), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare(set_a, SetT()), inclusion::superset );
+ BOOST_CHECK_EQUAL( inclusion_compare(set_a, set_sub_a), inclusion::superset );
- BOOST_CHECK_EQUAL( inclusion_compare(SetT(), set_a), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare(set_sub_a, set_a), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare(SetT(), set_a), inclusion::subset );
+ BOOST_CHECK_EQUAL( inclusion_compare(set_sub_a, set_a), inclusion::subset );
- BOOST_CHECK_EQUAL( inclusion_compare(set_a, map_c), inclusion::unrelated );
- BOOST_CHECK_EQUAL( inclusion_compare(map_c, set_a), inclusion::unrelated );
+ BOOST_CHECK_EQUAL( inclusion_compare(set_a, map_c), inclusion::unrelated );
+ BOOST_CHECK_EQUAL( inclusion_compare(map_c, set_a), inclusion::unrelated );
}
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 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -13,7 +13,7 @@
namespace boost{ namespace itl
{
-/*JODO completion like that:
+/*FYI completion like that:
std::string make(int n)
{
std::string value = neutron<std::string>::value();
Modified: sandbox/itl/libs/validate/example/labat_collector_/labat_collector.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_collector_/labat_collector.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_collector_/labat_collector.cpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -24,8 +24,8 @@
">> Output will be generated in a few seconds\n"
">> terminate by typing <CTRL>C\n"
">> ------------------------------------------------------ <<\n";
+ GentorProfileSgl::it()->set_std_profile(6,1);
GentorProfileSgl::it()->report_profile();
-
validater.validate();
};
Modified: sandbox/itl/libs/validate/example/labat_itl_morphic_/labat_itl_morphic.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_itl_morphic_/labat_itl_morphic.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_itl_morphic_/labat_itl_morphic.cpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -25,6 +25,8 @@
">> Output will be generated in a few seconds\n"
">> terminate by typing <CTRL>C\n"
">> ------------------------------------------------------ <<\n";
+ GentorProfileSgl::it()->set_std_profile(16,1);
+ GentorProfileSgl::it()->report_profile();
validater.validate();
};
Modified: sandbox/itl/libs/validate/example/labat_itl_order_/labat_itl_order.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_itl_order_/labat_itl_order.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_itl_order_/labat_itl_order.cpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -36,6 +36,8 @@
">> Output will be generated in a few seconds\n"
">> terminate by typing <CTRL>C\n"
">> ------------------------------------------------------ <<\n";
+ GentorProfileSgl::it()->set_std_profile(16,1);
+ GentorProfileSgl::it()->report_profile();
validater.validate();
};
Modified: sandbox/itl/libs/validate/example/labat_itl_set_/labat_itl_set.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_itl_set_/labat_itl_set.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_itl_set_/labat_itl_set.cpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -25,6 +25,8 @@
">> Output will be generated in a few seconds\n"
">> terminate by typing <CTRL>C\n"
">> ------------------------------------------------------ <<\n";
+ GentorProfileSgl::it()->set_std_profile(16,1);
+ GentorProfileSgl::it()->report_profile();
validater.validate();
};
Modified: sandbox/itl/libs/validate/example/labat_polygon_/labat_polygon.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_polygon_/labat_polygon.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_polygon_/labat_polygon.cpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -73,14 +73,14 @@
for(int i = 0; i < 100; ++i)
{
if(i%10==0)
- std::cout << ".";
+ std::cout << ".";
test_polygon_set<CPolygonSet>();
}
long long c2 = clock();
for(int i = 0; i < 100; ++i)
{
if(i%10==0)
- std::cout << ".";
+ std::cout << ".";
test_polygon_set<gtl::polygon_set_data<int> >();
}
long long c3 = clock();
@@ -98,38 +98,38 @@
// This function tests the generator for polygon sets.
void test_polyset_gen()
{
- typedef itl::list<point<int> > PolygonT;
- typedef itl::list<PolygonT> PolygonSetT;
+ typedef itl::list<point<int> > PolygonT;
+ typedef itl::list<PolygonT> PolygonSetT;
- point_gentor<int> pointgen;
- pointgen.setRange(interval<int>::rightopen(-99, 100));
+ point_gentor<int> pointgen;
+ pointgen.setRange(interval<int>::rightopen(-99, 100));
- PolygonT some_poly;
- polygon_gentor<PolygonT> polygen;
- polygen.setDomainGentor(&pointgen);
- polygen.setRangeOfSampleSize(interval<int>::rightopen(1, 5));
-
- PolygonSetT some_polyset;
- polygon_set_gentor<PolygonSetT> polysetgen;
- polysetgen.setDomainGentor(&polygen);
- polysetgen.setRangeOfSampleSize(interval<int>::rightopen(1, 3));
-
- for(int idx=0; idx<10; idx++)
- {
- polysetgen.some(some_polyset);
- cout << "[";
- for(PolygonSetT::iterator its_ = some_polyset.begin();
- its_ != some_polyset.end(); ++its_)
- {
- PolygonT& some_poly_ = *its_;
- cout << "{";
- for(PolygonT::iterator it_ = some_poly_.begin();
- it_ != some_poly_.end(); ++it_)
- cout << "(" << it_->x << "," << it_->y << ")";
- cout << "}\n";
- }
- cout << "]\n";
- }
+ PolygonT some_poly;
+ polygon_gentor<PolygonT> polygen;
+ polygen.setDomainGentor(&pointgen);
+ polygen.setRangeOfSampleSize(interval<int>::rightopen(1, 5));
+
+ PolygonSetT some_polyset;
+ polygon_set_gentor<PolygonSetT> polysetgen;
+ polysetgen.setDomainGentor(&polygen);
+ polysetgen.setRangeOfSampleSize(interval<int>::rightopen(1, 3));
+
+ for(int idx=0; idx<10; idx++)
+ {
+ polysetgen.some(some_polyset);
+ cout << "[";
+ for(PolygonSetT::iterator its_ = some_polyset.begin();
+ its_ != some_polyset.end(); ++its_)
+ {
+ PolygonT& some_poly_ = *its_;
+ cout << "{";
+ for(PolygonT::iterator it_ = some_poly_.begin();
+ it_ != some_poly_.end(); ++it_)
+ cout << "(" << it_->x << "," << it_->y << ")";
+ cout << "}\n";
+ }
+ cout << "]\n";
+ }
}
@@ -138,25 +138,25 @@
void test_LawValidater()
{
- //typedef PolygonCommutativity
- // < CPolygonSet > TestLawT;
- //LawValidater<TestLawT, RandomGentor> test_law;
-
- typedef PolygonSymmetricDifference
- < CPolygonSet > TestLawT;
- LawValidater<TestLawT, RandomGentor> test_law;
+ //typedef PolygonCommutativity
+ // < CPolygonSet > TestLawT;
+ //LawValidater<TestLawT, RandomGentor> test_law;
+
+ typedef PolygonSymmetricDifference
+ < CPolygonSet > TestLawT;
+ LawValidater<TestLawT, RandomGentor> test_law;
//-----------------------------------------------------------------------------
- // Set the test automatons parameters:
- // Size of polygon sets is in [0 .. |set| ]
- // Size of polygon sets is in [0 .. |poly|]
- // Coordinates in [min .. max)
- // |set|,|poly|, min, max
- GentorProfileSgl::it()->set_polygon_profile(1, 3, 0, 10);
- int test_count = 10000;
+ // Set the test automatons parameters:
+ // Size of polygon sets is in [0 .. |set| ]
+ // Size of polygon sets is in [0 .. |poly|]
+ // Coordinates in [min .. max)
+ // |set|,|poly|, min, max
+ GentorProfileSgl::it()->set_polygon_profile(1, 3, 0, 10);
+ int test_count = 10000;
ptime start, stop;
- test_law.set_trials_count(test_count);
+ test_law.set_trials_count(test_count);
std::cout << "Start\n";
start = ptime(microsec_clock::local_time());
@@ -169,10 +169,10 @@
int main()
{
- //test_polyset_gen();
- //polygon_test();
- //test_polygon_set<CPolygonSet>();
- test_LawValidater();
+ //test_polyset_gen();
+ //polygon_test();
+ //test_polygon_set<CPolygonSet>();
+ test_LawValidater();
}
Modified: sandbox/itl/libs/validate/example/labat_polygon_/point_gentor.hpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_polygon_/point_gentor.hpp (original)
+++ sandbox/itl/libs/validate/example/labat_polygon_/point_gentor.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -23,31 +23,31 @@
template<class DomainT>
struct point
{
- //CL typedef DomainT coordinate_type;
+ //CL typedef DomainT coordinate_type;
- std::string as_string()const
- {
- return std::string(
- "(" + to_string<DomainT>::apply(x) + "," +
- to_string<DomainT>::apply(y) + ")"
- );
- }
+ std::string as_string()const
+ {
+ return std::string(
+ "(" + to_string<DomainT>::apply(x) + "," +
+ to_string<DomainT>::apply(y) + ")"
+ );
+ }
- DomainT x;
- DomainT y;
+ DomainT x;
+ DomainT y;
};
template<class DomainT>
bool operator == (const point<DomainT>& left, const point<DomainT>& right)
{
- return left.x == right.x && left.y == right.y;
+ return left.x == right.x && left.y == right.y;
}
template <class Type>
struct type_to_string<itl::point<Type> >
{
- static std::string apply()
- { return "point<"+ type_to_string<Type>::apply() +">"; }
+ static std::string apply()
+ { return "point<"+ type_to_string<Type>::apply() +">"; }
};
template <class DomainT, class PointT = point<DomainT> >
@@ -56,7 +56,7 @@
public:
virtual void some(PointT& x);
- void setRange(const itl::interval<DomainT>& range)
+ void setRange(const itl::interval<DomainT>& range)
{ m_valueRange = range; }
void setValueRange(DomainT low, DomainT up)
@@ -76,8 +76,8 @@
template <class DomainT, class PointT>
void point_gentor<DomainT, PointT>::some(PointT& value)
{
- value.x = m_DomainTGentor(m_valueRange);
- value.y = m_DomainTGentor(m_valueRange);
+ value.x = m_DomainTGentor(m_valueRange);
+ value.y = m_DomainTGentor(m_valueRange);
};
}} // namespace itl boost
Modified: sandbox/itl/libs/validate/example/labat_polygon_/polygon_gentor.hpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_polygon_/polygon_gentor.hpp (original)
+++ sandbox/itl/libs/validate/example/labat_polygon_/polygon_gentor.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -56,11 +56,11 @@
DomainTD key, first;
- if(m_sampleSize == 0)
- return;
+ if(m_sampleSize == 0)
+ return;
- m_domainGentor->some(first);
- x.push_back(first);
+ m_domainGentor->some(first);
+ x.push_back(first);
for(int i=1; i<m_sampleSize; i++)
{
@@ -77,8 +77,8 @@
m_sample.push_back(key);
}
- if(m_sampleSize > 1 && !(*x.rbegin() == first))
- x.push_back(first);
+ if(m_sampleSize > 1 && !(*x.rbegin() == first))
+ x.push_back(first);
}
@@ -150,11 +150,11 @@
DomainTD key, first;
- if(m_sampleSize == 0)
- return;
+ if(m_sampleSize == 0)
+ return;
- m_domainGentor->some(first);
- x.push_back(first);
+ m_domainGentor->some(first);
+ x.push_back(first);
for(int i=1; i<m_sampleSize; i++)
{
@@ -172,8 +172,8 @@
m_sample.push_back(key);
}
- if(m_sampleSize > 1)
- x.push_back(first);
+ if(m_sampleSize > 1)
+ x.push_back(first);
}
Modified: sandbox/itl/libs/validate/example/labat_polygon_/polygon_laws.hpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_polygon_/polygon_laws.hpp (original)
+++ sandbox/itl/libs/validate/example/labat_polygon_/polygon_laws.hpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -49,16 +49,16 @@
bool holds()
{
- using namespace boost::polygon;
- using namespace boost::polygon::operators;
+ using namespace boost::polygon;
+ using namespace boost::polygon::operators;
Type value_a = this->template getInputValue<operand_a>();
Type value_b = this->template getInputValue<operand_b>();
- Type left = value_a;
- boost::polygon::operators::operator+=(left, value_b);
- Type right = value_b;
- boost::polygon::operators::operator+=(right, value_a);
+ Type left = value_a;
+ boost::polygon::operators::operator+=(left, value_b);
+ Type right = value_b;
+ boost::polygon::operators::operator+=(right, value_a);
this->template setOutputValue<lhs_result>(left);
this->template setOutputValue<rhs_result>(right);
@@ -68,13 +68,13 @@
bool debug_holds()
{
- // If law violations are found, this function is called
- // for the smallest violated law instance.
- // You may replace the call of
- // holds();
- // by your own code that is providing additional debugging
- // information.
- return holds();
+ // If law violations are found, this function is called
+ // for the smallest violated law instance.
+ // You may replace the call of
+ // holds();
+ // by your own code that is providing additional debugging
+ // information.
+ return holds();
}
};
@@ -83,9 +83,9 @@
template <typename Type> //Type can be more than one parameter for mixed laws with different types
class PolygonSymmetricDifference
: public Law<PolygonSymmetricDifference<Type>,
- // Input type list Result type list
- // Types of the variables Tpyes of the righthand and the lefthand side.
- // in a law Can be more, if you want to see interim results.
+ // Input type list Result type list
+ // Types of the variables Tpyes of the righthand and the lefthand side.
+ // in a law Can be more, if you want to see interim results.
LOKI_TYPELIST_2(Type,Type), LOKI_TYPELIST_2(Type,Type)>
{
// (a+b) - (a&b) == (a-b) + (b-a)
@@ -93,7 +93,7 @@
//Output = (sum_lhs, sum_rhs)
public:
- // These are descriptive informations to create readable output.
+ // These are descriptive informations to create readable output.
std::string name()const { return "Polygon Symmetric Difference"; }
std::string formula()const { return "(a+b) - (a&b) == (a-b) + (b-a)"; }
@@ -104,24 +104,24 @@
public:
- // Define a size measure for the laws input variables. According to
- // this size the smallest law instances are collected if violations occur.
+ // Define a size measure for the laws input variables. According to
+ // this size the smallest law instances are collected if violations occur.
size_t size()const
{
return value_size<Type>::apply(this->template getInputValue<operand_a>())+
value_size<Type>::apply(this->template getInputValue<operand_b>());
}
- // This function has to be coded to test the validity of a law instance.
+ // This function has to be coded to test the validity of a law instance.
bool holds()
{
- using namespace boost::polygon;
- using namespace boost::polygon::operators;
+ using namespace boost::polygon;
+ using namespace boost::polygon::operators;
- // There are predifined constants operand_a, _b, ..., lhs_reult, rhs_result in the base class.
- //std::cout << this->template getInputValue<operand_a>().as_string() << std::endl;
+ // There are predifined constants operand_a, _b, ..., lhs_reult, rhs_result in the base class.
+ //std::cout << this->template getInputValue<operand_a>().as_string() << std::endl;
- // --- left hand side ------------------------
+ // --- left hand side ------------------------
Type a_plus_b = this->template getInputValue<operand_a>();
boost::polygon::operators::operator+=(a_plus_b, this->template getInputValue<operand_b>());
@@ -141,7 +141,7 @@
Type rhs = a_minus_b;
boost::polygon::operators::operator+=(rhs, b_minus_a);
- // Set the output variables of this law instance.
+ // Set the output variables of this law instance.
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
@@ -150,13 +150,13 @@
bool debug_holds()
{
- // If law violations are found, this function is called
- // for the smallest violated law instance.
- // You may replace the call of
- // holds();
- // by your own code that is providing additional debugging
- // information.
- return holds();
+ // If law violations are found, this function is called
+ // for the smallest violated law instance.
+ // You may replace the call of
+ // holds();
+ // by your own code that is providing additional debugging
+ // information.
+ return holds();
}
};
Modified: sandbox/itl/libs/validate/example/labat_signed_quantifier_/labat_signed_quantifier.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_signed_quantifier_/labat_signed_quantifier.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_signed_quantifier_/labat_signed_quantifier.cpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -25,6 +25,8 @@
">> Output will be generated in a few seconds\n"
">> terminate by typing <CTRL>C\n"
">> ------------------------------------------------------ <<\n";
+ GentorProfileSgl::it()->set_std_profile(16,1);
+ GentorProfileSgl::it()->report_profile();
validater.validate();
};
Modified: sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -69,21 +69,21 @@
// <itl::interval_map<int, int> > TestLawT;
//LawValidater<TestLawT, RandomGentor> test_law;
- //typedef IntersectsDefined
- // <itl::interval_map<int, int, total_absorber> > TestLawT;
- //LawValidater<TestLawT, RandomGentor> test_law;
-
- //typedef Interinclusion
- // <interval_map<int,int>, interval_set<int> > TestLawT;
- //LawValidater<TestLawT, RandomGentor> test_law;
-
- //typedef Interinclusion
- // <interval_map<int, itl::set<int> >, interval_map<int, itl::set<int> > > TestLawT;
- //LawValidater<TestLawT, RandomGentor> test_law;
-
- typedef AddendInclusion
- <interval_set<int>, itl::interval<int> > TestLawT;
- LawValidater<TestLawT, RandomGentor> test_law;
+ //typedef IntersectsDefined
+ // <itl::interval_map<int, int, total_absorber> > TestLawT;
+ //LawValidater<TestLawT, RandomGentor> test_law;
+
+ //typedef Interinclusion
+ // <interval_map<int,int>, interval_set<int> > TestLawT;
+ //LawValidater<TestLawT, RandomGentor> test_law;
+
+ //typedef Interinclusion
+ // <interval_map<int, itl::set<int> >, interval_map<int, itl::set<int> > > TestLawT;
+ //LawValidater<TestLawT, RandomGentor> test_law;
+
+ typedef AddendInclusion
+ <interval_set<int>, itl::interval<int> > TestLawT;
+ LawValidater<TestLawT, RandomGentor> test_law;
//-----------------------------------------------------------------------------
int test_count = 20000;
Modified: sandbox/itl/libs/validate/example/labat_unsigned_quantifier_/labat_unsigned_quantifier.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_unsigned_quantifier_/labat_unsigned_quantifier.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_unsigned_quantifier_/labat_unsigned_quantifier.cpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -26,6 +26,8 @@
">> Output will be generated in a few seconds\n"
">> terminate by typing <CTRL>C\n"
">> ------------------------------------------------------ <<\n";
+ GentorProfileSgl::it()->set_std_profile(16,1);
+ GentorProfileSgl::it()->report_profile();
validater.validate();
};
Modified: sandbox/itl/libs/validate/example/labat_val_relations_/labat_val_relations.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_val_relations_/labat_val_relations.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_val_relations_/labat_val_relations.cpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -24,6 +24,8 @@
">> Output will be generated in a few seconds\n"
">> terminate by typing <CTRL>C\n"
">> ------------------------------------------------------ <<\n";
+ GentorProfileSgl::it()->set_std_profile(20,1);
+ GentorProfileSgl::it()->report_profile();
validater.validate();
};
Modified: sandbox/itl/libs/validate/src/gentor/gentorprofile.cpp
==============================================================================
--- sandbox/itl/libs/validate/src/gentor/gentorprofile.cpp (original)
+++ sandbox/itl/libs/validate/src/gentor/gentorprofile.cpp 2009-09-04 17:27:37 EDT (Fri, 04 Sep 2009)
@@ -110,8 +110,8 @@
void GentorProfile::set_polygon_profile(int max_polygon_set_size, int max_polygon_size, int min_coord, int max_coord)
{
- int factor = 1;
- int unit = max_polygon_set_size+1;
+ int factor = 1;
+ int unit = max_polygon_set_size+1;
int value = unit*factor;
_unit = unit;
_scaling = factor;