Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r55601 - in sandbox/itl: boost/itl boost/itl/type_traits boost/validate boost/validate/driver boost/validate/gentor boost/validate/validater libs/itl/test/test_casual_ libs/validate/example/labat_collector_ libs/validate/src/gentor
From: afojgo_at_[hidden]
Date: 2009-08-15 08:15:35


Author: jofaber
Date: 2009-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
New Revision: 55601
URL: http://svn.boost.org/trac/boost/changeset/55601

Log:
Boostifying. Replaced tabs. Standardized for min/max guidelines. Stable {msvc-9.0r+d, gcc-3.4.4, gcc-4.1.0}

Text files modified:
   sandbox/itl/boost/itl/functions.hpp | 114 ++++++++++----------
   sandbox/itl/boost/itl/interval.hpp | 8
   sandbox/itl/boost/itl/interval_base_map.hpp | 186 +++++++++++++++++-----------------
   sandbox/itl/boost/itl/interval_base_set.hpp | 64 +++++-----
   sandbox/itl/boost/itl/interval_map.hpp | 22 ++--
   sandbox/itl/boost/itl/interval_set.hpp | 16 +-
   sandbox/itl/boost/itl/map.hpp | 30 ++--
   sandbox/itl/boost/itl/separate_interval_set.hpp | 8
   sandbox/itl/boost/itl/set.hpp | 6
   sandbox/itl/boost/itl/set_algo.hpp | 12 +-
   sandbox/itl/boost/itl/split_interval_map.hpp | 28 ++--
   sandbox/itl/boost/itl/split_interval_set.hpp | 14 +-
   sandbox/itl/boost/itl/type_traits/is_combinable.hpp | 214 ++++++++++++++++++++--------------------
   sandbox/itl/boost/validate/driver/itl_driver.hpp | 42 +++---
   sandbox/itl/boost/validate/gentor/gentorprofile.hpp | 52 ++++----
   sandbox/itl/boost/validate/validater/itl_set_validater.hpp | 6
   sandbox/itl/boost/validate/validater/law_validater.hpp | 40 +++---
   sandbox/itl/boost/validate/validation_counts.hpp | 8
   sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp | 4
   sandbox/itl/libs/validate/example/labat_collector_/labat_collector.cpp | 2
   sandbox/itl/libs/validate/src/gentor/gentorprofile.cpp | 98 +++++++++---------
   21 files changed, 487 insertions(+), 487 deletions(-)

Modified: sandbox/itl/boost/itl/functions.hpp
==============================================================================
--- sandbox/itl/boost/itl/functions.hpp (original)
+++ sandbox/itl/boost/itl/functions.hpp 2009-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -18,7 +18,7 @@
 //= Equivalences and Orderings
 //==============================================================================
 /** Returns true, if \c left and \c right contain the same elements.
- Complexity: linear. */
+ Complexity: linear. */
 template<class LeftT, class RightT>
 typename boost::enable_if<is_intra_combinable<LeftT, RightT>,
                           bool>::type
@@ -28,8 +28,8 @@
 }
 
 /** Returns true, if \c left is lexicographically less than \c right.
- Intervals are interpreted as sequence of elements.
- Complexity: linear. */
+ Intervals are interpreted as sequence of elements.
+ Complexity: linear. */
 template<class LeftT, class RightT>
 typename boost::enable_if<is_intra_combinable<LeftT, RightT>,
                           bool>::type
@@ -39,8 +39,8 @@
 }
 
 /** Returns true, if \c left is lexicographically greater than \c right.
- Intervals are interpreted as sequence of elements.
- Complexity: linear. */
+ Intervals are interpreted as sequence of elements.
+ Complexity: linear. */
 template<class LeftT, class RightT>
 typename boost::enable_if<is_intra_combinable<LeftT, RightT>,
                           bool>::type
@@ -53,15 +53,15 @@
 //= Addition
 //==============================================================================
 /** \par \b Requires: \c OperandT is an interval container addable to \c ObjectT.
- \b Effects: \c operand is added to \c object.
- \par \b Returns: A reference to \c object.
- \b Complexity: loglinear */
+ \b Effects: \c operand is added to \c object.
+ \par \b Returns: A reference to \c object.
+ \b Complexity: loglinear */
 template<class ObjectT, class OperandT>
 typename boost::enable_if<is_intra_combinable<ObjectT, OperandT>,
                           ObjectT>::type&
 operator += (ObjectT& object, const OperandT& operand)
 {
- typename ObjectT::iterator prior_ = object.end();
+ typename ObjectT::iterator prior_ = object.end();
     const_FORALL(typename OperandT, elem_, operand)
         prior_ = object.add(prior_, *elem_);
 
@@ -69,9 +69,9 @@
 }
 
 /* \par \b Requires: \c OperandT is an addable derivative type of \c ObjectT.
- \b Effects: \c operand is added to \c object.
- \par \b Returns: A reference to \c object.
- \b Complexity:
+ \b Effects: \c operand is added to \c object.
+ \par \b Returns: A reference to \c object.
+ \b Complexity:
 \code
                   \ OperandT:
                    \ element segment
@@ -94,13 +94,13 @@
                           ObjectT>::type&
 operator += (ObjectT& object, const OperandT& operand)
 {
- return object.add(operand);
+ return object.add(operand);
 }
 
 /** \par \b Requires: \c object and \c operand are addable.
- \b Effects: \c operand is added to \c object.
- \par \b Efficieny: There is one additional copy of
- \c ObjectT \c object compared to inplace \c operator \c += */
+ \b Effects: \c operand is added to \c object.
+ \par \b Efficieny: There is one additional copy of
+ \c ObjectT \c object compared to inplace \c operator \c += */
 template<class ObjectT, class OperandT>
 typename boost::enable_if<is_binary_intra_combinable<ObjectT, OperandT>, ObjectT>::type
 operator + (ObjectT object, const OperandT& operand)
@@ -109,9 +109,9 @@
 }
 
 /** \par \b Requires: \c object and \c operand are addable.
- \b Effects: \c operand is added to \c object.
- \par \b Efficieny: There is one additional copy of
- \c ObjectT \c object compared to inplace \c operator \c += */
+ \b Effects: \c operand is added to \c object.
+ \par \b Efficieny: There is one additional copy of
+ \c ObjectT \c object compared to inplace \c operator \c += */
 template<class ObjectT, class OperandT>
 typename boost::enable_if<is_binary_intra_combinable<ObjectT, OperandT>, ObjectT>::type
 operator + (const OperandT& operand, ObjectT object)
@@ -121,9 +121,9 @@
 
 
 /** \par \b Requires: \c object and \c operand are addable.
- \b Effects: \c operand is added to \c object.
- \par \b Efficieny: There is one additional copy of
- \c ObjectT \c object compared to inplace \c operator \c += */
+ \b Effects: \c operand is added to \c object.
+ \par \b Efficieny: There is one additional copy of
+ \c ObjectT \c object compared to inplace \c operator \c += */
 template<class ObjectT>
 ObjectT operator + (typename ObjectT::overloadable_type object, const ObjectT& operand)
 {
@@ -136,9 +136,9 @@
 //------------------------------------------------------------------------------
 
 /** \par \b Requires: Types \c ObjectT and \c OperandT are addable.
- \par \b Effects: \c operand is added to \c object.
- \par \b Returns: A reference to \c object.
- \b Complexity:
+ \par \b Effects: \c operand is added to \c object.
+ \par \b Returns: A reference to \c object.
+ \b Complexity:
 \code
                   \ OperandT: interval
                    \ element segment container
@@ -162,13 +162,13 @@
                           ObjectT>::type&
 operator |= (ObjectT& object, const OperandT& operand)
 {
- return object += operand;
+ return object += operand;
 }
 
 /** \par \b Requires: \c object and \c operand are addable.
- \b Effects: \c operand is added to \c object.
- \par \b Efficieny: There is one additional copy of
- \c ObjectT \c object compared to inplace \c operator \c |= */
+ \b Effects: \c operand is added to \c object.
+ \par \b Efficieny: There is one additional copy of
+ \c ObjectT \c object compared to inplace \c operator \c |= */
 template<class ObjectT, class OperandT>
 typename boost::enable_if<is_binary_intra_combinable<ObjectT, OperandT>, ObjectT>::type
 operator | (ObjectT object, const OperandT& operand)
@@ -177,9 +177,9 @@
 }
 
 /** \par \b Requires: \c object and \c operand are addable.
- \b Effects: \c operand is added to \c object.
- \par \b Efficieny: There is one additional copy of
- \c ObjectT \c object compared to inplace \c operator \c |= */
+ \b Effects: \c operand is added to \c object.
+ \par \b Efficieny: There is one additional copy of
+ \c ObjectT \c object compared to inplace \c operator \c |= */
 template<class ObjectT, class OperandT>
 typename boost::enable_if<is_binary_intra_combinable<ObjectT, OperandT>, ObjectT>::type
 operator | (const OperandT& operand, ObjectT object)
