|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r55062 - in sandbox/itl: boost/itl boost/validate/driver boost/validate/laws boost/validate/validater libs/itl/example libs/itl/example/interval_ libs/itl/example/interval_container_ libs/itl/example/party_ libs/validate/example/labat_single_ libs/validate/src/gentor
From: afojgo_at_[hidden]
Date: 2009-07-21 09:50:24
Author: jofaber
Date: 2009-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
New Revision: 55062
URL: http://svn.boost.org/trac/boost/changeset/55062
Log:
Added code to LaBatea to monitor the times of law validations. Added documentation. Stable {msvc-9.0}
Added:
sandbox/itl/libs/itl/example/toytime.hpp (contents, props changed)
Removed:
sandbox/itl/libs/itl/example/toytime.h
Text files modified:
sandbox/itl/boost/itl/gregorian.hpp | 1
sandbox/itl/boost/itl/interval.hpp | 26 ++++----
sandbox/itl/boost/itl/interval_base_map.hpp | 105 +++++++++++++++++++-----------------
sandbox/itl/boost/itl/interval_base_set.hpp | 58 +++++++-------------
sandbox/itl/boost/itl/interval_map.hpp | 5 -
sandbox/itl/boost/itl/map.hpp | 105 ++++++++++++++++++++----------------
sandbox/itl/boost/itl/ptime.hpp | 4 -
sandbox/itl/boost/itl/set.hpp | 113 ++++++++++++++++++---------------------
sandbox/itl/boost/itl/set_algo.hpp | 76 --------------------------
sandbox/itl/boost/validate/driver/itl_driver.hpp | 2
sandbox/itl/boost/validate/driver/signed_quantifier_driver.hpp | 34 ++++++------
sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp | 16 ++--
sandbox/itl/boost/validate/laws/induced_relation.hpp | 2
sandbox/itl/boost/validate/validater/law_validater.hpp | 2
sandbox/itl/libs/itl/example/interval_/interval.cpp | 2
sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp | 2
sandbox/itl/libs/itl/example/party_/party.cpp | 2
sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp | 2
sandbox/itl/libs/validate/src/gentor/gentorprofile.cpp | 4 +
19 files changed, 237 insertions(+), 324 deletions(-)
Modified: sandbox/itl/boost/itl/gregorian.hpp
==============================================================================
--- sandbox/itl/boost/itl/gregorian.hpp (original)
+++ sandbox/itl/boost/itl/gregorian.hpp 2009-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -17,7 +17,6 @@
#ifdef ITL_NEUTRONS_PROVIDED
#pragma message("error: No neutral element provided for type boost::gregorian::date")
#pragma message(".. please #include <boost/itl/gregorian.hpp> PRIOR TO other itl/* classes")
-"JODO: Compiletime error has to be produced, but in a nicer way."
#endif
#ifdef ITL_DIFFERENCE_TYPES_PROVIDED
Modified: sandbox/itl/boost/itl/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval.hpp (original)
+++ sandbox/itl/boost/itl/interval.hpp 2009-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -198,17 +198,17 @@
interval& extend(const interval& x2);
/** Extend \c *this interval to the minimum of the lower bounds of
- \c this and \c left_extesion */
- interval& left_extend(const interval& left_extesion);
+ \c this and \c left_extension. */
+ interval& left_extend(const interval& left_extension);
/** Extend \c *this interval to the maximum of the upper bounds of
- \c this and \c right_extesion */
- interval& right_extend(const interval& right_extesion);
+ \c this and \c right_extension. */
+ interval& right_extend(const interval& right_extension);
- /** Set the lower bound and bound type according to \c left */
+ /** Set the lower bound and bound type according to interval \c left. */
interval& left_set(const interval& left);
- /** Set the upper bound and bound type according to \c right */
+ /** Set the upper bound and bound type according to interval \c right. */
interval& right_set(const interval& right);
/** Interval spanning from lower bound of \c *this interval to the upper bound of \c rhs.
@@ -1004,14 +1004,16 @@
return right.left_subtract(left_minuend);
}
-// ----------------------------------------------------------------------------
-// operators
-// ----------------------------------------------------------------------------
+//==============================================================================
+//= Intersection
+//==============================================================================
+
+/** Returns the intersection of \c left and \c right interval. */
template <class DomainT, ITL_COMPARE Compare>
-inline itl::interval<DomainT,Compare> operator & (const itl::interval<DomainT,Compare>& left,
- const itl::interval<DomainT,Compare>& right)
+inline itl::interval<DomainT,Compare> operator & (itl::interval<DomainT,Compare> left,
+ const itl::interval<DomainT,Compare>& right)
{
- return itl::interval<DomainT,Compare>(left) &= right;
+ return left &= right;
}
template<class CharType, class CharTraits, class DomainT, ITL_COMPARE Compare>
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-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -591,7 +591,7 @@
{
dom.clear();
const_FOR_IMPLMAP(it_)
- dom += (*it_).KEY_VALUE;
+ dom += it_->KEY_VALUE;
}
/* Sum of associated elements of the map */
@@ -728,7 +728,7 @@
{
difference_type length = neutron<difference_type>::value();
const_FOR_IMPLMAP(it_)
- length += (*it_).KEY_VALUE.length();
+ length += it_->KEY_VALUE.length();
return length;
}
@@ -800,24 +800,36 @@
else
{
interval_type sectant_interval = sectant.KEY_VALUE;
- if(sectant_interval.empty()) return;
+ if(sectant_interval.empty())
+ return;
- typename ImplMapT::const_iterator first_ = _map.lower_bound(sectant_interval);
- typename ImplMapT::const_iterator end_ = _map.upper_bound(sectant_interval);
+ const_iterator first_ = _map.lower_bound(sectant_interval);
+ const_iterator end_ = _map.upper_bound(sectant_interval);
- for(typename ImplMapT::const_iterator it_=first_; it_ != end_; it_++)
- {
- interval_type common_interval = ((*it_).KEY_VALUE) & sectant_interval;
+ 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(!common_interval.empty())
- {
- section.that()->add( value_type(common_interval, (*it_).CONT_VALUE) );
- if(is_set<CodomainT>::value)
- section.that()->template add<codomain_intersect>(value_type(common_interval, sectant.CONT_VALUE));
- else
- section.that()->template add<codomain_combine>(value_type(common_interval, sectant.CONT_VALUE));
- }
- }
}
}
@@ -837,11 +849,12 @@
typename ImplMapT::const_iterator first_ = _map.lower_bound(sectant_interval);
typename ImplMapT::const_iterator end_ = _map.upper_bound(sectant_interval);
+ iterator prior_ = section.end();
for(typename ImplMapT::const_iterator it_=first_; it_ != end_; it_++)
{
- interval_type common_interval = ((*it_).KEY_VALUE) & sectant_interval;
+ interval_type common_interval = it_->KEY_VALUE & sectant_interval;
if(!common_interval.empty())
- section.that()->add( value_type(common_interval, (*it_).CONT_VALUE) );
+ prior_ = section.that()->add(prior_, value_type(common_interval, it_->CONT_VALUE) );
}
}
@@ -1002,42 +1015,36 @@
interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
::join()
{
- iterator it_=_map.begin();
+ iterator it_ = _map.begin();
if(it_==_map.end())
return *this;
- iterator nxt=it_; nxt++;
- if(nxt==_map.end())
- return *this;
+ iterator next_ = it_; next_++;
- while(nxt != _map.end())
+ while(next_ != _map.end())
{
- if( (*it_).KEY_VALUE.touches((*nxt).KEY_VALUE)
- && (*it_).CONT_VALUE == (*nxt).CONT_VALUE )
+ if( it_->KEY_VALUE.touches(next_->KEY_VALUE)
+ && it_->CONT_VALUE == next_->CONT_VALUE )
{
iterator fst_mem = it_; // hold the fist member
- // go noodling on while touchin members found
- it_++; nxt++;
- while( nxt != _map.end()
- && (*it_).KEY_VALUE.touches((*nxt).KEY_VALUE)
- && (*it_).CONT_VALUE == (*nxt).CONT_VALUE )
- { it_++; nxt++; }
+ // Go on while touching members are found
+ it_++; next_++;
+ while( next_ != _map.end()
+ && it_->KEY_VALUE.touches(next_->KEY_VALUE)
+ && it_->CONT_VALUE == next_->CONT_VALUE )
+ { it_++; next_++; }
// finally we arrive at the end of a sequence of joinable intervals
- // and it points to the last member of that sequence
- iterator lst_mem = it_, end_mem = nxt;
- interval_type joinedInterval((*fst_mem).KEY_VALUE);
- joinedInterval.extend((*lst_mem).KEY_VALUE);
- CodomainT value = (*fst_mem).CONT_VALUE; //CodomainT::OP =
-
- _map.erase(fst_mem, end_mem);
- it_ = _map.insert(value_type(joinedInterval, value)).ITERATOR;
-
- it_++; // go on for the next after the currently inserted
- nxt=it_; if(nxt!=_map.end())nxt++;
+ // and it points to the last member of that sequence
+ 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_++;
}
- else { it_++; nxt++; }
+ else { it_++; next_++; }
}
return *this;
}
@@ -1053,9 +1060,9 @@
std::string res("");
const_FOR_IMPLMAP(it_) {
std::string cur("(");
- cur += (*it_).KEY_VALUE.as_string();
+ cur += it_->KEY_VALUE.as_string();
cur += ",";
- cur += itl::to_string<CodomainT>::apply((*it_).CONT_VALUE);
+ cur += itl::to_string<CodomainT>::apply(it_->CONT_VALUE);
cur += ")";
res += cur;
}
@@ -1073,7 +1080,7 @@
{
total = codomain_combine::neutron();
const_FOR_IMPLMAP(it_)
- total += (*it_).CONT_VALUE;
+ total += it_->CONT_VALUE;
}
@@ -1086,7 +1093,7 @@
{
// I can do this only, because I am shure that the contents and the
// ordering < on interval is invariant wrt. this transformation on bounds
- FOR_IMPLMAP(it_) const_cast<interval_type&>((*it_).KEY_VALUE).as(bounded);
+ FOR_IMPLMAP(it_) const_cast<interval_type&>(it_->KEY_VALUE).as(bounded);
}
@@ -1316,7 +1323,7 @@
Traits,Compare,Combine,Section,Interval,Alloc> IntervalMapT;
stream << "{";
const_FORALL(typename IntervalMapT, it_, object)
- stream << "(" << (*it_).KEY_VALUE << "->" << (*it_).CONT_VALUE << ")";
+ stream << "(" << it_->KEY_VALUE << "->" << it_->CONT_VALUE << ")";
return stream << "}";
}
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-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -430,20 +430,6 @@
discrete_interval_container
>
::type::cardinality(*this);
-
- /*JODO BOOST: This more simple implementention fails because ptime::duration has no infinity
- size_type size = neutron<size_type>::value();
- size_type interval_size;
- const_FOR_IMPL(it)
- {
- interval_size = (*it).cardinality();
- if(interval_size == std::numeric_limits<size_type>::infinity())
- return interval_size;
- else
- size += interval_size;
- }
- return size;
- */
}
template
@@ -470,11 +456,12 @@
if(inter_val.empty())
return;
- typename ImplSetT::const_iterator first_ = _set.lower_bound(inter_val);
- typename ImplSetT::const_iterator end_ = _set.upper_bound(inter_val);
+ const_iterator first_ = _set.lower_bound(inter_val);
+ const_iterator end_ = _set.upper_bound(inter_val);
- for(typename ImplSetT::const_iterator it_=first_; it_ != end_; it_++)
- section.add((*it_) & inter_val);
+ iterator prior_ = section.end();
+ for(const_iterator it_=first_; it_ != end_; it_++)
+ prior_ = section.add(prior_, (*it_) & inter_val);
}
@@ -594,35 +581,32 @@
if(it_==_set.end())
return *this;
- iterator nxt=it_; nxt++;
- if(nxt==_set.end())
- return *this;
+ iterator next_=it_; next_++;
+ //if(next_==_set.end())
+ // return *this;
- while(nxt != _set.end())
+ while(next_ != _set.end())
{
- if( (*it_).touches(*nxt) )
+ if( (*it_).touches(*next_) )
{
iterator fst_mem = it_; // hold the fist member
- // go noodling on while touchin members found
- it_++; nxt++;
- while( nxt != _set.end()
- && (*it_).touches(*nxt) )
- { it_++; nxt++; }
+ // Go on while touching members are found
+ it_++; next_++;
+ while( next_ != _set.end()
+ && (*it_).touches(*next_) )
+ { it_++; next_++; }
// finally we arrive at the end of a sequence of joinable intervals
// and it points to the last member of that sequence
- iterator lst_mem = it_, end_mem = nxt;
- interval_type joinedInterval(*fst_mem);
- joinedInterval.extend(*lst_mem);
-
- _set.erase(fst_mem, end_mem);
- it_ = _set.insert(joinedInterval).ITERATOR;
+ const_cast<interval_type&>(*it_).extend(*fst_mem);
+ _set.erase(fst_mem, it_);
- it_++; // go on for the next after the currently inserted
- nxt=it_; if(nxt!=_set.end())nxt++;
+ it_++; next_=it_;
+ if(next_!=_set.end())
+ next_++;
}
- else { it_++; nxt++; }
+ else { it_++; next_++; }
}
return *this;
}
Modified: sandbox/itl/boost/itl/interval_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_map.hpp 2009-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -223,11 +223,6 @@
// both left and right are in the map and they are neighbours
BOOST_ASSERT(joinable(left_, right_));
- //JODO: This implementation does not work in very rare cases. Causes are not clear
- //interval_type left_interval = left_->KEY_VALUE;
- //this->_map.erase(left_);
- //const_cast<interval_type&>(right_->KEY_VALUE).extend(left_interval);
-
interval_type right_interval = right_->KEY_VALUE;
this->_map.erase(right_);
const_cast<interval_type&>(left_->KEY_VALUE).extend(right_interval);
Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2009-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -221,6 +221,11 @@
value is added to the data value already found in the map. */
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. */
+ iterator add(iterator prior, const value_type& 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. */
map& subtract(const value_type& value_pair)
@@ -329,6 +334,9 @@
map& add(const value_type& value_pair);
template<class Combiner>
+ iterator add(iterator prior, const value_type& value_pair);
+
+ template<class Combiner>
map& subtract(const value_type& value_pair);
};
@@ -365,6 +373,29 @@
}
}
+
+template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
+ template <class Combiner>
+typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::iterator
+ map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
+ ::add(iterator prior_, const value_type& val)
+{
+ if(Traits::absorbs_neutrons && val.CONT_VALUE == Combiner::neutron())
+ return prior_;
+
+ 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_;
+}
+
+
+
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
typename map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::size_type
map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
@@ -620,13 +651,11 @@
{ return object.add(operand); }
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator + ( const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
+inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
+operator + ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object,
const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::element_type& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- ObjectT result(object);
- return result += operand;
+ return object += operand;
}
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
@@ -649,13 +678,11 @@
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator + (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
+inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
+operator + ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- ObjectT result(object);
- return result += operand;
+ return object += operand;
}
//--------------------------------------------------------------------------
@@ -667,13 +694,11 @@
{ return object.add(operand); }
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator | ( const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
+inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
+operator | ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object,
const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::value_type& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- ObjectT result(object);
- return result |= operand;
+ return object |= operand;
}
@@ -698,12 +723,10 @@
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator | (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
+operator | ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object,
const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- ObjectT result(object);
- return result |= operand;
+ return object |= operand;
}
//--------------------------------------------------------------------------
@@ -723,13 +746,11 @@
}
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator - (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
+inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
+operator - ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object,
const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- ObjectT result(object);
- return result -= operand;
+ return object -= operand;
}
/** Subtract a set \c x2 from this map. Every element of \c this map that
@@ -742,13 +763,11 @@
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator - (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
+inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
+operator - ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::set_type& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- ObjectT result(object);
- return result -= operand;
+ return object -= operand;
}
@@ -772,12 +791,10 @@
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator & (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
+operator & ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- ObjectT result(object);
- return result &= operand;
+ return object &= operand;
}
/** Intersect set \c x2 and \c *this.
@@ -791,22 +808,18 @@
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator & (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
+operator & (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object,
const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::set_type& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- ObjectT result(object);
- return result &= operand;
+ return object &= operand;
}
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
+inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
operator & (const typename itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>::set_type& operand,
- const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object )
+ itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object )
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- ObjectT result(object);
- return result &= operand;
+ return object &= operand;
}
@@ -823,13 +836,11 @@
}
template <class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, ITL_ALLOC Alloc>
-itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
-operator ^ (const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& object,
+inline itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>
+operator ^ ( itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> object,
const itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& operand)
{
- typedef itl::map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc> ObjectT;
- ObjectT result(object);
- return result ^= operand;
+ return object ^= operand;
}
Modified: sandbox/itl/boost/itl/ptime.hpp
==============================================================================
--- sandbox/itl/boost/itl/ptime.hpp (original)
+++ sandbox/itl/boost/itl/ptime.hpp 2009-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -21,13 +21,9 @@
#include <boost/date_time/posix_time/posix_time.hpp>
-//JODO Produce a better compietime error here.
-//JODO (Write Macro to reduce codereplication. Generate line info.) not needed if compile-time error is nifty.
-//JODO Make it complete for all date_time classes. check portability.
#ifdef ITL_NEUTRONS_PROVIDED
#pragma message("error: No neutral element provided for type boost::posix_time::ptime")
#pragma message(".. please #include <boost/itl/ptime.hpp> PRIOR TO other itl/* classes")
-"JODO: Compiletime error has to be produced, but in a nicer way."
#endif
#ifdef ITL_DIFFERENCE_TYPES_PROVIDED
Modified: sandbox/itl/boost/itl/set.hpp
==============================================================================
--- sandbox/itl/boost/itl/set.hpp (original)
+++ sandbox/itl/boost/itl/set.hpp 2009-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -149,11 +149,15 @@
//==========================================================================
//= Addition, subtraction
//==========================================================================
- /** Add an element \c value to the set. */
- set& add(const element_type& value) { insert(value); return *this; }
+ /** Add an \c element to the set. */
+ set& add(const element_type& element) { insert(element); return *this; }
- /** Subtract an element \c value from the set. */
- set& subtract(const element_type& value);
+ /** Add an element \c element after \c prior to the set. */
+ iterator add(iterator prior, const element_type& element)
+ { return insert(prior, element); }
+
+ /** Subtract an \c element from the set. */
+ set& subtract(const element_type& element);
//==========================================================================
//= Insertion, erasure
@@ -167,15 +171,15 @@
//= Intersection, symmetric difference
//==========================================================================
- /** The intersection of \c key in \c *this set is added to \c section. */
- void add_intersection(set& section, const element_type& key)const;
+ /** 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
to \c section. */
void add_intersection(set& section, const set& sectant)const;
- /** If \c *this set contains \c value it is erased, otherwise it is added. */
- set& flip(const element_type& value);
+ /** If \c *this set contains \c element it is erased, otherwise it is added. */
+ set& flip(const element_type& element);
//==========================================================================
//= Representation
@@ -366,21 +370,19 @@
{ return object.add(operand); }
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-itl::set<DomainT,Compare,Alloc>
-operator + (const itl::set<DomainT,Compare,Alloc>& object,
+inline itl::set<DomainT,Compare,Alloc>
+operator + ( itl::set<DomainT,Compare,Alloc> object,
const typename itl::set<DomainT,Compare,Alloc>::element_type& operand)
{
- itl::set<DomainT,Compare,Alloc> result(object);
- return result += operand;
+ return object += operand;
}
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-itl::set<DomainT,Compare,Alloc>
+inline itl::set<DomainT,Compare,Alloc>
operator + (const typename itl::set<DomainT,Compare,Alloc>::element_type& operand,
- const itl::set<DomainT,Compare,Alloc>& object)
+ itl::set<DomainT,Compare,Alloc> object)
{
- itl::set<DomainT,Compare,Alloc> result(object);
- return result += operand;
+ return object += operand;
}
/// Add a set \c operand to this set \object.
@@ -392,11 +394,10 @@
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
itl::set<DomainT,Compare,Alloc>
-operator + (const itl::set<DomainT,Compare,Alloc>& object,
+operator + ( itl::set<DomainT,Compare,Alloc> object,
const itl::set<DomainT,Compare,Alloc>& operand)
{
- itl::set<DomainT,Compare,Alloc> result(object);
- return result += operand;
+ return object += operand;
}
//--------------------------------------------------------------------------
@@ -409,20 +410,18 @@
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
itl::set<DomainT,Compare,Alloc>
-operator | (const itl::set<DomainT,Compare,Alloc>& object,
+operator | ( itl::set<DomainT,Compare,Alloc> object,
const typename itl::set<DomainT,Compare,Alloc>::element_type& operand)
{
- itl::set<DomainT,Compare,Alloc> result(object);
- return result |= operand;
+ return object |= operand;
}
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-itl::set<DomainT,Compare,Alloc>
+inline itl::set<DomainT,Compare,Alloc>
operator | (const typename itl::set<DomainT,Compare,Alloc>::element_type& operand,
- const itl::set<DomainT,Compare,Alloc>& object)
+ itl::set<DomainT,Compare,Alloc> object)
{
- itl::set<DomainT,Compare,Alloc> result(object);
- return result |= operand;
+ return object |= operand;
}
/// Add a set \c operand to this set \object.
@@ -433,12 +432,11 @@
{ Set::add(object, operand); return object; }
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-itl::set<DomainT,Compare,Alloc>
-operator | (const itl::set<DomainT,Compare,Alloc>& object,
+inline itl::set<DomainT,Compare,Alloc>
+operator | ( itl::set<DomainT,Compare,Alloc> object,
const itl::set<DomainT,Compare,Alloc>& operand)
{
- itl::set<DomainT,Compare,Alloc> result(object);
- return result |= operand;
+ return object |= operand;
}
//--------------------------------------------------------------------------
@@ -450,12 +448,11 @@
{ return object.subtract(operand); }
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-itl::set<DomainT,Compare,Alloc>
-operator - (const itl::set<DomainT,Compare,Alloc>& object,
+inline itl::set<DomainT,Compare,Alloc>
+operator - ( itl::set<DomainT,Compare,Alloc> object,
const typename itl::set<DomainT,Compare,Alloc>::element_type& operand)
{
- itl::set<DomainT,Compare,Alloc> result(object);
- return result -= operand;
+ return object -= operand;
}
/// Subtract a set \c x2 from this set.
@@ -466,12 +463,11 @@
{ Set::subtract(object, operand); return object; }
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-itl::set<DomainT,Compare,Alloc>
-operator - (const itl::set<DomainT,Compare,Alloc>& object,
+inline itl::set<DomainT,Compare,Alloc>
+operator - ( itl::set<DomainT,Compare,Alloc> object,
const itl::set<DomainT,Compare,Alloc>& operand)
{
- itl::set<DomainT,Compare,Alloc> result(object);
- return result -= operand;
+ return object -= operand;
}
//--------------------------------------------------------------------------
@@ -489,21 +485,19 @@
}
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-itl::set<DomainT,Compare,Alloc>
-operator & (const itl::set<DomainT,Compare,Alloc>& object,
+inline itl::set<DomainT,Compare,Alloc>
+operator & ( itl::set<DomainT,Compare,Alloc> object,
const typename itl::set<DomainT,Compare,Alloc>::element_type& operand)
{
- itl::set<DomainT,Compare,Alloc> result(object);
- return result &= operand;
+ return object &= operand;
}
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-itl::set<DomainT,Compare,Alloc>
+inline itl::set<DomainT,Compare,Alloc>
operator & (const typename itl::set<DomainT,Compare,Alloc>::element_type& operand,
- const itl::set<DomainT,Compare,Alloc>& object)
+ itl::set<DomainT,Compare,Alloc> object)
{
- itl::set<DomainT,Compare,Alloc> result(object);
- return result &= operand;
+ return object &= operand;
}
@@ -522,12 +516,11 @@
}
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-itl::set<DomainT,Compare,Alloc>
-operator & (const itl::set<DomainT,Compare,Alloc>& object,
+inline itl::set<DomainT,Compare,Alloc>
+operator & ( itl::set<DomainT,Compare,Alloc> object,
const itl::set<DomainT,Compare,Alloc>& operand)
{
- itl::set<DomainT,Compare,Alloc> result(object);
- return result &= operand;
+ return object &= operand;
}
//--------------------------------------------------------------------------
@@ -542,21 +535,19 @@
}
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-itl::set<DomainT,Compare,Alloc>
-operator ^ (const itl::set<DomainT,Compare,Alloc>& object,
+inline itl::set<DomainT,Compare,Alloc>
+operator ^ ( itl::set<DomainT,Compare,Alloc> object,
const typename itl::set<DomainT,Compare,Alloc>::element_type& operand)
{
- itl::set<DomainT,Compare,Alloc> result(object);
- return result ^= operand;
+ return object ^= operand;
}
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
-itl::set<DomainT,Compare,Alloc>
+inline itl::set<DomainT,Compare,Alloc>
operator ^ (const typename itl::set<DomainT,Compare,Alloc>::element_type& operand,
- const itl::set<DomainT,Compare,Alloc>& object)
+ itl::set<DomainT,Compare,Alloc> object)
{
- itl::set<DomainT,Compare,Alloc> result(object);
- return result ^= operand;
+ return object ^= operand;
}
@@ -572,15 +563,13 @@
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
itl::set<DomainT,Compare,Alloc>
-operator ^ (const itl::set<DomainT,Compare,Alloc>& object,
+operator ^ ( itl::set<DomainT,Compare,Alloc> object,
const itl::set<DomainT,Compare,Alloc>& operand)
{
- itl::set<DomainT,Compare,Alloc> result(object);
- return result ^= operand;
+ return object ^= operand;
}
-
template <typename DomainT, ITL_COMPARE Compare, ITL_ALLOC Alloc>
set<DomainT,Compare,Alloc>&
insert( set<DomainT,Compare,Alloc>& object,
Modified: sandbox/itl/boost/itl/set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/set_algo.hpp (original)
+++ sandbox/itl/boost/itl/set_algo.hpp 2009-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -66,15 +66,13 @@
return result;
typedef typename ObjectT::const_iterator Object_const_iterator;
+ typename ObjectT::iterator prior_ = result.end();
for(Object_const_iterator x2_ = x2.begin(); x2_ != x2.end(); x2_++)
- result += *x2_;
+ prior_ = result.add(prior_, *x2_);
return result;
}
- template<class ObjectT>
- ObjectT& operator += (ObjectT& result, const ObjectT& x2)
- { return Set::add(result, x2); }
template<class ObjectT, class CoObjectT>
ObjectT& subtract(ObjectT& result, const CoObjectT& x2)
@@ -162,37 +160,6 @@
}
- /** */
- template<class SetType>
- void intersect(SetType& result, const SetType& x1, const SetType& x2)
- {
- typename SetType::const_iterator common_lwb_;
- typename SetType::const_iterator common_upb_;
-
- result.clear();
- if(!common_range(common_lwb_, common_upb_, x1, x2))
- return;
-
- typename SetType::const_iterator x1_ = common_lwb_, x2_;
-
- while(x1_ != common_upb_)
- {
- x2_ = x2.find(*x1_++);
- if(x2_ != x2.end())
- result.insert(*x2_);
- }
- }
-
- template<class SetType>
- SetType& intersect(SetType& result, const SetType& x2)
- {
- SetType aux;
- intersect(aux, result, x2);
- aux.swap(result);
- return result;
- }
-
-
template<class SetType>
void flip(SetType& result, const SetType& x2)
{
@@ -205,45 +172,6 @@
}
}
-
-
- template<class SetType>
- bool disjoint(const SetType& x1, const SetType& x2)
- {
- typename SetType::const_iterator common_lwb_;
- typename SetType::const_iterator common_upb_;
-
- if(!common_range(common_lwb_, common_upb_, x1, x2))
- return true;
-
- typename SetType::const_iterator x1_ = common_lwb_, x2_;
-
- while(x1_ != common_upb_)
- {
- x2_ = x2.find(*x1_++);
- if(x2_ != x2.end()) return false; // found a common element
- }
- // found no common element
- return true;
- }
-
- template<class SetType>
- void subtract(SetType& result, const SetType& x1, const SetType& x2)
- {
- SetType temp;
- typename SetType::const_iterator x1_ = x1.begin(), x2_;
-
- if(&x1 != &x2)
- while(x1_ != x1.end())
- {
- x2_ = x2.find(*x1_);
- if(x2_ == x2.end())
- temp.insert(*x1_);
- ++x1_;
- }
- temp.swap(result);
- }
-
} // namespace Set
}} // namespace itl boost
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-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -64,9 +64,9 @@
for(int idx=0; hasValidProfile(); idx++)
{
- validateType();
if(idx>0 && idx % _laws_per_cycle == 0)
reportFrequencies();
+ validateType();
}
}
Modified: sandbox/itl/boost/validate/driver/signed_quantifier_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/signed_quantifier_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/signed_quantifier_driver.hpp 2009-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -33,9 +33,9 @@
_rootChoice[RootType::interval_set] = 0;
_rootChoice[RootType::separate_interval_set] = 0;
_rootChoice[RootType::split_interval_set] = 0;
- _rootChoice[RootType::itl_map] = 0;//33;
- _rootChoice[RootType::interval_map] = 50;//33;
- _rootChoice[RootType::split_interval_map] = 50;//34;
+ _rootChoice[RootType::itl_map] = 33;
+ _rootChoice[RootType::interval_map] = 33;
+ _rootChoice[RootType::split_interval_map] = 34;
setRootTypeNames();
_rootChoice.init();
@@ -94,29 +94,29 @@
algebra_validater* chooseValidater()
{
int rootChoice = _rootChoice.some();
- int domainChoice = _domainChoice.some();
+ //int domainChoice = _domainChoice.some(); // not used
int codomainChoice = _codomainChoice.some();
int neutronizerChoice = _neutronizerChoice.some();
switch(rootChoice)
{
//-----------------------------------------------------------------
- //case RootType::itl_map: {
- // switch(neutronizerChoice) {
- // case NeutronHandlerType::partial_absorber: return new signed_quantifier_validater<itl::map<double,int,partial_absorber> >;
- // case NeutronHandlerType::partial_enricher: return new signed_quantifier_validater<itl::map<double,int,partial_enricher> >;
- // case NeutronHandlerType::total_absorber: return new signed_quantifier_validater<itl::map<double,int,total_absorber > >;
- // case NeutronHandlerType::total_enricher: return new signed_quantifier_validater<itl::map<double,int,total_enricher > >;
- // default: return choiceError(ITL_LOCATION("\nRootType::itl_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
- // }//switch neutronizerChoice
- //}//case itl_map
+ case RootType::itl_map: {
+ switch(neutronizerChoice) {
+ case NeutronHandlerType::partial_absorber: return new signed_quantifier_validater<itl::map<int, int,partial_absorber> >;
+ case NeutronHandlerType::partial_enricher: return new signed_quantifier_validater<itl::map<int, int,partial_enricher> >;
+ case NeutronHandlerType::total_absorber: return new signed_quantifier_validater<itl::map<double,int,total_absorber > >;
+ case NeutronHandlerType::total_enricher: return new signed_quantifier_validater<itl::map<double,int,total_enricher > >;
+ default: return choiceError(ITL_LOCATION("\nRootType::itl_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
+ }//switch neutronizerChoice
+ }//case itl_map
//-----------------------------------------------------------------
case RootType::interval_map: {
switch(neutronizerChoice) {
case NeutronHandlerType::partial_absorber: return new signed_quantifier_validater<interval_map<double,int,partial_absorber> >;
case NeutronHandlerType::partial_enricher: return new signed_quantifier_validater<interval_map<double,int,partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new signed_quantifier_validater<interval_map<double,int,total_absorber > >;
- case NeutronHandlerType::total_enricher: return new signed_quantifier_validater<interval_map<double,int,total_enricher > >;
+ case NeutronHandlerType::total_absorber: return new signed_quantifier_validater<interval_map<int, int,total_absorber > >;
+ case NeutronHandlerType::total_enricher: return new signed_quantifier_validater<interval_map<int, int,total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
}//switch neutronizerChoice
}//case interval_map
@@ -124,9 +124,9 @@
case RootType::split_interval_map: {
switch(neutronizerChoice) {
case NeutronHandlerType::partial_absorber: return new signed_quantifier_validater<split_interval_map<double,int,partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new signed_quantifier_validater<split_interval_map<double,int,partial_enricher> >;
+ case NeutronHandlerType::partial_enricher: return new signed_quantifier_validater<split_interval_map<int, int,partial_enricher> >;
case NeutronHandlerType::total_absorber: return new signed_quantifier_validater<split_interval_map<double,int,total_absorber > >;
- case NeutronHandlerType::total_enricher: return new signed_quantifier_validater<split_interval_map<double,int,total_enricher > >;
+ case NeutronHandlerType::total_enricher: return new signed_quantifier_validater<split_interval_map<int, int,total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
}//switch neutronizerChoice
}//case split_interval_map
Modified: sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp 2009-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -103,8 +103,8 @@
//-----------------------------------------------------------------
case RootType::itl_map: {
switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new unsigned_quantifier_validater<itl::map<int,nat,partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new unsigned_quantifier_validater<itl::map<int,nat,partial_enricher> >;
+ case NeutronHandlerType::partial_absorber: return new unsigned_quantifier_validater<itl::map<double,nat,partial_absorber> >;
+ case NeutronHandlerType::partial_enricher: return new unsigned_quantifier_validater<itl::map<double,nat,partial_enricher> >;
case NeutronHandlerType::total_absorber: return new unsigned_quantifier_validater<itl::map<int,nat,total_absorber > >;
case NeutronHandlerType::total_enricher: return new unsigned_quantifier_validater<itl::map<int,nat,total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::itl_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
@@ -115,18 +115,18 @@
switch(neutronizerChoice) {
case NeutronHandlerType::partial_absorber: return new unsigned_quantifier_validater<interval_map<int,nat,partial_absorber> >;
case NeutronHandlerType::partial_enricher: return new unsigned_quantifier_validater<interval_map<int,nat,partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new unsigned_quantifier_validater<interval_map<int,nat,total_absorber > >;
- case NeutronHandlerType::total_enricher: return new unsigned_quantifier_validater<interval_map<int,nat,total_enricher > >;
+ case NeutronHandlerType::total_absorber: return new unsigned_quantifier_validater<interval_map<double,nat,total_absorber > >;
+ case NeutronHandlerType::total_enricher: return new unsigned_quantifier_validater<interval_map<double,nat,total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
}//switch neutronizerChoice
}//case interval_map
//-----------------------------------------------------------------
case RootType::split_interval_map: {
switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new unsigned_quantifier_validater<split_interval_map<int,nat,partial_absorber> >;
- case NeutronHandlerType::partial_enricher: return new unsigned_quantifier_validater<split_interval_map<int,nat,partial_enricher> >;
- case NeutronHandlerType::total_absorber: return new unsigned_quantifier_validater<split_interval_map<int,nat,total_absorber > >;
- case NeutronHandlerType::total_enricher: return new unsigned_quantifier_validater<split_interval_map<int,nat,total_enricher > >;
+ case NeutronHandlerType::partial_absorber: return new unsigned_quantifier_validater<split_interval_map<int, nat,partial_absorber> >;
+ case NeutronHandlerType::partial_enricher: return new unsigned_quantifier_validater<split_interval_map<double,nat,partial_enricher> >;
+ case NeutronHandlerType::total_absorber: return new unsigned_quantifier_validater<split_interval_map<int, nat,total_absorber > >;
+ case NeutronHandlerType::total_enricher: return new unsigned_quantifier_validater<split_interval_map<double,nat,total_enricher > >;
default: return choiceError(ITL_LOCATION("\nRootType::split_interval_map: neutronizerChoice:\n"), neutronizerChoice, _neutronizerChoice);
}//switch neutronizerChoice
}//case split_interval_map
Modified: sandbox/itl/boost/validate/laws/induced_relation.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/induced_relation.hpp (original)
+++ sandbox/itl/boost/validate/laws/induced_relation.hpp 2009-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -43,7 +43,7 @@
std::string typeString()const
{
return
- "InducedRelation<"+type_to_string<SourceT>::apply()+","
+ "InducedRel<"+type_to_string<SourceT>::apply()+","
+type_to_string<TargetT>::apply()+","
+binary_template_to_string<FunctionT>::apply()+","
+unary_template_to_string<RelationT>::apply()+">";
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-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -65,7 +65,7 @@
_trials_count = GentorProfileSgl::it()->trials_count();
}
- void settrials_count(int trials)
+ void set_trials_count(int trials)
{
_trials_count = trials;
_silent_trials_count = std::max(1, _trials_count / 10);
Modified: sandbox/itl/libs/itl/example/interval_/interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/interval_/interval.cpp (original)
+++ sandbox/itl/libs/itl/example/interval_/interval.cpp 2009-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -23,7 +23,7 @@
#include <math.h>
#include <boost/itl/type_traits/to_string.hpp>
#include <boost/itl/interval.hpp>
-#include "../toytime.h"
+#include "../toytime.hpp"
using namespace std;
using namespace boost::itl;
Modified: sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp (original)
+++ sandbox/itl/libs/itl/example/interval_container_/interval_container.cpp 2009-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -26,7 +26,7 @@
#include <boost/itl/separate_interval_set.hpp>
#include <boost/itl/split_interval_set.hpp>
#include <boost/itl/split_interval_map.hpp>
-#include "../toytime.h"
+#include "../toytime.hpp"
using namespace std;
using namespace boost::itl;
Modified: sandbox/itl/libs/itl/example/party_/party.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/party_/party.cpp (original)
+++ sandbox/itl/libs/itl/example/party_/party.cpp 2009-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -12,7 +12,7 @@
#include <iostream>
#include <boost/itl/type_traits/to_string.hpp>
#include <boost/itl/interval_map.hpp>
-#include "../toytime.h"
+#include "../toytime.hpp"
using namespace std;
using namespace boost::itl;
Deleted: sandbox/itl/libs/itl/example/toytime.h
==============================================================================
--- sandbox/itl/libs/itl/example/toytime.h 2009-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
+++ (empty file)
@@ -1,65 +0,0 @@
-/*-----------------------------------------------------------------------------+
-Copyright (c) 2007-2009: Joachim Faulhaber
-+------------------------------------------------------------------------------+
-Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
-+------------------------------------------------------------------------------+
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENCE.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt)
-+-----------------------------------------------------------------------------*/
-namespace boost{namespace itl
-{
-
-/** Time is a toy-class to demonstrate a class that conforms the requirements of
- a template parameter for class IntervalT.
-
- In real world applications you may want to use the integer representation of a
- time variable. That way intervals and their containers are working most efficiently.
-*/
-
-enum {sunday=0, monday, tuesday, wednesday, thursday, friday, saturday};
-static const char* daynames[] = {"sun", "mon", "tue", "wed", "thu", "fri", "sat"};
-
-class Time
-{
-public:
- Time(): m_time(0) {}
- Time(int hours, int minutes): m_time(60*hours+minutes) {}
- Time(int day, int hours, int minutes): m_time((24*60)*day+60*hours+minutes) {}
- int getDay()const { return m_time/(24*60); }
- int getHours()const { return (m_time%(24*60))/60; }
- int getMinutes()const { return (m_time%(24*60))%60; }
- int asInt()const { return m_time; }
- std::string getDayString()const { return daynames[getDay()]; }
-
- std::string as_string()const
- {
- const int MAX_TIMESTING_LEN = 256;
- char repr[MAX_TIMESTING_LEN];
- sprintf(repr, "%3s:%02d:%02d", getDayString().c_str(), getHours(), getMinutes());
- return std::string(repr);
- }
-
- Time& operator ++ () { m_time++; return *this; }
- Time& operator -- () { m_time--; return *this; }
-
-private:
- int m_time;
-};
-
-
-bool operator < (const Time& x1, const Time& x2) { return x1.asInt() < x2.asInt(); }
-bool operator == (const Time& x1, const Time& x2) { return x1.asInt() == x2.asInt(); }
-bool operator <= (const Time& x1, const Time& x2) { return x1.asInt() <= x2.asInt(); }
-
-
-template<class CharType, class CharTraits>
-std::basic_ostream<CharType, CharTraits> &operator<<
- (std::basic_ostream<CharType, CharTraits> &stream, Time const& value)
-{
- return stream << value.as_string();
-}
-
-
-}} // namespace itl boost
-
Added: sandbox/itl/libs/itl/example/toytime.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/libs/itl/example/toytime.hpp 2009-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -0,0 +1,65 @@
+/*-----------------------------------------------------------------------------+
+Copyright (c) 2007-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
+Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
++------------------------------------------------------------------------------+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENCE.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
++-----------------------------------------------------------------------------*/
+namespace boost{namespace itl
+{
+
+/** Time is a toy-class to demonstrate a class that conforms the requirements of
+ a template parameter for class template itl::interval.
+
+ In real world applications you may want to use the integer representation of a
+ time variable. That way intervals and their containers are working most efficiently.
+*/
+
+enum {sunday=0, monday, tuesday, wednesday, thursday, friday, saturday};
+static const char* daynames[] = {"sun", "mon", "tue", "wed", "thu", "fri", "sat"};
+
+class Time
+{
+public:
+ Time(): m_time(0) {}
+ Time(int hours, int minutes): m_time(60*hours+minutes) {}
+ Time(int day, int hours, int minutes): m_time((24*60)*day+60*hours+minutes) {}
+ int getDay()const { return m_time/(24*60); }
+ int getHours()const { return (m_time%(24*60))/60; }
+ int getMinutes()const { return (m_time%(24*60))%60; }
+ int asInt()const { return m_time; }
+ std::string getDayString()const { return daynames[getDay()]; }
+
+ std::string as_string()const
+ {
+ const int MAX_TIMESTING_LEN = 256;
+ char repr[MAX_TIMESTING_LEN];
+ sprintf(repr, "%3s:%02d:%02d", getDayString().c_str(), getHours(), getMinutes());
+ return std::string(repr);
+ }
+
+ Time& operator ++ () { m_time++; return *this; }
+ Time& operator -- () { m_time--; return *this; }
+
+private:
+ int m_time;
+};
+
+
+bool operator < (const Time& x1, const Time& x2) { return x1.asInt() < x2.asInt(); }
+bool operator == (const Time& x1, const Time& x2) { return x1.asInt() == x2.asInt(); }
+bool operator <= (const Time& x1, const Time& x2) { return x1.asInt() <= x2.asInt(); }
+
+
+template<class CharType, class CharTraits>
+std::basic_ostream<CharType, CharTraits> &operator<<
+ (std::basic_ostream<CharType, CharTraits> &stream, Time const& value)
+{
+ return stream << value.as_string();
+}
+
+
+}} // namespace itl boost
+
Modified: sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp 2009-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -72,7 +72,7 @@
int test_count = 1000;
ptime start, stop;
- test_law.setTrialsCount(test_count);
+ test_law.set_trials_count(test_count);
std::cout << "Start\n";
start = ptime(microsec_clock::local_time());
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-07-21 09:50:21 EDT (Tue, 21 Jul 2009)
@@ -111,9 +111,11 @@
set_range_element_ContainerSize(0,20);
set_repeat_count(1);
- set_trials_count(50);
+ set_trials_count(10);
set_laws_per_cycle(100);
+ set_debug_defaults();
+
//--------------------------------------------------------------------------
// values for novial_tree test
//set_range_int(-5, 5);
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