|
|
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