@@ -188,9 +188,9 @@
 }
 
 /** \par \b Requires: \c object and \c operand are addable.
- \b Effects: \c operand is added to \c object.
- \par \b Efficieny: There is one additional copy of
- \c ObjectT \c object compared to inplace \c operator \c |= */
+ \b Effects: \c operand is added to \c object.
+ \par \b Efficieny: There is one additional copy of
+ \c ObjectT \c object compared to inplace \c operator \c |= */
 template<class ObjectT>
 ObjectT operator | (typename ObjectT::overloadable_type object, const ObjectT& operand)
 {
@@ -206,9 +206,9 @@
 //------------------------------------------------------------------------------
 
 /** \par \b Requires: Types \c ObjectT and \c OperandT are subtractable.
- \par \b Effects: \c operand is subtracted from \c object.
- \par \b Returns: A reference to \c object.
- \b Complexity:
+ \par \b Effects: \c operand is subtracted from \c object.
+ \par \b Returns: A reference to \c object.
+ \b Complexity:
 \code
                   \ OperandT: interval
                    \ element segment container
@@ -243,7 +243,7 @@
                           ObjectT>::type&
 operator -= (ObjectT& object, const OperandT& operand)
 {
- return object.subtract(operand);
+ return object.subtract(operand);
 }
 
 template<class ObjectT, class OperandT>
@@ -251,7 +251,7 @@
                           ObjectT>::type&
 operator -= (ObjectT& object, const OperandT& operand)
 {
- return object.erase(operand);
+ return object.erase(operand);
 }
 
 template<class ObjectT, class IntervalSetT>
@@ -259,7 +259,7 @@
                           ObjectT>::type&
 operator -= (ObjectT& object, const IntervalSetT& operand)
 {
- return erase(object, operand);
+ return erase(object, operand);
 }
 
 
@@ -278,7 +278,7 @@
                           ObjectT>::type&
 insert(ObjectT& object, const OperandT& operand)
 {
- typename ObjectT::iterator prior_ = object.end();
+ typename ObjectT::iterator prior_ = object.end();
     const_FORALL(typename OperandT, elem_, operand)
         object.insert(*elem_);
 
@@ -305,7 +305,7 @@
 
     typename OperandT::const_iterator it_ = common_lwb;
     while(it_ != common_upb)
- object.erase(*it_++);
+ object.erase(*it_++);
 
     return object;
 }
@@ -355,12 +355,12 @@
                           bool>::type
 intersects(const LeftT& left, const RightT& right)
 {
- LeftT intersection;
+ LeftT intersection;
 
- if(left.empty() || right.empty())
- return false;
+ if(left.empty() || right.empty())
+ return false;
 
- typename RightT::const_iterator right_common_lower_;
+ typename RightT::const_iterator right_common_lower_;
     typename RightT::const_iterator right_common_upper_;
 
     if(!Set::common_range(right_common_lower_, right_common_upper_, right, left))
@@ -382,30 +382,30 @@
                           bool>::type
 intersects(const Type& left, const AssociateT& right)
 {
- return left.intersects(right);
+ return left.intersects(right);
 }
 
 /** \b Returns true, if \c left and \c right have no common elements.
     Intervals are interpreted as sequence of elements.
- \b Complexity: loglinear, if \c left and \c right are interval containers. */
+ \b Complexity: loglinear, if \c left and \c right are interval containers. */
 template<class LeftT, class RightT>
 typename boost::enable_if<is_inter_combinable<LeftT, RightT>,
                           bool>::type
 is_disjoint(const LeftT& left, const RightT& right)
 {
- return !intersects(left, right);
+ return !intersects(left, right);
 }
 
 /** \b Returns true, if \c left and \c right have no common elements.
     Intervals are interpreted as sequence of elements.
- \b Complexity: logarithmic, if \c AssociateT is an element type \c Type::element_type.
- linear, if \c AssociateT is a segment type \c Type::segment_type. */
+ \b Complexity: logarithmic, if \c AssociateT is an element type \c Type::element_type.
+ linear, if \c AssociateT is a segment type \c Type::segment_type. */
 template<class Type, class AssociateT>
 typename boost::enable_if<is_inter_derivative<Type, AssociateT>,
                           bool>::type
 is_disjoint(const Type& left, const AssociateT& right)
 {
- return !left.intersects(right);
+ return !left.intersects(right);
 }
 
 
@@ -422,7 +422,7 @@
                           ObjectT>::type&
 operator ^= (ObjectT& object, const OperandT& operand)
 {
- return object.flip(operand);
+ return object.flip(operand);
 }
 
 template<class ObjectT, class OperandT>
@@ -430,7 +430,7 @@
                           ObjectT>::type&
 operator ^= (ObjectT& object, const OperandT& operand)
 {
- return object.flip(operand);
+ return object.flip(operand);
 }
 
 template<class ObjectT, class OperandT>
@@ -464,8 +464,8 @@
 hull(const ObjectT& object)
 {
     return
- object.empty() ? neutron<typename ObjectT::interval_type>::value()
- : (ObjectT::key_value(object.begin()))
+ object.empty() ? neutron<typename ObjectT::interval_type>::value()
+ : (ObjectT::key_value(object.begin()))
             .span(ObjectT::key_value(object.rbegin()));
 }
 

Modified: sandbox/itl/boost/itl/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval.hpp (original)
+++ sandbox/itl/boost/itl/interval.hpp 2009-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -29,8 +29,8 @@
 #include <boost/itl/type_traits/size.hpp>
 #include <boost/itl/type_traits/to_string.hpp>
 
-#undef min
-#undef max
+//#undef min
+//#undef max
 
 #define BOUND_VALUE first
 #define BOUND_TYPES second
@@ -339,8 +339,8 @@
 
     /** An interval that covers the complete range of it's domain_type */
     static interval whole()
- { return interval<DomainT>::closed(std::numeric_limits<DomainT>::min(),
- std::numeric_limits<DomainT>::max()); }
+ { return interval<DomainT>::closed((std::numeric_limits<DomainT>::min)(),
+ (std::numeric_limits<DomainT>::max)()); }
 
 
     /** First element of \c *this is less than first element of \c x2 */

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-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -157,7 +157,7 @@
     { return is_set<codomain_type>::value || (!is_set<codomain_type>::value && !traits::is_total); }
 
     enum { is_itl_container = true };
- enum { fineness = 0 };
+ enum { fineness = 0 };
 
 public:
     //==========================================================================
@@ -172,7 +172,7 @@
     /** Assignment operator */
     interval_base_map& operator = (const interval_base_map& src)
     {
- this->_map = src._map;
+ this->_map = src._map;
         return *this;
     }
 
@@ -309,9 +309,9 @@
     SubType& add(const segment_type& interval_value_pair)
     { that()->template add_<codomain_combine>(interval_value_pair); return *that(); }
 
- /** Addition of an interval value pair \c interval_value_pair to the map.
- Iterator \c prior_ is a hint to the position \c interval_value_pair can be
- inserted after. */
+ /** Addition of an interval value pair \c interval_value_pair to the map.
+ Iterator \c prior_ is a hint to the position \c interval_value_pair can be
+ inserted after. */
     iterator add(iterator prior_, const segment_type& interval_value_pair)
     { return that()->template add_<codomain_combine>(prior_, interval_value_pair); }
 
@@ -411,34 +411,34 @@
     template<class SetSubType>
     SubType& erase(const interval_base_set<SetSubType,DomainT,Compare,Interval,Alloc>& operand)
     {
- typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> operand_type;
+ typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> operand_type;
 
- if(operand.empty())
- return *that();
+ if(operand.empty())
+ return *that();
 
- typename operand_type::const_iterator common_lwb;
- typename operand_type::const_iterator common_upb;
+ typename operand_type::const_iterator common_lwb;
+ typename operand_type::const_iterator common_upb;
 
- if(!Set::common_range(common_lwb, common_upb, operand, *this))
- return *that();
+ if(!Set::common_range(common_lwb, common_upb, operand, *this))
+ return *that();
 
- typename operand_type::const_iterator it_ = common_lwb;
- while(it_ != common_upb)
- erase(*it_++);
+ typename operand_type::const_iterator it_ = common_lwb;
+ while(it_ != common_upb)
+ erase(*it_++);
 
- return *that();
+ return *that();
     }
 
 
     /** Erase all value pairs from \c *this map that are elements of map \eraser */
     SubType& erase(const interval_base_map& eraser);
 
- /** Erase all value pairs within the range of the interval that iterator
- \c position points to. */
- void erase(iterator position){ _map.erase(position); }
+ /** Erase all value pairs within the range of the interval that iterator
+ \c position points to. */
+ void erase(iterator position){ _map.erase(position); }
 
- /** Erase all value pairs for a range of iterators <tt>[first,past)</tt>. */
- void erase(iterator first, iterator past){ _map.erase(first, past); }
+ /** Erase all value pairs for a range of iterators <tt>[first,past)</tt>. */
+ void erase(iterator first, iterator past){ _map.erase(first, past); }
 
     /** Remove all elements where property <tt>p</tt> holds, keep all others */
     template<class Predicate>
@@ -509,32 +509,32 @@
     )const;
 
 
