Subject: [Boost-commit] svn:boost r65239 - in sandbox/itl: boost/itl boost/itl/detail libs/validate/example/labat_signed_quantifier_
From: afojgo_at_[hidden]
Date: 2010-09-04 08:17:11
Author: jofaber
Date: 2010-09-04 08:17:09 EDT (Sat, 04 Sep 2010)
New Revision: 65239
URL: http://svn.boost.org/trac/boost/changeset/65239
Log:
Refactoring: Refactoring for interval_map::add_ complete. Stable{msvc-9.0, gcc-3.4.4}
Text files modified:
sandbox/itl/boost/itl/detail/interval_map_algo.hpp | 169 +++++++++++++++++++++++++++++++++++++++
sandbox/itl/boost/itl/detail/interval_set_algo.hpp | 8 +
sandbox/itl/boost/itl/interval_base_map.hpp | 14 +-
sandbox/itl/boost/itl/interval_map.hpp | 139 +-------------------------------
sandbox/itl/libs/validate/example/labat_signed_quantifier_/labat_signed_quantifier.cpp | 2
5 files changed, 190 insertions(+), 142 deletions(-)
Modified: sandbox/itl/boost/itl/detail/interval_map_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/interval_map_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/interval_map_algo.hpp 2010-09-04 08:17:09 EDT (Sat, 04 Sep 2010)
@@ -171,7 +171,6 @@
namespace detail
{
-
template <class Type, class Combiner>
inline typename Type::iterator
gap_insert( Type& object,
@@ -188,6 +187,86 @@
}
+
+//------------------------------------------------------------------------------
+template<class Type, class Combiner, bool abosorbs_neutrons>
+struct last_segment
+{
+ typedef last_segment type;
+
+ typedef typename Type::iterator iterator;
+ typedef typename Type::interval_type interval_type;
+ typedef typename Type::codomain_type codomain_type;
+
+ static void join(Type&, iterator&, iterator);
+ static void insert_at(Type&, iterator&, iterator,
+ const interval_type&, const codomain_type&);
+};
+
+template<class Type, class Combiner>
+struct last_segment<Type, Combiner, false>
+{
+ typedef last_segment type;
+
+ typedef typename Type::iterator iterator;
+ typedef typename Type::interval_type interval_type;
+ typedef typename Type::codomain_type codomain_type;
+
+ static void join(Type& object, iterator& it_, iterator)
+ {
+ join_neighbours(object, it_);
+ }
+
+ static void insert_at(Type& object, iterator& it_, iterator,
+ const interval_type& end_gap, const codomain_type& co_val)
+ {
+ join_left(object, it_);
+ iterator inserted_ = gap_insert<Type,Combiner>(object, it_, end_gap, co_val);
+ it_ = join_neighbours(object, inserted_);
+ }
+};
+
+
+template<class Type, class Combiner>
+struct last_segment<Type, Combiner, true>
+{
+ typedef last_segment type;
+
+ typedef typename Type::iterator iterator;
+ typedef typename Type::interval_type interval_type;
+ typedef typename Type::codomain_type codomain_type;
+
+ static void join(Type& object, iterator& it_, iterator inserted_)
+ {
+ if(it_->second == Combiner::neutron())
+ {
+ object.erase(it_);
+ it_ = inserted_;
+ }
+ else
+ join_neighbours(object, it_);
+ }
+
+ static void insert_at(Type& object, iterator& it_, iterator prior_,
+ const interval_type& end_gap, const codomain_type& co_val)
+ {
+ if(it_->second == Combiner::neutron())
+ {
+ object.erase(it_);
+ it_ = gap_insert<Type,Combiner>(object, prior_, end_gap, co_val);
+ join_right(object, it_);
+ }
+ else
+ {
+ join_left(object, it_);
+ iterator inserted_ = gap_insert<Type,Combiner>(object, it_, end_gap, co_val);
+ it_ = join_neighbours(object, inserted_);
+ }
+ }
+};
+
+
+
template<class Type, class Combiner>
void add_segment( Type& object,
const typename Type::interval_type& inter_val,
@@ -215,13 +294,99 @@
object.erase(it_++);
else
{
- detail::join_left(object, it_);
+ join_left(object, it_);
++it_;
}
}
+template<class Type, class Combiner>
+void add_main( Type& object,
+ typename Type::interval_type& rest_interval,
+ const typename Type::codomain_type& co_val,
+ typename Type::iterator& it_,
+ const typename Type::iterator& last_ )
+{
+ typedef typename Type::interval_type interval_type;
+ typedef typename Type::iterator iterator;
+
+ interval_type cur_interval;
+ while(it_!=last_)
+ {
+ cur_interval = it_->first ;
+ add_segment<Type,Combiner>(object, rest_interval, co_val, it_);
+ // shrink interval
+ rest_interval = left_subtract(rest_interval, cur_interval);
+ }
+}
+
+
+
+template<class Type, class Combiner>
+void add_rear( Type& object,
+ typename Type::interval_type& inter_val,
+ const typename Type::codomain_type& co_val,
+ typename Type::iterator& it_ )
+{
+ typedef typename Type::interval_type interval_type;
+ typedef typename Type::value_type value_type;
+ typedef typename Type::iterator iterator;
+ typedef typename last_segment<Type,Combiner,absorbs_neutrons<Type>::value>::type last_segment_;
+
+ iterator prior_ = object.prior(it_);
+ interval_type cur_itv = it_->first ;
+
+ interval_type lead_gap = right_subtract(inter_val, cur_itv);
+ if(!itl::is_empty(lead_gap))
+ { // [lead_gap--- . . .
+ // [prior) [-- it_ ...
+ iterator inserted_ = gap_insert<Type,Combiner>(object, prior_, lead_gap, co_val);
+ if(prior_ != object.end() && joinable(object, prior_, inserted_))
+ join_on_left(object, prior_, inserted_);
+ }
+
+ interval_type end_gap = left_subtract(inter_val, cur_itv);
+ if(!itl::is_empty(end_gap))
+ {
+ // [----------------end_gap)
+ // . . . -- it_ --)
+ Combiner()(it_->second, co_val);
+ last_segment_::insert_at(object, it_, prior_, end_gap, co_val);
+ }
+ else
+ {
+ // only for the last there can be a right_resid: a part of *it_ right of x
+ interval_type right_resid = left_subtract(cur_itv, inter_val);
+
+ if(itl::is_empty(right_resid))
+ {
+ // [---------------)
+ // [-- it_ ---)
+ Combiner()(it_->second, co_val);
+ last_segment_::join(object, it_, prior_);
+ }
+ else
+ {
+ // [--------------)
+ // [-- it_ --right_resid)
+ const_cast<interval_type&>(it_->first) = right_subtract(it_->first, right_resid);
+
+ //NOTE: This is NOT an insertion that has to take care for correct application of
+ // the Combiner functor. It only reestablished that state after splitting the
+ // 'it_' interval value pair. Using _map_insert<Combiner> does not work here.
+ iterator insertion_ = object._insert(it_, value_type(right_resid, it_->second));
+ join_right(object, insertion_);
+
+ Combiner()(it_->second, co_val);
+ last_segment_::join(object, it_, insertion_);
+ }
+ }
+}
+
+
+
+
} // namespace detail
}} // namespace itl boost
Modified: sandbox/itl/boost/itl/detail/interval_set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/interval_set_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/interval_set_algo.hpp 2010-09-04 08:17:09 EDT (Sat, 04 Sep 2010)
@@ -517,15 +517,17 @@
// The addend interval 'inter_val' covers the beginning of the collision sequence.
// only for the first there can be a left_resid: a part of *first_ left of inter_val
- interval_type left_resid = right_subtract(*first_, inter_val);
+ interval_type left_resid = right_subtract(Type::key_value(first_), inter_val);
if(!itl::is_empty(left_resid))
{ // [------------ . . .
// [left_resid---first_ --- . . .
iterator prior_ = object.prior(first_);
- const_cast<interval_type&>(*first_) = left_subtract(*first_, left_resid);
+ const_cast<interval_type&>(Type::key_value(first_))
+ = left_subtract(Type::key_value(first_), left_resid);
//NOTE: Only splitting
- iterator insertion_ = object._insert(prior_, left_resid);
+ //CL iterator insertion_ =
+ object._insert(prior_, Type::make_value(left_resid, Type::co_value(first_)));
}
//POST:
Modified: sandbox/itl/boost/itl/interval_base_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_map.hpp 2010-09-04 08:17:09 EDT (Sat, 04 Sep 2010)
@@ -673,6 +673,13 @@
const_reverse_iterator rbegin()const { return _map.rbegin(); }
const_reverse_iterator rend()const { return _map.rend(); }
+ iterator prior(iterator it_)
+ { return it_ == this->_map.begin() ? this->_map.end() : --it_; }
+
+ const_iterator prior(const_iterator it_)const
+ { return it_ == this->_map.begin() ? this->_map.end() : --it_; }
+
+
//==========================================================================
//= Element iterator related
//==========================================================================
@@ -740,6 +747,7 @@
{ codomain_type total; sum(total); return total; }
+
//==========================================================================
//= Algorithm unifiers
//==========================================================================
@@ -766,12 +774,6 @@
protected:
- iterator prior(iterator it_)
- { return it_ == this->_map.begin() ? this->_map.end() : --it_; }
-
- const_iterator prior(const_iterator it_)const
- { return it_ == this->_map.begin() ? this->_map.end() : --it_; }
-
template <class Combiner>
bool combine(iterator& it_, const codomain_type& co_val)
{
Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2010-09-04 08:17:09 EDT (Sat, 04 Sep 2010)
@@ -146,6 +146,7 @@
&& !(Traits::absorbs_neutrons && value.second == codomain_combine::neutron());
}
+ /*CL
template<class Combiner>
void add_main(interval_type& inter_val, const CodomainT& co_val,
iterator& it_, const iterator& last_);
@@ -154,7 +155,7 @@
void add_rear(const interval_type& inter_val, const CodomainT& co_val, iterator& it_);
void add_front(const interval_type& inter_val, iterator& first_);
-
+ */
template<class Combiner>
void subtract_main(const CodomainT& co_val, iterator& it_, iterator& end_ );
@@ -201,9 +202,9 @@
iterator it_ = first_;
interval_type rest_interval = inter_val;
- add_front (rest_interval, it_);
- add_main<Combiner>(rest_interval, co_val, it_, last_);
- add_rear<Combiner>(rest_interval, co_val, it_);
+ detail::add_front (*this, rest_interval, it_ );
+ detail::add_main<type,Combiner>(*this, rest_interval, co_val, it_, last_);
+ detail::add_rear<type,Combiner>(*this, rest_interval, co_val, it_ );
}
}
@@ -236,139 +237,15 @@
--last_;
interval_type rest_interval = inter_val;
- add_front (rest_interval, it_);
- add_main<Combiner>(rest_interval, co_val, it_, last_);
- add_rear<Combiner>(rest_interval, co_val, it_);
+ detail::add_front (*this, rest_interval, it_ );
+ detail::add_main<type,Combiner>(*this, rest_interval, co_val, it_, last_);
+ detail::add_rear<type,Combiner>(*this, rest_interval, co_val, it_ );
return it_;
}
}
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
-inline void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
- ::add_front(const interval_type& inter_val, iterator& first_)
-{
- // If the collision sequence has a left residual 'left_resid' it will
- // be split, to provide a standardized start of algorithms:
- // The addend interval 'inter_val' covers the beginning of the collision sequence.
-
- // only for the first there can be a left_resid: a part of *first_ left of inter_val
- interval_type left_resid = right_subtract(first_->first, inter_val);
-
- if(!itl::is_empty(left_resid))
- { // [------------ . . .
- // [prior) [left_resid---first_ --- . . .
- iterator prior_ = this->prior(first_);
- const_cast<interval_type&>(first_->first) = left_subtract(first_->first, left_resid);
- //NOTE: Only splitting
- this->_map.insert(prior_, value_type(left_resid, first_->second));
- }
-
- //POST:
- // [----- inter_val ---- . . .
- // ...[-- first_ --...
-}
-
-
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
- template<class Combiner>
-inline void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
- ::add_main(interval_type& x_rest, const CodomainT& co_val, iterator& it_, const iterator& last_)
-{
- interval_type cur_interval;
- while(it_!=last_)
- {
- cur_interval = it_->first ;
- detail::add_segment<type,Combiner>(*this, x_rest, co_val, it_);
- // shrink interval
- x_rest = left_subtract(x_rest, cur_interval);
- }
-}
-
-
-template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_INTERVAL(ITL_COMPARE) Interval, ITL_ALLOC Alloc>
- template<class Combiner>
-inline void interval_map<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
- ::add_rear(const interval_type& inter_val, const CodomainT& co_val, iterator& it_)
-{
- iterator prior_ = this->prior(it_);
- interval_type cur_itv = it_->first ;
-
- interval_type lead_gap = right_subtract(inter_val, cur_itv);
- if(!itl::is_empty(lead_gap))
- { // [lead_gap--- . . .
- // [prior) [-- it_ ...
- iterator inserted_ = this->template gap_insert<Combiner>(prior_, lead_gap, co_val);
- if(prior_ != this->_map.end() && detail::joinable(*this, prior_, inserted_))
- detail::join_on_left(*this, prior_, inserted_);
- }
-
- interval_type end_gap = left_subtract(inter_val, cur_itv);
- if(!itl::is_empty(end_gap))
- {
- // [----------------end_gap)
- // . . . -- it_ --)
- Combiner()(it_->second, co_val);
-
- if(Traits::absorbs_neutrons && it_->second == Combiner::neutron())
- {
- this->_map.erase(it_);
- it_ = this->template gap_insert<Combiner>(prior_, end_gap, co_val);
- detail::join_right(*this, it_);
- }
- else
- {
- detail::join_left(*this, it_);
- iterator inserted_ = this->template gap_insert<Combiner>(it_, end_gap, co_val);
- it_ = detail::join_neighbours(*this, inserted_);
- }
- }
- else
- {
- // only for the last there can be a right_resid: a part of *it_ right of x
- interval_type right_resid = left_subtract(cur_itv, inter_val);
-
- if(itl::is_empty(right_resid))
- {
- // [---------------)
- // [-- it_ ---)
- Combiner()(it_->second, co_val);
-
- if(Traits::absorbs_neutrons && it_->second == Combiner::neutron())
- {
- this->_map.erase(it_);
- it_ = prior_;
- }
- else
- detail::join_neighbours(*this, it_);
- }
- else
- {
- // [--------------)
- // [-- it_ --right_resid)
- const_cast<interval_type&>(it_->first) = right_subtract(it_->first, right_resid);
-
- //NOTE: This is NOT an insertion that has to take care for correct application of
- // the Combiner functor. It only reestablished that state after splitting the
- // 'it_' interval value pair. Using _map_insert<Combiner> does not work here.
- iterator insertion_ = this->_map.insert(it_, value_type(right_resid, it_->second));
- detail::join_right(*this, insertion_);
-
- Combiner()(it_->second, co_val);
-
- if(Traits::absorbs_neutrons && it_->second == Combiner::neutron())
- {
- this->_map.erase(it_);
- it_ = insertion_;
- }
- else
- detail::join_neighbours(*this, it_);
- }
- }
-}
-
-
//-----------------------------------------------------------------------------
// subtract<Combinator>(pair(interval,value)):
//-----------------------------------------------------------------------------
Modified: sandbox/itl/libs/validate/example/labat_signed_quantifier_/labat_signed_quantifier.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_signed_quantifier_/labat_signed_quantifier.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_signed_quantifier_/labat_signed_quantifier.cpp 2010-09-04 08:17:09 EDT (Sat, 04 Sep 2010)
@@ -28,6 +28,8 @@
GentorProfileSgl::it()->set_std_profile(16,1);
GentorProfileSgl::it()->set_range_double(-1.0, 1.0);
GentorProfileSgl::it()->report_profile();
+
+ //validater.set_information_level(inform::never);
validater.validate();
};