- /** Returns \c true, if element \c key is found in \c *this map.
- Complexity: logarithmic. */
- bool intersects(const domain_type& key)const
- { return _map.find(interval_type(key)) != _map.end(); }
-
- /** Returns \c true, if \c inter_val intersects with \c *this map.
- Complexity: logarithmic. */
- bool intersects(const interval_type& inter_val)const
- { return _map.find(inter_val) != _map.end(); }
-
- /** 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
- {
- const_iterator found_ = _map.find(interval_type(key_value_pair.key));
- return found_ != _map.end() && found_->KEY_VALUE == key_value_pair.data;
- }
-
- /** Returns \c true, if \c interval_value_pair intersects with \c *this map:
- Complexity: logarithmic. */
- bool intersects(const segment_type& interval_value_pair)const
- {
- type intersection;
- add(intersection, interval_value_pair);
- return !intersection.empty();
- }
+ /** Returns \c true, if element \c key is found in \c *this map.
+ Complexity: logarithmic. */
+ bool intersects(const domain_type& key)const
+ { return _map.find(interval_type(key)) != _map.end(); }
+
+ /** Returns \c true, if \c inter_val intersects with \c *this map.
+ Complexity: logarithmic. */
+ bool intersects(const interval_type& inter_val)const
+ { return _map.find(inter_val) != _map.end(); }
+
+ /** 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
+ {
+ const_iterator found_ = _map.find(interval_type(key_value_pair.key));
+ return found_ != _map.end() && found_->KEY_VALUE == key_value_pair.data;
+ }
+
+ /** Returns \c true, if \c interval_value_pair intersects with \c *this map:
+ Complexity: logarithmic. */
+ bool intersects(const segment_type& interval_value_pair)const
+ {
+ type intersection;
+ add(intersection, interval_value_pair);
+ return !intersection.empty();
+ }
 
 
 
@@ -571,10 +571,10 @@
     const_iterator upper_bound(const key_type& interval)const
     { return _map.upper_bound(interval); }
 
- std::pair<iterator,iterator> equal_range(const key_type& interval)
+ std::pair<iterator,iterator> equal_range(const key_type& interval)
     { return _map.equal_range(interval); }
 
- std::pair<const_iterator,const_iterator> equal_range(const key_type& interval)const
+ std::pair<const_iterator,const_iterator> equal_range(const key_type& interval)const
     { return _map.equal_range(interval); }
 
     iterator begin() { return _map.begin(); }
@@ -676,7 +676,7 @@
 protected:
 
     iterator prior(iterator it_)
- { return it_ == this->_map.begin() ? this->_map.end() : --it_; }
+ { return it_ == this->_map.begin() ? this->_map.end() : --it_; }
 
     template <class Combiner>
     bool combine(iterator& it_, const codomain_type& co_val)
@@ -700,35 +700,35 @@
             return this->_map.insert(value_type(inter_val, co_val));
     }
 
- // Insertion with hint, that does report insertion failure
+ // Insertion with hint, that does report insertion failure
     template <class Combiner>
- std::pair<iterator, bool>
- map_insert(iterator prior_, const interval_type& inter_val, const codomain_type& co_val)
+ std::pair<iterator, bool>
+ map_insert(iterator prior_, const interval_type& inter_val, const codomain_type& co_val)
     {
- iterator inserted_
- = this->_map.insert(prior_, value_type(inter_val, Combiner::neutron()));
+ iterator inserted_
+ = this->_map.insert(prior_, value_type(inter_val, Combiner::neutron()));
 
- if(inserted_->KEY_VALUE == inter_val && inserted_->CONT_VALUE == Combiner::neutron())
- {
- Combiner()(inserted_->CONT_VALUE, co_val);
- return std::pair<iterator,bool>(inserted_, true);
- }
- else
- return std::pair<iterator,bool>(inserted_, false);
+ if(inserted_->KEY_VALUE == inter_val && inserted_->CONT_VALUE == Combiner::neutron())
+ {
+ Combiner()(inserted_->CONT_VALUE, co_val);
+ return std::pair<iterator,bool>(inserted_, true);
+ }
+ else
+ return std::pair<iterator,bool>(inserted_, false);
     }
 
     template <class Combiner>
     iterator gap_insert(iterator prior_, const interval_type& inter_val, const codomain_type& co_val)
     {
- // inter_val is not conained in this map. Insertion will be successful
- BOOST_ASSERT(this->_map.find(inter_val) == this->_map.end());
- BOOST_ASSERT(!(Traits::absorbs_neutrons && co_val==Combiner::neutron()));
+ // inter_val is not conained in this map. Insertion will be successful
+ BOOST_ASSERT(this->_map.find(inter_val) == this->_map.end());
+ BOOST_ASSERT(!(Traits::absorbs_neutrons && co_val==Combiner::neutron()));
 
         if(Traits::is_total)
         {
             iterator inserted_ = this->_map.insert(prior_, value_type(inter_val, Combiner::neutron()));
             Combiner()(inserted_->CONT_VALUE, co_val);
- return inserted_;
+ return inserted_;
         }
         else
             return this->_map.insert(prior_, value_type(inter_val, co_val));
@@ -846,34 +846,34 @@
     {
         interval_type sectant_interval = sectant.KEY_VALUE;
         if(sectant_interval.empty())
- return;
+ return;
 
         const_iterator first_ = _map.lower_bound(sectant_interval);
         const_iterator end_ = _map.upper_bound(sectant_interval);
 
- const_iterator it_;
- iterator prior_ = section.end();
+ const_iterator it_;
+ iterator prior_ = section.end();
 
- if(is_set<CodomainT>::value)
- for(it_=first_; it_ != end_; it_++)
- {
- interval_type common_interval = it_->KEY_VALUE & sectant_interval;
- if(!common_interval.empty())
- {
- section.that()->add(value_type(common_interval, it_->CONT_VALUE));
- section.that()->template add<codomain_intersect>(value_type(common_interval, sectant.CONT_VALUE));
- }
- }
- else
- for(it_=first_; it_ != end_; it_++)
- {
- interval_type common_interval = it_->KEY_VALUE & sectant_interval;
- if(!common_interval.empty())
- {
- section.that()->add(value_type(common_interval, it_->CONT_VALUE) );
- section.that()->template add<codomain_combine>(value_type(common_interval, sectant.CONT_VALUE));
- }
- }
+ if(is_set<CodomainT>::value)
+ for(it_=first_; it_ != end_; it_++)
+ {
+ interval_type common_interval = it_->KEY_VALUE & sectant_interval;
+ if(!common_interval.empty())
+ {
+ section.that()->add(value_type(common_interval, it_->CONT_VALUE));
+ section.that()->template add<codomain_intersect>(value_type(common_interval, sectant.CONT_VALUE));
+ }
+ }
+ else
+ for(it_=first_; it_ != end_; it_++)
+ {
+ interval_type common_interval = it_->KEY_VALUE & sectant_interval;
+ if(!common_interval.empty())
+ {
+ section.that()->add(value_type(common_interval, it_->CONT_VALUE) );
+ section.that()->template add<codomain_combine>(value_type(common_interval, sectant.CONT_VALUE));
+ }
+ }
 
     }
 }
@@ -894,7 +894,7 @@
     typename ImplMapT::const_iterator first_ = _map.lower_bound(sectant_interval);
     typename ImplMapT::const_iterator end_ = _map.upper_bound(sectant_interval);
 
- iterator prior_ = section.end();
+ iterator prior_ = section.end();
     for(typename ImplMapT::const_iterator it_=first_; it_ != end_; it_++)
     {
         interval_type common_interval = it_->KEY_VALUE & sectant_interval;
@@ -1082,12 +1082,12 @@
 
             // finally we arrive at the end of a sequence of joinable intervals
             // and it points to the last member of that sequence
- const_cast<interval_type&>(it_->KEY_VALUE).extend(fst_mem->KEY_VALUE);
+ const_cast<interval_type&>(it_->KEY_VALUE).extend(fst_mem->KEY_VALUE);
             _map.erase(fst_mem, it_);
 
             it_++; next_=it_;
- if(next_!=_map.end())
- next_++;
+ if(next_!=_map.end())
+ next_++;
         }
         else { it_++; next_++; }
     }

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-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -116,7 +116,7 @@
     /// const_iterator for iteration over intervals
     typedef typename ImplSetT::const_reverse_iterator const_reverse_iterator;
 
- enum { fineness = 4 }; //SubType::fineness };
+ enum { fineness = 4 }; //SubType::fineness };
 
 public:
     //==========================================================================
@@ -126,12 +126,12 @@
     interval_base_set(){}
 
     /** Copy constructor */
- interval_base_set(const interval_base_set& src): _set(src._set){}
+ interval_base_set(const interval_base_set& src): _set(src._set){}
 
     /** Assignment operator */
     interval_base_set& operator = (const interval_base_set& src)
     {
- this->_set = src._set;
+ this->_set = src._set;
         return *this;
     }
 
@@ -245,9 +245,9 @@
     SubType& add(const segment_type& inter_val)
     { that()->add_(inter_val); return *that(); }
 
- /** Add an interval of elements \c inter_val to the set. Iterator
- \c prior_ is a hint to the position \c inter_val can be
- inserted after. */
+ /** Add an interval of elements \c inter_val to the set. Iterator
+ \c prior_ is a hint to the position \c inter_val can be
+ inserted after. */
     iterator add(iterator prior_, const segment_type& inter_val)
     { return that()->add_(prior_, inter_val); }
 
@@ -283,11 +283,11 @@
     SubType& erase(const segment_type& inter_val)
     { return subtract(inter_val); }
 
- /** Erase the interval that iterator \c position points to. */
- void erase(iterator position){ _set.erase(position); }
+ /** Erase the interval that iterator \c position points to. */
+ void erase(iterator position){ _set.erase(position); }
 
- /** Erase all intervals in the range <tt>[first,past)</tt> of iterators. */
- void erase(iterator first, iterator past){ _set.erase(first, past); }
+ /** Erase all intervals in the range <tt>[first,past)</tt> of iterators. */
+ void erase(iterator first, iterator past){ _set.erase(first, past); }
 
 
     //==========================================================================
@@ -317,15 +317,15 @@
     )const;
 
 
- /** Returns \c true, if element \c key is found in \c *this map.
- Complexity: logarithmic. */
- bool intersects(const element_type& key)const
- { return _set.find(interval_type(key)) != _set.end(); }
-
- /** Returns \c true, if \c inter_val intersects with \c *this map.
- Complexity: logarithmic. */
- bool intersects(const interval_type& inter_val)const
- { return _set.find(inter_val) != _set.end(); }
+ /** Returns \c true, if element \c key is found in \c *this map.
+ Complexity: logarithmic. */
+ bool intersects(const element_type& key)const
+ { return _set.find(interval_type(key)) != _set.end(); }
+
+ /** Returns \c true, if \c inter_val intersects with \c *this map.
+ Complexity: logarithmic. */
+ bool intersects(const interval_type& inter_val)const
+ { return _set.find(inter_val) != _set.end(); }
 
     //==========================================================================
     //= Symmetric difference
@@ -368,10 +368,10 @@
     const_iterator upper_bound(const value_type& interval)const
     { return _set.upper_bound(interval); }
 
- std::pair<iterator,iterator> equal_range(const key_type& interval)
+ std::pair<iterator,iterator> equal_range(const key_type& interval)
     { return _set.equal_range(interval); }
 
- std::pair<const_iterator,const_iterator> equal_range(const key_type& interval)const
+ std::pair<const_iterator,const_iterator> equal_range(const key_type& interval)const
     { return _set.equal_range(interval); }
 
     //==========================================================================
@@ -430,8 +430,8 @@
 
     iterator gap_insert(iterator prior_, const interval_type& inter_val)
     {
- // inter_val is not conained in this map. Insertion will be successful
- BOOST_ASSERT(this->_set.find(inter_val) == this->_set.end());
+ // inter_val is not conained in this map. Insertion will be successful
+ BOOST_ASSERT(this->_set.find(inter_val) == this->_set.end());
         return this->_set.insert(prior_, inter_val);
     }
 
@@ -485,13 +485,13 @@
     const_iterator first_ = _set.lower_bound(inter_val);
     const_iterator end_ = _set.upper_bound(inter_val);
 
- iterator prior_ = section.end();
+ iterator prior_ = section.end();
     for(const_iterator it_=first_; it_ != end_; it_++)
- {
- interval_type common_interval = (*it_) & inter_val;
- if(!common_interval.empty())
- prior_ = section.gap_insert(prior_, common_interval);
- }
+ {
+ interval_type common_interval = (*it_) & inter_val;
+ if(!common_interval.empty())
+ prior_ = section.gap_insert(prior_, common_interval);
+ }
 }
 
 
@@ -629,12 +629,12 @@
 
             // finally we arrive at the end of a sequence of joinable intervals
             // and it points to the last member of that sequence
- const_cast<interval_type&>(*it_).extend(*fst_mem);
+ const_cast<interval_type&>(*it_).extend(*fst_mem);
             _set.erase(fst_mem, it_);
 
             it_++; next_=it_;
- if(next_!=_set.end())
- next_++;
+ if(next_!=_set.end())
+ next_++;
         }
         else { it_++; next_++; }
     }

Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2009-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -102,7 +102,7 @@
                                   Traits,Compare,Combine,Section,Interval,Alloc> base_map_type;
         this->clear();
         // Can be implemented via _map.insert: Interval joining not necessary.
- iterator prior_ = this->_map.end();
+ iterator prior_ = this->_map.end();
         const_FORALL(typename base_map_type, it_, src)
             prior_ = this->add(prior_, *it_);
     }
@@ -328,17 +328,17 @@
     else
     {
         // Detect the first and the end iterator of the collision sequence
- std::pair<iterator,iterator> overlap = this->_map.equal_range(inter_val);
+ std::pair<iterator,iterator> overlap = this->_map.equal_range(inter_val);
         iterator it_ = overlap.first,
- last_ = overlap.second;
- --last_;
+ last_ = overlap.second;
+ --last_;
         interval_type rest_interval = inter_val;
 
         add_front (rest_interval, co_val, it_);
         add_main<Combiner>(rest_interval, co_val, it_, last_);
         add_rear<Combiner>(rest_interval, co_val, it_);
 
- return it_;
+ return it_;
     }
 }
 
@@ -464,10 +464,10 @@
             Combiner()(it_->CONT_VALUE, co_val);
 
             if(Traits::absorbs_neutrons && it_->CONT_VALUE == Combiner::neutron())
- {
+ {
                 this->_map.erase(it_);
- it_ = prior_;
- }
+ it_ = prior_;
+ }
             else
                 join_neighbours(it_);
         }
@@ -486,10 +486,10 @@
             Combiner()(it_->CONT_VALUE, co_val);
 
             if(Traits::absorbs_neutrons && it_->CONT_VALUE == Combiner::neutron())
- {
+ {
                 this->_map.erase(it_);
- it_ = insertion_;
- }
+ it_ = insertion_;
+ }
             else
                 join_neighbours(it_);
         }

Modified: sandbox/itl/boost/itl/interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_set.hpp 2009-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -121,7 +121,7 @@
         typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> base_set_type;
         this->clear();
         // Has to be implemented via add. there might be touching borders to be joined
- iterator prior_ = this->_set.end();
+ iterator prior_ = this->_set.end();
         const_FORALL(typename base_set_type, it_, src)
             prior_ = this->add(prior_, *it_);
     }
@@ -199,11 +199,11 @@
                 // it's a non border element that might have two touching neighbours
                 if((*it_extended).touches(*succ_))
                     return join_on_left(it_extended, succ_);
- else
- return it_extended;
+ else
+ return it_extended;
             }
- else
- return it_extended;
+ else
+ return it_extended;
         }
         else
         {
@@ -217,7 +217,7 @@
         }
     }
 
- return it_;
+ return it_;
 }
 
 
@@ -274,7 +274,7 @@
     interval_set<DomainT,Compare,Interval,Alloc>::add_(iterator prior_, const value_type& addend)
 {
     if(addend.empty())
- return prior_;
+ return prior_;
 
     iterator insertion = this->_set.insert(prior_, addend);
 
@@ -282,7 +282,7 @@
         return handle_neighbours(insertion);
     else
     {
- std::pair<iterator,iterator> overlap = this->_set.equal_range(addend);
+ std::pair<iterator,iterator> overlap = this->_set.equal_range(addend);
         iterator first_ = overlap.first,
                  end_ = overlap.second,
                  last_ = end_; --last_;

Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2009-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -222,9 +222,9 @@
     map& add(const value_type& value_pair) { return add<codomain_combine>(value_pair); }
 
     /** \c add add \c value_pair into the map using \c prior as a hint to
- insert \c value_pair after the position \c prior is pointing to. */
+ insert \c value_pair after the position \c prior is pointing to. */
     iterator add(iterator prior, const value_type& value_pair)
- { return add<codomain_combine>(prior, value_pair); }
+ { return add<codomain_combine>(prior, value_pair); }
 
     /** If the \c value_pair's key value is in the map, it's data value is
         subtraced from the data value stored in the map. */
@@ -378,20 +378,20 @@
     template <class Combiner>
 typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::iterator
     map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
- ::add(iterator prior_, const value_type& val)
+ ::add(iterator prior_, const value_type& val)
 {
     if(Traits::absorbs_neutrons && val.CONT_VALUE == Combiner::neutron())
         return prior_;
 
- iterator inserted_ = insert(prior_, value_type(val.KEY_VALUE, Combiner::neutron()));
- Combiner()(inserted_->CONT_VALUE, val.CONT_VALUE);
+ iterator inserted_ = insert(prior_, value_type(val.KEY_VALUE, Combiner::neutron()));
+ Combiner()(inserted_->CONT_VALUE, val.CONT_VALUE);
     if(Traits::absorbs_neutrons && inserted_->CONT_VALUE == Combiner::neutron())
- {
+ {
         erase(inserted_);
- return prior_;
- }
- else
- return inserted_;
+ return prior_;
+ }
+ else
+ return inserted_;
 }
 
 
@@ -673,7 +673,7 @@
 operator += ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
              const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
 {
- return Set::add(object, operand);
+ return Set::add(object, operand);
 }
 
 
@@ -718,7 +718,7 @@
 operator |= ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
              const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
 {
- return Set::add(object, operand);
+ return Set::add(object, operand);
 }
 
 
@@ -762,7 +762,7 @@
 operator -= ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
     const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::set_type& operand)
 {
- return Set::erase(object, operand);
+ return Set::erase(object, operand);
 }
 
 
@@ -808,8 +808,8 @@
 operator &= ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
     const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::set_type& operand)
 {
- Map::intersect(object, operand);
- return object;
+ Map::intersect(object, operand);
+ return object;
 }
 
 

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-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -115,8 +115,8 @@
     template<class SubType>
     void assign(const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
     {
- this->clear();
- this->_set.insert(src.begin(), src.end());
+ this->clear();
+ this->_set.insert(src.begin(), src.end());
     }
 
 private:
@@ -186,7 +186,7 @@
     separate_interval_set<DomainT,Compare,Interval,Alloc>::add_(iterator prior_, const value_type& addend)
 {
     if(addend.empty())
- return prior_;
+ return prior_;
 
     iterator insertion = this->_set.insert(prior_, addend);
 
@@ -194,7 +194,7 @@
         return insertion;
     else
     {
- std::pair<iterator,iterator> overlap = this->_set.equal_range(addend);
+ std::pair<iterator,iterator> overlap = this->_set.equal_range(addend);
         iterator first_ = overlap.first,
                  end_ = overlap.second,
                  last_ = end_; --last_;

Modified: sandbox/itl/boost/itl/set.hpp
==============================================================================
--- sandbox/itl/boost/itl/set.hpp (original)
+++ sandbox/itl/boost/itl/set.hpp 2009-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -152,9 +152,9 @@
     /** Add an \c element to the set. */
     set& add(const element_type& element) { insert(element); return *this; }
 
- /** Add an element \c element after \c prior to the set. */
+ /** Add an element \c element after \c prior to the set. */
     iterator add(iterator prior, const element_type& element)
- { return insert(prior, element); }
+ { return insert(prior, element); }
 
     /** Subtract an \c element from the set. */
     set& subtract(const element_type& element);
@@ -171,7 +171,7 @@
     //= Intersection, symmetric difference
     //==========================================================================
 
- /** Add \c element to \c section, if \c element is in \c *this set */
+ /** Add \c element to \c section, if \c element is in \c *this set */
     void add_intersection(set& section, const element_type& element)const;
 
     /** The intersection of set \c sectant with \c *this set is added

Modified: sandbox/itl/boost/itl/set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/set_algo.hpp (original)
+++ sandbox/itl/boost/itl/set_algo.hpp 2009-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -66,9 +66,9 @@
                 return result;
 
             typedef typename ObjectT::const_iterator Object_const_iterator;
- typename ObjectT::iterator prior_ = result.end();
+ typename ObjectT::iterator prior_ = result.end();
             for(Object_const_iterator x2_ = x2.begin(); x2_ != x2.end(); x2_++)
- prior_ = result.add(prior_, *x2_);
+ prior_ = result.add(prior_, *x2_);
 
             return result;
         }
@@ -135,7 +135,7 @@
             return true;
         }
 
- template<class SetType>
+ template<class SetType>
         bool intersects(const SetType& left, const SetType& right)
         {
             typename SetType::const_iterator common_lwb_right_;
@@ -150,16 +150,16 @@
             {
                 found_ = left.find(*right_++);
                 if(found_ != left.end())
- return true; // found a common element
+ return true; // found a common element
             }
             // found no common element
             return false;
         }
 
- template<class SetType>
+ template<class SetType>
         inline bool is_disjoint(const SetType& left, const SetType& right)
         {
- return !intersects(left, right);
+ return !intersects(left, right);
         }
 
 

Modified: sandbox/itl/boost/itl/split_interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_map.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_map.hpp 2009-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -87,8 +87,8 @@
     void assign(const interval_base_map<SubType,DomainT,CodomainT,
                                         Traits,Compare,Combine,Section,Interval,Alloc>& src)
     {
- this->clear();
- this->_map.insert(src.begin(), src.end());
+ this->clear();
+ this->_map.insert(src.begin(), src.end());
     }
 
     //==========================================================================
@@ -201,7 +201,7 @@
         add_front (rest_interval, co_val, it_);
         add_main<Combiner>(rest_interval, co_val, it_, last_);
         add_rear<Combiner>(rest_interval, co_val, it_);
- }
+ }
 }
 
 template <typename DomainT, typename CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
@@ -222,21 +222,21 @@
         = this->template map_insert<Combiner>(prior_, inter_val, co_val);
 
     if(insertion.WAS_SUCCESSFUL)
- return insertion.ITERATOR;
- else
+ return insertion.ITERATOR;
+ else
     {
         // Detect the first and the end iterator of the collision sequence
- std::pair<iterator,iterator> overlap = this->_map.equal_range(inter_val);
+ std::pair<iterator,iterator> overlap = this->_map.equal_range(inter_val);
         iterator it_ = overlap.first,
- last_ = overlap.second;
- --last_;
+ last_ = overlap.second;
+ --last_;
         interval_type rest_interval = inter_val;
 
         add_front (rest_interval, co_val, it_);
         add_main<Combiner>(rest_interval, co_val, it_, last_);
         add_rear<Combiner>(rest_interval, co_val, it_);
 
- return it_;
+ return it_;
     }
 }
 
@@ -315,7 +315,7 @@
 
     interval_type lead_gap = right_subtract(inter_val, cur_itv);
     if(!lead_gap.empty())
- // [lead_gap--- . . .
+ // [lead_gap--- . . .
         // [prior_) [-- it_ ...
         this->template gap_insert<Combiner>(prior_, lead_gap, co_val);
     
@@ -347,10 +347,10 @@
             Combiner()(it_->CONT_VALUE, co_val);
 
             if(Traits::absorbs_neutrons && it_->CONT_VALUE == Combiner::neutron())
- {
+ {
                 this->_map.erase(it_);
- it_ = prior_;
- }
+ it_ = prior_;
+ }
         }
         else
         {
@@ -368,7 +368,7 @@
             if(Traits::absorbs_neutrons && it_->CONT_VALUE == Combiner::neutron())
                 this->_map.erase(it_);
 
- it_ = insertion_;
+ it_ = insertion_;
         }
     }
 }

Modified: sandbox/itl/boost/itl/split_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_set.hpp 2009-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -112,8 +112,8 @@
     template<class SubType>
     void assign(const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& src)
     {
- this->clear();
- this->_set.insert(src.begin(), src.end());
+ this->clear();
+ this->_set.insert(src.begin(), src.end());
     }
     
 private:
@@ -126,7 +126,7 @@
 
     /// Insertion of an interval <tt>x</tt>
     void add_(const value_type& x);
- iterator add_(iterator prior_, const value_type& x);
+ iterator add_(iterator prior_, const value_type& x);
 
     /// Removal of an interval <tt>x</tt>
     void subtract_(const value_type& x);
@@ -183,7 +183,7 @@
     split_interval_set<DomainT,Compare,Interval,Alloc>::add_(iterator prior_, const value_type& addend)
 {
     if(addend.empty())
- return prior_;
+ return prior_;
 
     iterator insertion = this->_set.insert(prior_, addend);
 
@@ -191,7 +191,7 @@
         return insertion;
     else
     {
- std::pair<iterator,iterator> overlap = this->_set.equal_range(addend);
+ std::pair<iterator,iterator> overlap = this->_set.equal_range(addend);
         iterator first_ = overlap.first,
                  end_ = overlap.second,
                  last_ = end_; --last_;
@@ -203,7 +203,7 @@
         add_main (rest_interval, it_, last_);
         add_rear (rest_interval, it_);
 
- return it_;
+ return it_;
     }
 }
 
@@ -274,7 +274,7 @@
 
     interval_type lead_gap = right_subtract(inter_val, cur_itv);
     if(!lead_gap.empty())
- // [lead_gap--- . . .
+ // [lead_gap--- . . .
         // [prior_) [-- it_ ...
         this->_set.insert(prior_, lead_gap);
     

Modified: sandbox/itl/boost/itl/type_traits/is_combinable.hpp
==============================================================================
--- sandbox/itl/boost/itl/type_traits/is_combinable.hpp (original)
+++ sandbox/itl/boost/itl/type_traits/is_combinable.hpp 2009-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -45,7 +45,7 @@
 template<template<class>class IsConcept, class LeftT, class RightT>
 struct is_concept_equivalent
 {
- typedef is_concept_equivalent<IsConcept, LeftT, RightT> type;
+ typedef is_concept_equivalent<IsConcept, LeftT, RightT> type;
     static const bool value =
         mpl::and_<IsConcept<LeftT>, IsConcept<RightT> >::value;
 };
@@ -54,29 +54,29 @@
 template<class LeftT, class RightT>
 struct is_codomain_equal
 {
- typedef is_codomain_equal<LeftT, RightT> type;
- static const bool value =
- is_same<typename LeftT::codomain_type,
- typename RightT::codomain_type>::value;
+ typedef is_codomain_equal<LeftT, RightT> type;
+ static const bool value =
+ is_same<typename LeftT::codomain_type,
+ typename RightT::codomain_type>::value;
 };
 
 //NOTE: Equality of compare order implies the equality of the domain_types
 template<class LeftT, class RightT>
 struct is_domain_compare_equal
 {
- typedef is_domain_compare_equal<LeftT, RightT> type;
- static const bool value =
- is_same<typename LeftT::domain_compare,
- typename RightT::domain_compare>::value;
+ typedef is_domain_compare_equal<LeftT, RightT> type;
+ static const bool value =
+ is_same<typename LeftT::domain_compare,
+ typename RightT::domain_compare>::value;
 };
 
 template<class LeftT, class RightT>
 struct is_content_type_equal
 {
- typedef is_content_type_equal<LeftT, RightT> type;
- static const bool value =
- mpl::and_<is_domain_compare_equal<LeftT, RightT>,
- is_codomain_equal<LeftT, RightT> >::value;//JODO
+ typedef is_content_type_equal<LeftT, RightT> type;
+ static const bool value =
+ mpl::and_<is_domain_compare_equal<LeftT, RightT>,
+ is_codomain_equal<LeftT, RightT> >::value;//JODO
 };
 
 
@@ -84,39 +84,39 @@
 template<template<class>class IsConcept, class LeftT, class RightT>
 struct is_concept_compatible
 {
- typedef is_concept_compatible<IsConcept, LeftT, RightT> type;
- static const bool value =
- mpl::and_
- <
- mpl::and_<IsConcept<LeftT>, IsConcept<RightT> >
- , is_content_type_equal<LeftT, RightT>
- >::value;
+ typedef is_concept_compatible<IsConcept, LeftT, RightT> type;
+ static const bool value =
+ mpl::and_
+ <
+ mpl::and_<IsConcept<LeftT>, IsConcept<RightT> >
+ , is_content_type_equal<LeftT, RightT>
+ >::value;
 };
 
 template<template<class>class LeftConcept,
          template<class>class RightConcept,
- class LeftT, class RightT>
+ class LeftT, class RightT>
 struct is_concept_combinable
 {
- typedef is_concept_combinable<LeftConcept, RightConcept, LeftT, RightT> type;
- static const bool value =
- mpl::and_
- <
- mpl::and_<LeftConcept<LeftT>, RightConcept<RightT> >
- , is_domain_compare_equal<LeftT, RightT>
- >::value;
+ typedef is_concept_combinable<LeftConcept, RightConcept, LeftT, RightT> type;
+ static const bool value =
+ mpl::and_
+ <
+ mpl::and_<LeftConcept<LeftT>, RightConcept<RightT> >
+ , is_domain_compare_equal<LeftT, RightT>
+ >::value;
 };
 
 template<class LeftT, class RightT>
 struct is_intra_combinable
 {
- typedef is_intra_combinable<LeftT, RightT> type;
- static const bool value =
- mpl::or_
- <
- is_concept_compatible<is_interval_set, LeftT, RightT>
- , is_concept_compatible<is_interval_map, LeftT, RightT>
- >::value;
+ typedef is_intra_combinable<LeftT, RightT> type;
+ static const bool value =
+ mpl::or_
+ <
+ is_concept_compatible<is_interval_set, LeftT, RightT>
+ , is_concept_compatible<is_interval_map, LeftT, RightT>
+ >::value;
 };
 
 //------------------------------------------------------------------------------
@@ -126,22 +126,22 @@
 template<class LeftT, class RightT>
 struct is_cross_combinable
 {
- typedef is_cross_combinable<LeftT, RightT> type;
- static const bool value =
- mpl::or_
- <
- is_concept_combinable<is_interval_set, is_interval_map, LeftT, RightT>
- , is_concept_combinable<is_interval_map, is_interval_set, LeftT, RightT>
- >::value;
+ typedef is_cross_combinable<LeftT, RightT> type;
+ static const bool value =
+ mpl::or_
+ <
+ is_concept_combinable<is_interval_set, is_interval_map, LeftT, RightT>
+ , is_concept_combinable<is_interval_map, is_interval_set, LeftT, RightT>
+ >::value;
 };
 
 template<class LeftT, class RightT>
 struct is_inter_combinable
 {
- typedef is_inter_combinable<LeftT, RightT> type;
- static const bool value =
- mpl::or_<is_intra_combinable<LeftT,RightT>,
- is_cross_combinable<LeftT,RightT> >::value;
+ typedef is_inter_combinable<LeftT, RightT> type;
+ static const bool value =
+ mpl::or_<is_intra_combinable<LeftT,RightT>,
+ is_cross_combinable<LeftT,RightT> >::value;
 };
 
 //------------------------------------------------------------------------------
@@ -227,11 +227,11 @@
 {
     typedef is_cross_derivative<Type, AssociateT> type;
     static const bool value =
- mpl::and_
- <
+ mpl::and_
+ <
             is_interval_map<Type>
           , is_interval_set_derivative<Type, AssociateT>
- >::value;
+ >::value;
 };
 
 template<class Type, class AssociateT>
@@ -239,11 +239,11 @@
 {
     typedef is_inter_derivative<Type, AssociateT> type;
     static const bool value =
- mpl::or_
- <
+ mpl::or_
+ <
             is_intra_derivative<Type, AssociateT>
           , is_cross_derivative<Type, AssociateT>
- >::value;
+ >::value;
 };
 
 //------------------------------------------------------------------------------
@@ -255,15 +255,15 @@
 {
     typedef is_interval_set_right_combinable<GuideT, CompanionT> type;
     static const bool value =
- mpl::and_
- <
- is_interval_set<GuideT>
- , mpl::or_
- <
- is_interval_set_derivative<GuideT, CompanionT>
- , is_concept_compatible<is_interval_set, GuideT, CompanionT>
- >
- >::value;
+ mpl::and_
+ <
+ is_interval_set<GuideT>
+ , mpl::or_
+ <
+ is_interval_set_derivative<GuideT, CompanionT>
+ , is_concept_compatible<is_interval_set, GuideT, CompanionT>
+ >
+ >::value;
 };
 
 template<class GuideT, class CompanionT>
@@ -271,15 +271,15 @@
 {
     typedef is_interval_map_right_intra_combinable<GuideT, CompanionT> type;
     static const bool value =
- mpl::and_
- <
- is_interval_map<GuideT>
- , mpl::or_
- <
- is_interval_map_derivative<GuideT, CompanionT>
- , is_concept_compatible<is_interval_map, GuideT, CompanionT>
- >
- >::value;
+ mpl::and_
+ <
+ is_interval_map<GuideT>
+ , mpl::or_
+ <
+ is_interval_map_derivative<GuideT, CompanionT>
+ , is_concept_compatible<is_interval_map, GuideT, CompanionT>
+ >
+ >::value;
 };
 
 template<class GuideT, class CompanionT>
@@ -287,15 +287,15 @@
 {
     typedef is_interval_map_right_cross_combinable<GuideT, CompanionT> type;
     static const bool value =
- mpl::and_
- <
- is_interval_map<GuideT>
- , mpl::or_
- <
- is_cross_derivative<GuideT, CompanionT>
- , is_concept_combinable<is_interval_map, is_interval_set, GuideT, CompanionT>
- >
- >::value;
+ mpl::and_
+ <
+ is_interval_map<GuideT>
+ , mpl::or_
+ <
+ is_cross_derivative<GuideT, CompanionT>
+ , is_concept_combinable<is_interval_map, is_interval_set, GuideT, CompanionT>
+ >
+ >::value;
 };
 
 template<class GuideT, class CompanionT>
@@ -303,11 +303,11 @@
 {
     typedef is_interval_map_right_inter_combinable<GuideT, CompanionT> type;
     static const bool value =
- mpl::or_
- <
- is_interval_map_right_intra_combinable<GuideT, CompanionT>
- , is_interval_map_right_cross_combinable<GuideT, CompanionT>
- >::value;
+ mpl::or_
+ <
+ is_interval_map_right_intra_combinable<GuideT, CompanionT>
+ , is_interval_map_right_cross_combinable<GuideT, CompanionT>
+ >::value;
 };
 
 
@@ -316,11 +316,11 @@
 {
     typedef is_right_intra_combinable<GuideT, CompanionT> type;
     static const bool value =
- mpl::or_
- <
- is_interval_set_right_combinable<GuideT, CompanionT>
- , is_interval_map_right_intra_combinable<GuideT, CompanionT>
- >::value;
+ mpl::or_
+ <
+ is_interval_set_right_combinable<GuideT, CompanionT>
+ , is_interval_map_right_intra_combinable<GuideT, CompanionT>
+ >::value;
 };
 
 template<class GuideT, class CompanionT>
@@ -328,11 +328,11 @@
 {
     typedef is_right_inter_combinable<GuideT, CompanionT> type;
     static const bool value =
- mpl::or_
- <
- is_interval_set_right_combinable<GuideT, CompanionT>
- , is_interval_map_right_inter_combinable<GuideT, CompanionT>
- >::value;
+ mpl::or_
+ <
+ is_interval_set_right_combinable<GuideT, CompanionT>
+ , is_interval_map_right_inter_combinable<GuideT, CompanionT>
+ >::value;
 };
 
 template<class GuideT, class IntervalSetT>
@@ -340,8 +340,8 @@
 {
     typedef combines_right_to_interval_set<GuideT, IntervalSetT> type;
     static const bool value =
- is_concept_combinable<is_interval_container, is_interval_set,
- GuideT, IntervalSetT>::value;
+ is_concept_combinable<is_interval_container, is_interval_set,
+ GuideT, IntervalSetT>::value;
 };
 
 template<class GuideT, class IntervalMapT>
@@ -349,7 +349,7 @@
 {
     typedef combines_right_to_interval_map<GuideT, IntervalMapT> type;
     static const bool value =
- is_concept_compatible<is_interval_map, GuideT, IntervalMapT>::value;
+ is_concept_compatible<is_interval_map, GuideT, IntervalMapT>::value;
 };
 
 template<class GuideT, class IntervalContainerT>
@@ -357,8 +357,8 @@
 {
     typedef combines_right_to_interval_container<GuideT, IntervalContainerT> type;
     static const bool value =
- mpl::or_<combines_right_to_interval_set<GuideT, IntervalContainerT>,
- combines_right_to_interval_map<GuideT, IntervalContainerT> >::value;
+ mpl::or_<combines_right_to_interval_set<GuideT, IntervalContainerT>,
+ combines_right_to_interval_map<GuideT, IntervalContainerT> >::value;
 };
 
 
@@ -399,11 +399,11 @@
 {
     typedef is_interval_set_companion<GuideT,CompanionT> type;
     static const bool value =
- mpl::or_
- <
+ mpl::or_
+ <
             combines_right_to_interval_set<GuideT,CompanionT>
           , is_interval_set_derivative<GuideT,CompanionT>
- >::value;
+ >::value;
 };
 
 
@@ -415,11 +415,11 @@
 {
     typedef is_interval_map_companion<GuideT,CompanionT> type;
     static const bool value =
- mpl::or_
- <
+ mpl::or_
+ <
             combines_right_to_interval_map<GuideT,CompanionT>
           , is_interval_map_derivative<GuideT,CompanionT>
- >::value;
+ >::value;
 };
 
 
@@ -453,7 +453,7 @@
 struct is_binary_interval_set_combinable
 {
     typedef is_binary_interval_set_combinable<GuideT,CompanionT> type;
- static const int value =
+ static const int value =
         mpl::and_< is_interval_set<GuideT>
                   , is_coarser_interval_set_companion<GuideT, CompanionT>
>::value;
@@ -463,7 +463,7 @@
 struct is_binary_interval_map_combinable
 {
     typedef is_binary_interval_map_combinable<GuideT,CompanionT> type;
- static const int value =
+ static const int value =
         mpl::and_< is_interval_map<GuideT>
                   , is_coarser_interval_map_companion<GuideT, CompanionT>
>::value;

Modified: sandbox/itl/boost/validate/driver/itl_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/itl_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/itl_driver.hpp 2009-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -46,10 +46,10 @@
     class itl_driver
     {
     public:
- itl_driver()
- {
- _laws_per_cycle = GentorProfileSgl::it()->laws_per_cycle();
- }
+ itl_driver()
+ {
+ _laws_per_cycle = GentorProfileSgl::it()->laws_per_cycle();
+ }
 
         bool hasValidProfile()const { return _isValid; }
 
@@ -86,26 +86,26 @@
         {
             std::cout << "------------------------------------------------------------------------------" << std::endl;
             int valid_count = 1;
- double avg_evaluation_time = 0.0;
- long instance_count = 0;
+ double avg_evaluation_time = 0.0;
+ long instance_count = 0;
             FORALL(ValidationCounterT, it, _frequencies)
             {
- long law_validation_count = it->CONT_VALUE.count();
- double avg_law_evaluation_time =
- it->CONT_VALUE.time()/(law_validation_count);
+ long law_validation_count = it->CONT_VALUE.count();
+ double avg_law_evaluation_time =
+ it->CONT_VALUE.time()/(law_validation_count);
                 printf("%3d %-58s%9d%7.0lf\n",
- valid_count, it->KEY_VALUE.c_str(), law_validation_count, avg_law_evaluation_time);
+ valid_count, it->KEY_VALUE.c_str(), law_validation_count, avg_law_evaluation_time);
 
- avg_evaluation_time += avg_law_evaluation_time;
- instance_count += law_validation_count;
+ avg_evaluation_time += avg_law_evaluation_time;
+ instance_count += law_validation_count;
                 valid_count++;
             }
 
             std::cout << "------------------------------------------------------------------------------" << std::endl;
- // Summary for the current cycle
- double avg_evaluation_time_per_law = avg_evaluation_time/_frequencies.size();
+ // Summary for the current cycle
+ double avg_evaluation_time_per_law = avg_evaluation_time/_frequencies.size();
             printf( " %10.3lf%-50s%7d%7.0lf\n",
- avg_evaluation_time_per_law, " ", instance_count, avg_evaluation_time_per_law);
+ avg_evaluation_time_per_law, " ", instance_count, avg_evaluation_time_per_law);
 
             int violation_count = 1;
             FORALL(ViolationMapT, it, _violations)
@@ -145,9 +145,9 @@
 
     protected:
         void setValid(bool truth)
- {
- _isValid = truth;
- }
+ {
+ _isValid = truth;
+ }
 
         void setRootTypeNames()
         {
@@ -207,9 +207,9 @@
         ViolationMapT _violations;
         bool _isValid;
 
- int _laws_per_cycle; // After _laws_per_cycle times a cycle is
- // done and times and frequencies of law
- // validations are reported for all instances.
+ int _laws_per_cycle; // After _laws_per_cycle times a cycle is
+ // done and times and frequencies of law
+ // validations are reported for all instances.
     };
 
 

Modified: sandbox/itl/boost/validate/gentor/gentorprofile.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/gentorprofile.hpp (original)
+++ sandbox/itl/boost/validate/gentor/gentorprofile.hpp 2009-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -19,13 +19,13 @@
     class GentorProfile
     {
     public:
- GentorProfile();
+ GentorProfile();
 
- void set_defaults();
- void set_debug_defaults();
- void set_release_defaults();
+ void set_defaults();
+ void set_debug_defaults();
+ void set_release_defaults();
 
- void set_std_profile(int unit, int factor);
+ void set_std_profile(int unit, int factor);
 
         void set_range_int(int lwb, int upb)
         { _range_int = interval<int>::rightopen(lwb, upb); }
@@ -58,19 +58,19 @@
         int maxIntervalLength() { return _maxIntervalLength; }
         interval<int> range_codomain_ContainerSize()
                                                     { return _range_codomain_ContainerSize; }
- int repeat_count() { return _repeat_count; }
- int trials_count() { return _trials_count; }
- int trials_count_release() { return _trials_count_release; }
- int laws_per_cycle() { return _laws_per_cycle; }
+ int repeat_count() { return _repeat_count; }
+ int trials_count() { return _trials_count; }
+ int trials_count_release() { return _trials_count_release; }
+ int laws_per_cycle() { return _laws_per_cycle; }
 
- int unit() { return _unit; }
- int scaling() { return _scaling; }
+ int unit() { return _unit; }
+ int scaling() { return _scaling; }
 
- double debug_slowdown()const { return _debug_slowdown; }
+ double debug_slowdown()const { return _debug_slowdown; }
 
- int adjusted_trials_count()const;
+ int adjusted_trials_count()const;
 
- void report_profile();
+ void report_profile();
 
     private:
         interval<int> _range_int;
@@ -83,15 +83,15 @@
         int _maxIntervalLength;
 
         interval<int> _range_codomain_ContainerSize;
- int _repeat_count;
- int _trials_count;
- int _trials_count_release;
- int _laws_per_cycle;
+ int _repeat_count;
+ int _trials_count;
+ int _trials_count_release;
+ int _laws_per_cycle;
 
- double _debug_slowdown;
+ double _debug_slowdown;
 
- int _unit;
- int _scaling;
+ int _unit;
+ int _scaling;
     };
 
 
@@ -128,13 +128,13 @@
         interval<double> range_interval_double() { return m_profile.range_interval_double();}
         int maxIntervalLength() { return m_profile.maxIntervalLength(); }
         interval<int> range_codomain_ContainerSize(){ return m_profile.range_codomain_ContainerSize(); }
- int repeat_count() { return m_profile.repeat_count(); }
- int trials_count() { return m_profile.trials_count(); }
- int laws_per_cycle() { return m_profile.laws_per_cycle(); }
+ int repeat_count() { return m_profile.repeat_count(); }
+ int trials_count() { return m_profile.trials_count(); }
+ int laws_per_cycle() { return m_profile.laws_per_cycle(); }
 
- void report_profile() { return m_profile.report_profile(); }
+ void report_profile() { return m_profile.report_profile(); }
 
- void set_std_profile(int unit, int factor){ return m_profile.set_std_profile(unit, factor); }
+ void set_std_profile(int unit, int factor){ return m_profile.set_std_profile(unit, factor); }
 
 
     private:

Modified: sandbox/itl/boost/validate/validater/itl_set_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/itl_set_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/itl_set_validater.hpp 2009-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -47,9 +47,9 @@
     };
 
     itl_set_validater()
- {
- setProfile();
- }
+ {
+ setProfile();
+ }
 
     void setProfile()
     {

Modified: sandbox/itl/boost/validate/validater/law_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/law_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/law_validater.hpp 2009-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -60,10 +60,10 @@
         static const int default_repeat_count = 10;
 #endif
         LawValidater()
- {
- _repeat_count = GentorProfileSgl::it()->repeat_count();
- _trials_count = GentorProfileSgl::it()->trials_count();
- }
+ {
+ _repeat_count = GentorProfileSgl::it()->repeat_count();
+ _trials_count = GentorProfileSgl::it()->trials_count();
+ }
 
         void set_trials_count(int trials)
         {
@@ -105,7 +105,7 @@
 
         int _trials_count;
         int _silent_trials_count;
- int _repeat_count;
+ int _repeat_count;
 
         LawViolationsT _lawViolations;
         ValidationCounterT _frequencies;
@@ -122,8 +122,8 @@
         _violations.clear();
     }
 
- // Runs law_instance_count * repeat_count validations on the law LawT
- // law_instance_count: Number of instances that are validated for LawT
+ // Runs law_instance_count * repeat_count validations on the law LawT
+ // law_instance_count: Number of instances that are validated for LawT
     template <class LawT, template<typename>class GentorT>
     void LawValidater<LawT, GentorT>::run()
     {
@@ -134,8 +134,8 @@
 
         // Input values that are to be generated on every iteration
         input_tuple values;
- posix_time::ptime start, stop;
- double validation_time = 0.0; //microseconds
+ posix_time::ptime start, stop;
+ double validation_time = 0.0; //microseconds
 
         for(int idx=0; idx<_trials_count; idx++)
         {
@@ -143,22 +143,22 @@
             _gentor.template map_template<GentorT, SomeValue>(values);
             _law.setInstance(values);
 
- bool law_is_violated = false;
- start = posix_time::ptime(posix_time::microsec_clock::local_time());
- // In order to measure small time intervals, evaluation must be repeated.
- for(int repeat=0; repeat<_repeat_count; repeat++)
- law_is_violated = !_law.holds();
+ bool law_is_violated = false;
+ start = posix_time::ptime(posix_time::microsec_clock::local_time());
+ // In order to measure small time intervals, evaluation must be repeated.
+ for(int repeat=0; repeat<_repeat_count; repeat++)
+ law_is_violated = !_law.holds();
 
- stop = posix_time::ptime(posix_time::microsec_clock::local_time());
- validation_time += static_cast<double>((stop - start).total_microseconds());
+ stop = posix_time::ptime(posix_time::microsec_clock::local_time());
+ validation_time += static_cast<double>((stop - start).total_microseconds());
 
             if(law_is_violated)
                 _lawViolations.insert(_law);
 
         }
 
- // Average time for one law evaluation in micro seconds
- double avg_validation_time = validation_time/(_trials_count * _repeat_count);
+ // Average time for one law evaluation in micro seconds
+ double avg_validation_time = validation_time/(_trials_count * _repeat_count);
 
         if(!_lawViolations.empty())
         {
@@ -179,8 +179,8 @@
         {
             //reportSuccess();
             _frequencies +=
- ValidationCounterT::value_type(lawType(),
- validation_counts(avg_validation_time));
+ ValidationCounterT::value_type(lawType(),
+ validation_counts(avg_validation_time));
         }
 
     }

Modified: sandbox/itl/boost/validate/validation_counts.hpp
==============================================================================
--- sandbox/itl/boost/validate/validation_counts.hpp (original)
+++ sandbox/itl/boost/validate/validation_counts.hpp 2009-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -26,10 +26,10 @@
 
     validation_counts& operator += (const validation_counts& right)
     {
- _time += right.time();
- _count += right.count();
- return *this;
- }
+ _time += right.time();
+ _count += right.count();
+ return *this;
+ }
 
 private:
     double _time;

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-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -39,6 +39,6 @@
     typedef interval_set<int> IntervalSetT;
     typedef split_interval_set<int> SplitIntervalSetT;
 
- const bool test = is_same<SplitIntervalSetT::key_type, SplitIntervalSetT::interval_type>::value;
- BOOST_CHECK_EQUAL(test, true);
+ const bool test = is_same<SplitIntervalSetT::key_type, SplitIntervalSetT::interval_type>::value;
+ BOOST_CHECK_EQUAL(test, true);
 }

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-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -24,7 +24,7 @@
     ">> Output will be generated in a few seconds\n"
     ">> terminate by typing <CTRL>C\n"
     ">> ------------------------------------------------------ <<\n";
- GentorProfileSgl::it()->report_profile();
+ 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-08-15 08:15:33 EDT (Sat, 15 Aug 2009)
@@ -26,12 +26,12 @@
 
 void GentorProfile::set_defaults()
 {
- set_debug_slowdown(8.45);
- set_trials_count_release(100);
+ set_debug_slowdown(8.45);
+ set_trials_count_release(100);
 #ifdef _DEBUG
- set_debug_defaults();
+ set_debug_defaults();
 #else
- set_release_defaults();
+ set_release_defaults();
 #endif
 }
 
@@ -39,88 +39,88 @@
 int GentorProfile::adjusted_trials_count()const
 {
 #ifdef _DEBUG
- return static_cast<int>(floor(0.5+(_trials_count_release / _debug_slowdown)));
+ return static_cast<int>(floor(0.5+(_trials_count_release / _debug_slowdown)));
 #else
- return _trials_count_release;
+ return _trials_count_release;
 #endif
 }
 
 
 void GentorProfile::set_debug_defaults()
 {
- set_range_int(-5, 5);
- set_range_nat(0, 16);
- set_range_double(0.0, 1.0);
- set_range_ContainerSize(0,4);
-
- set_range_interval_int(-5, 5);
- set_range_interval_double(-5.0, 5.0);
- set_maxIntervalLength(5);
-
- set_range_codomain_ContainerSize(0,4);
-
- set_repeat_count(1);
- set_trials_count(adjusted_trials_count());
- set_laws_per_cycle(100);
+ set_range_int(-5, 5);
+ set_range_nat(0, 16);
+ set_range_double(0.0, 1.0);
+ set_range_ContainerSize(0,4);
+
+ set_range_interval_int(-5, 5);
+ set_range_interval_double(-5.0, 5.0);
+ set_maxIntervalLength(5);
+
+ set_range_codomain_ContainerSize(0,4);
+
+ set_repeat_count(1);
+ set_trials_count(adjusted_trials_count());
+ set_laws_per_cycle(100);
 }
 
 void GentorProfile::set_release_defaults()
 {
- set_range_int(-5, 5);
- set_range_nat(0, 16);
- set_range_double(0.0, 1.0);
- set_range_ContainerSize(0,20);
-
- set_range_interval_int(-20, 20);
- set_range_interval_double(-20.0, 20.0);
- set_maxIntervalLength(10);
-
- set_range_codomain_ContainerSize(0,20);
-
- set_repeat_count(1);
- set_trials_count(trials_count_release());
- set_laws_per_cycle(100);
+ set_range_int(-5, 5);
+ set_range_nat(0, 16);
+ set_range_double(0.0, 1.0);
+ set_range_ContainerSize(0,20);
+
+ set_range_interval_int(-20, 20);
+ set_range_interval_double(-20.0, 20.0);
+ set_maxIntervalLength(10);
+
+ set_range_codomain_ContainerSize(0,20);
+
+ set_repeat_count(1);
+ set_trials_count(trials_count_release());
+ set_laws_per_cycle(100);
 }
 
 
 void GentorProfile::set_std_profile(int unit, int factor)
 {
- int value = unit*factor;
- _unit = unit;
- _scaling = factor;
- set_defaults();
+ int value = unit*factor;
+ _unit = unit;
+ _scaling = factor;
+ set_defaults();
 
- // Codomain values
+ // Codomain values
     set_range_int(-5, 5);
     set_range_nat(0, 16);
     set_range_double(0.0, 1.0);
     set_range_codomain_ContainerSize(0,4);
 
- // Parameter that influence speed
+ // Parameter that influence speed
     set_range_ContainerSize(0, value);
     set_range_interval_int(-value, value);
     set_range_interval_double(-value, value);
     set_maxIntervalLength(value);
 
- // Parameter to influence frequencies of output update.
- set_repeat_count(1);
- set_trials_count(adjusted_trials_count());
- set_laws_per_cycle(std::max(1, 100/factor));
+ // Parameter to influence frequencies of output update.
+ set_repeat_count(1);
+ set_trials_count(adjusted_trials_count());
+ set_laws_per_cycle(std::max(1, 100/factor));
 }
 
 
 
 GentorProfile::GentorProfile()
 {
- set_std_profile(4, 1);
+ set_std_profile(4, 1);
 }
 
 void GentorProfile::report_profile()
 {
- printf("(cycl=%d trls=%d rep=%d unit=%d scale=%d)\n",
- laws_per_cycle(), trials_count(), repeat_count(),
- unit(), scaling()
- );
+ printf("(cycl=%d trls=%d rep=%d unit=%d scale=%d)\n",
+ laws_per_cycle(), trials_count(), repeat_count(),
+ unit(), scaling()
+ );
 }
 
 // -------------------------------------


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk