|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r58060 - in sandbox/itl: boost/itl/detail boost/itl_xt boost/itl_xt/detail boost/validate/driver boost/validate/laws boost/validate/std/algorithm boost/validate/validater libs/itl/test/test_casual_ libs/validate/example/labat_single_
From: afojgo_at_[hidden]
Date: 2009-11-30 10:38:15
Author: jofaber
Date: 2009-11-30 10:38:13 EST (Mon, 30 Nov 2009)
New Revision: 58060
URL: http://svn.boost.org/trac/boost/changeset/58060
Log:
Added element_iterators for interval containers and interval_bitset. Replaced Tabs.
Stable {msvc-8.0,9.0,10.0; gcc-3.4.4,4.3.2}
Text files modified:
sandbox/itl/boost/itl/detail/mapped_reference.hpp | 10
sandbox/itl/boost/itl_xt/bits.hpp | 2
sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp | 266 ++++++++++++++++++------------------
sandbox/itl/boost/itl_xt/interval_bitset.hpp | 66 ++++----
sandbox/itl/boost/validate/driver/sorted_associative_bitset_driver.hpp | 2
sandbox/itl/boost/validate/driver/sorted_associative_map_driver.hpp | 2
sandbox/itl/boost/validate/laws/atomic_equivalence.hpp | 80 +++++-----
sandbox/itl/boost/validate/std/algorithm/copy.hpp | 96 ++++++------
sandbox/itl/boost/validate/std/algorithm/set_algo.hpp | 288 ++++++++++++++++++++--------------------
sandbox/itl/boost/validate/validater/law_validater.hpp | 14
sandbox/itl/boost/validate/validater/sorted_associative_validater.hpp | 56 +++---
sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp | 234 ++++++++++++++++----------------
sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp | 22 +-
13 files changed, 569 insertions(+), 569 deletions(-)
Modified: sandbox/itl/boost/itl/detail/mapped_reference.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/mapped_reference.hpp (original)
+++ sandbox/itl/boost/itl/detail/mapped_reference.hpp 2009-11-30 10:38:13 EST (Mon, 30 Nov 2009)
@@ -20,13 +20,13 @@
typedef FirstT first_type;
typedef SecondT second_type;
typedef mapped_reference type;
- typedef typename
- mpl::if_<is_const<second_type>,
- second_type&,
- const second_type&>::type second_reference_type;
+ typedef typename
+ mpl::if_<is_const<second_type>,
+ second_type&,
+ const second_type&>::type second_reference_type;
const FirstT& first;
- second_reference_type second;
+ second_reference_type second;
mapped_reference(const FirstT& fst, second_reference_type snd) : first(fst), second(snd){}
Modified: sandbox/itl/boost/itl_xt/bits.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/bits.hpp (original)
+++ sandbox/itl/boost/itl_xt/bits.hpp 2009-11-30 10:38:13 EST (Mon, 30 Nov 2009)
@@ -97,7 +97,7 @@
size_type cardinality()const{ return bitcount::count<word_type, digits>::apply(_bits); }
size_type size()const { return cardinality(); }
- std::string as_string(const char off_on[2] = " 1")const;
+ std::string as_string(const char off_on[2] = " 1")const;
private:
word_type _bits;
Modified: sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp (original)
+++ sandbox/itl/boost/itl_xt/detail/bit_element_iterator.hpp 2009-11-30 10:38:13 EST (Mon, 30 Nov 2009)
@@ -27,7 +27,7 @@
typedef DomainT domain_type;
typedef DomainT codomain_type;
typedef DomainT element_type;
- typedef BitSetT bitset_type;
+ typedef BitSetT bitset_type;
typedef typename BitSetT::word_type word_type;
BOOST_STATIC_CONSTANT(bit_range_type, digits = BitSetT::digits);
@@ -60,11 +60,11 @@
typedef element_type data_type;
BOOST_STATIC_CONSTANT(bit_range_type, digits = bitwise<segment_type>::digits );
- BOOST_STATIC_CONSTANT(bool, is_forward = mpl::not_<is_reverse<SegmentIteratorT> >::value );
+ BOOST_STATIC_CONSTANT(bool, is_forward = mpl::not_<is_reverse<SegmentIteratorT> >::value );
- typedef typename biterate::proceed<segment_iterator,is_forward> Proceed;
+ typedef typename biterate::proceed<segment_iterator,is_forward> Proceed;
- BOOST_STATIC_CONSTANT(bit_range_type, before = Proceed::before );
+ BOOST_STATIC_CONSTANT(bit_range_type, before = Proceed::before );
BOOST_STATIC_CONSTANT(bit_range_type, ante = Proceed::ante );
BOOST_STATIC_CONSTANT(bit_range_type, past = Proceed::past );
BOOST_STATIC_CONSTANT(bit_range_type, beyond = Proceed::beyond );
@@ -83,7 +83,7 @@
bit_element_iterator(segment_iterator jumper, bit_range_type start_pos)
: _saltator(jumper)
, _reptator(neutron<domain_difference_type>::value())
- , _on_bit(start_pos)
+ , _on_bit(start_pos)
{}
template <class SaltatorT>
@@ -104,58 +104,58 @@
template <class SaltatorT>
bool equal(bit_element_iterator<SaltatorT> const& other) const
{
- if( _saltator != other._saltator)
- return false;
- else if(_reptator != other._reptator)
- return false;
- else if(this->_on_bit == ante)
- return other._on_bit == beyond || other.is_segment_begin();
- else
- return _on_bit == other._on_bit;
+ if( _saltator != other._saltator)
+ return false;
+ else if(_reptator != other._reptator)
+ return false;
+ else if(_on_bit == ante)
+ return other._on_bit == beyond || other.is_segment_begin();
+ else
+ return _on_bit == other._on_bit;
}
void increment()
{
- if(_on_bit == ante)
- first_bit();
-
- next_bit();
- if(_on_bit == past)
+ if(_on_bit == ante)
+ first_bit();
+
+ next_bit();
+ if(_on_bit == past)
{ // The current bitset passed the end
if(_reptator < pred(_saltator->first.length()))
- {
+ {
++_reptator;
- _on_bit = ante;
- }
+ _on_bit = ante;
+ }
else
{
++_saltator;
- // NOTE: increment and dereference are unsecure now, because
- // _saltator can (finally) be end here. decrement is secure.
+ // NOTE: increment and dereference are unsecure now, because
+ // _saltator can (finally) be end here. decrement is secure.
_reptator = neutron<domain_difference_type>::value();
- _on_bit = ante;
+ _on_bit = ante;
}
}
}
void decrement()
{
- prev_bit();
+ prev_bit();
if(_on_bit == ante)
{ // The current bitset passed the beginning
if(neutron<domain_difference_type>::value() < _reptator)
- {
+ {
--_reptator;
- _on_bit = past;
- }
+ _on_bit = past;
+ }
else
{
- //assert: _saltator is not at begin here.
+ //assert: _saltator is not at begin here.
--_saltator;
- // NOW: decrement insecure, because _saltator can (finally) be
- // begin here. increment and dereference are secure.
- _reptator = _saltator->first.length();
- --_reptator;
+ // NOW: decrement insecure, because _saltator can (finally) be
+ // begin here. increment and dereference are secure.
+ _reptator = _saltator->first.length();
+ --_reptator;
_on_bit = past;
}
}
@@ -163,61 +163,61 @@
element_type dereference()const
{
- if(_on_bit == ante)
- first_bit();
- else if(_on_bit == past)
- last_bit();
+ if(_on_bit == ante)
+ first_bit();
+ else if(_on_bit == past)
+ last_bit();
- return (Proceed::inter_value(_reptator, _saltator->first) << shift) + _on_bit;
+ return (Proceed::inter_value(_reptator, _saltator->first) << shift) + _on_bit;
}
void first_bit()const
{
- // Because interval_bitsets are neutron absorbers, _saltator->second.word() is not a neutron
+ // Because interval_bitsets are neutron absorbers, _saltator->second.word() is not a neutron
_on_bit = Proceed::first_bit(_saltator->second.word());
}
void last_bit()const
{
- // Because interval_bitsets are neutron absorbers, _saltator->second.word() is not a neutron
+ // Because interval_bitsets are neutron absorbers, _saltator->second.word() is not a neutron
_on_bit = Proceed::last_bit(_saltator->second.word());
}
bool next_bit()
{
- if(_on_bit == before)
- {
- ++_saltator;
- _reptator = neutron<domain_difference_type>::value();
+ if(_on_bit == before)
+ {
+ ++_saltator;
+ _reptator = neutron<domain_difference_type>::value();
_on_bit = Proceed::first_bit(_saltator->second.word());
- }
- else
- _on_bit = Proceed::next_bit(_saltator->second.word(), _on_bit);
+ }
+ else
+ _on_bit = Proceed::next_bit(_saltator->second.word(), _on_bit);
return _on_bit != past;
}
bool prev_bit()
{
- if(_on_bit == beyond)
- {
- --_saltator;
- _reptator = _saltator->first.length();
- --_reptator;
+ if(_on_bit == beyond)
+ {
+ --_saltator;
+ _reptator = _saltator->first.length();
+ --_reptator;
_on_bit = Proceed::last_bit(_saltator->second.word());
- }
- else
+ }
+ else
_on_bit = Proceed::prev_bit(_saltator->second.word(), _on_bit);
return _on_bit != ante;
}
- bool is_segment_begin()const
- {
- return _reptator == neutron<domain_difference_type>::value()
- && 0 <= _on_bit && _on_bit < digits
- && _on_bit == Proceed::first_bit(_saltator->second.word());
- }
+ bool is_segment_begin()const
+ {
+ return _reptator == neutron<domain_difference_type>::value()
+ && 0 <= _on_bit && _on_bit < digits
+ && _on_bit == Proceed::first_bit(_saltator->second.word());
+ }
private:
segment_iterator _saltator; // satltare: to jump : the fast moving iterator
@@ -297,10 +297,10 @@
}
}
- static bit_range_type last_bit(word_type value)
+ static bit_range_type last_bit(word_type value)
{
return index32[((high_bit(value) * factor)) >> shift];
- }
+ }
static bit_range_type prev_bit(word_type value, bit_range_type cur_pos)
{
@@ -347,7 +347,7 @@
return static_cast<half_type>(value >> half) & ~((1<<(cur_pos-half+1))-1);
}
- static bit_range_type first_bit(word_type value)
+ static bit_range_type first_bit(word_type value)
{
half_type lower = static_cast<half_type>(lower_mask & value);
if(lower)
@@ -357,7 +357,7 @@
half_type upper = static_cast<half_type>(value >> half);
return half + index32[(((upper & -upper) * factor)) >> shift];
}
- }
+ }
static bit_range_type next_bit(word_type value, bit_range_type cur_pos)
{
@@ -376,8 +376,8 @@
return index32[(((low_next & -low_next) * factor)) >> shift];
else if(half_type up_next = upper_next(value, cur_pos))
return half + index32[(((up_next & -up_next) * factor)) >> shift];
- else
- return past;
+ else
+ return past;
}
}
@@ -392,7 +392,7 @@
return static_cast<half_type>(value >> half) & ((1<<(cur_pos-half))-1);
}
- static bit_range_type last_bit(word_type value)
+ static bit_range_type last_bit(word_type value)
{
half_type upper = static_cast<half_type>(value >> half);
if(upper)
@@ -402,7 +402,7 @@
half_type lower = static_cast<half_type>(value & lower_mask);
return index32[((high_bit(lower) * factor)) >> shift];
}
- }
+ }
static bit_range_type prev_bit(word_type value, bit_range_type cur_pos)
{
@@ -440,40 +440,40 @@
typedef typename bitwise<segment_type>::word_type word_type;
BOOST_STATIC_CONSTANT(bit_range_type, digits = bitwise<segment_type>::digits );
- BOOST_STATIC_CONSTANT(bit_range_type, before = -2 );
- BOOST_STATIC_CONSTANT(bit_range_type, ante = -1 );
- BOOST_STATIC_CONSTANT(bit_range_type, past = digits );
- BOOST_STATIC_CONSTANT(bit_range_type, beyond = digits+1 );
-
- static bit_range_type first_bit(word_type value)
- {
- unsigned int dbg_word_value = value; //CL
- return forward<word_type,digits>::first_bit(value);
- }
-
- static bit_range_type last_bit(word_type value)
- { return forward<word_type,digits>::last_bit(value); }
-
- static bit_range_type next_bit(word_type value, bit_range_type cur_pos)
- { return forward<word_type,digits>::next_bit(value, cur_pos); }
-
- static bit_range_type prev_bit(word_type value, bit_range_type cur_pos)
- { return forward<word_type,digits>::prev_bit(value, cur_pos); }
-
- static difference_type inter_value(difference_type reptator, const interval_type inter_val)
- {
- return inter_val.first() + reptator;
- }
-
- static difference_type inter_base(const iterator& iter)
- {
- return neutron<difference_type>::value();
- }
-
- static difference_type inter_ceil(const iterator& iter)
- {
- return iter->first.length();
- }
+ BOOST_STATIC_CONSTANT(bit_range_type, before = -2 );
+ BOOST_STATIC_CONSTANT(bit_range_type, ante = -1 );
+ BOOST_STATIC_CONSTANT(bit_range_type, past = digits );
+ BOOST_STATIC_CONSTANT(bit_range_type, beyond = digits+1 );
+
+ static bit_range_type first_bit(word_type value)
+ {
+ unsigned int dbg_word_value = value; //CL
+ return forward<word_type,digits>::first_bit(value);
+ }
+
+ static bit_range_type last_bit(word_type value)
+ { return forward<word_type,digits>::last_bit(value); }
+
+ static bit_range_type next_bit(word_type value, bit_range_type cur_pos)
+ { return forward<word_type,digits>::next_bit(value, cur_pos); }
+
+ static bit_range_type prev_bit(word_type value, bit_range_type cur_pos)
+ { return forward<word_type,digits>::prev_bit(value, cur_pos); }
+
+ static difference_type inter_value(difference_type reptator, const interval_type inter_val)
+ {
+ return inter_val.first() + reptator;
+ }
+
+ static difference_type inter_base(const iterator& iter)
+ {
+ return neutron<difference_type>::value();
+ }
+
+ static difference_type inter_ceil(const iterator& iter)
+ {
+ return iter->first.length();
+ }
};
template<class IteratorT>
@@ -486,37 +486,37 @@
typedef typename bitwise<segment_type>::word_type word_type;
BOOST_STATIC_CONSTANT(bit_range_type, digits = bitwise<segment_type>::digits );
- BOOST_STATIC_CONSTANT(bit_range_type, beyond = -2 );
- BOOST_STATIC_CONSTANT(bit_range_type, past = -1 );
- BOOST_STATIC_CONSTANT(bit_range_type, ante = digits );
- BOOST_STATIC_CONSTANT(bit_range_type, before = digits+1 );
-
- static bit_range_type first_bit(word_type value)
- { return forward<word_type,digits>::last_bit(value); }
-
- static bit_range_type last_bit(word_type value)
- { return forward<word_type,digits>::first_bit(value); }
-
- static bit_range_type next_bit(word_type value, bit_range_type cur_pos)
- { return forward<word_type,digits>::prev_bit(value, cur_pos); }
-
- static bit_range_type prev_bit(word_type value, bit_range_type cur_pos)
- { return forward<word_type,digits>::next_bit(value, cur_pos); }
-
- static difference_type inter_value(difference_type reptator, const interval_type inter_val)
- {
- return inter_val.last() - reptator;
- }
-
- static difference_type inter_base(const iterator& iter)//CL . . .
- {
- return iter->first.length();
- }
-
- static difference_type inter_ceil(const iterator& iter)
- {
- return neutron<difference_type>::value();
- }
+ BOOST_STATIC_CONSTANT(bit_range_type, beyond = -2 );
+ BOOST_STATIC_CONSTANT(bit_range_type, past = -1 );
+ BOOST_STATIC_CONSTANT(bit_range_type, ante = digits );
+ BOOST_STATIC_CONSTANT(bit_range_type, before = digits+1 );
+
+ static bit_range_type first_bit(word_type value)
+ { return forward<word_type,digits>::last_bit(value); }
+
+ static bit_range_type last_bit(word_type value)
+ { return forward<word_type,digits>::first_bit(value); }
+
+ static bit_range_type next_bit(word_type value, bit_range_type cur_pos)
+ { return forward<word_type,digits>::prev_bit(value, cur_pos); }
+
+ static bit_range_type prev_bit(word_type value, bit_range_type cur_pos)
+ { return forward<word_type,digits>::next_bit(value, cur_pos); }
+
+ static difference_type inter_value(difference_type reptator, const interval_type inter_val)
+ {
+ return inter_val.last() - reptator;
+ }
+
+ static difference_type inter_base(const iterator& iter)//CL . . .
+ {
+ return iter->first.length();
+ }
+
+ static difference_type inter_ceil(const iterator& iter)
+ {
+ return neutron<difference_type>::value();
+ }
};
Modified: sandbox/itl/boost/itl_xt/interval_bitset.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/interval_bitset.hpp (original)
+++ sandbox/itl/boost/itl_xt/interval_bitset.hpp 2009-11-30 10:38:13 EST (Mon, 30 Nov 2009)
@@ -166,48 +166,48 @@
//= Element iterator related
//==========================================================================
element_iterator elements_begin()
- {
- if(this->begin()==this->end())
- return element_iterator(this->begin(), element_iterator::beyond);
- else
- return element_iterator(this->begin(), element_iterator::ante );
- }
+ {
+ if(this->begin()==this->end())
+ return element_iterator(this->begin(), element_iterator::beyond);
+ else
+ return element_iterator(this->begin(), element_iterator::ante );
+ }
element_iterator elements_end()
- { return element_iterator(this->end(), element_iterator::beyond); }
+ { return element_iterator(this->end(), element_iterator::beyond); }
element_const_iterator elements_begin()const
- {
- if(this->begin()==this->end())
- return element_const_iterator(this->begin(), element_iterator::beyond);
- else
- return element_const_iterator(this->begin(), element_iterator::ante );
- }
+ {
+ if(this->begin()==this->end())
+ return element_const_iterator(this->begin(), element_iterator::beyond);
+ else
+ return element_const_iterator(this->begin(), element_iterator::ante );
+ }
element_const_iterator elements_end()const
- { return element_const_iterator(this->end(), element_iterator::beyond); }
+ { return element_const_iterator(this->end(), element_iterator::beyond); }
element_reverse_iterator elements_rbegin()
- {
- if(this->rbegin()==this->rend())
- return element_reverse_iterator(this->rbegin(), element_iterator::before);
- else
- return element_reverse_iterator(this->rbegin(), element_iterator::past );
- }
+ {
+ if(this->rbegin()==this->rend())
+ return element_reverse_iterator(this->rbegin(), element_iterator::before);
+ else
+ return element_reverse_iterator(this->rbegin(), element_iterator::past );
+ }
element_reverse_iterator elements_rend()
- { return element_reverse_iterator(this->rend(), element_iterator::before); }
+ { return element_reverse_iterator(this->rend(), element_iterator::before); }
element_const_reverse_iterator elements_rbegin()const
- {
- if(this->rbegin()==this->rend())
- return element_const_reverse_iterator(this->rbegin(), element_iterator::before);
- else
- return element_const_reverse_iterator(this->rbegin(), element_iterator::past );
- }
+ {
+ if(this->rbegin()==this->rend())
+ return element_const_reverse_iterator(this->rbegin(), element_iterator::before);
+ else
+ return element_const_reverse_iterator(this->rbegin(), element_iterator::past );
+ }
element_const_reverse_iterator elements_rend()const
- { return element_const_reverse_iterator(this->rend(), element_iterator::before); }
+ { return element_const_reverse_iterator(this->rend(), element_iterator::before); }
private:
typedef typename interval_bitmap_type::segment_type seg_type;
@@ -423,15 +423,15 @@
namespace Interval
{
template <typename DomainT, typename BitSetT>
- struct Atomize<itl::set<DomainT>, interval_bitset<DomainT, BitSetT> >
+ struct Atomize<itl::set<DomainT>, interval_bitset<DomainT, BitSetT> >
{
void operator()( itl::set<DomainT>& atomized,
- const interval_bitset<DomainT, BitSetT>& clustered)
+ const interval_bitset<DomainT, BitSetT>& clustered)
{
typedef interval_bitset<DomainT, BitSetT> InterBitsetT;
- typename InterBitsetT::element_const_iterator bit_ = clustered.elements_begin();
- while(bit_ != clustered.elements_end())
- atomized.insert(*bit_++);
+ typename InterBitsetT::element_const_iterator bit_ = clustered.elements_begin();
+ while(bit_ != clustered.elements_end())
+ atomized.insert(*bit_++);
}
};
Modified: sandbox/itl/boost/validate/driver/sorted_associative_bitset_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/sorted_associative_bitset_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/sorted_associative_bitset_driver.hpp 2009-11-30 10:38:13 EST (Mon, 30 Nov 2009)
@@ -51,7 +51,7 @@
switch(freeChoice)
{
case FreeChoice::_1:
- return new sorted_associative_validater< interval_bitset<int, bits<unsigned char> >, itl::list<int> >;
+ return new sorted_associative_validater< interval_bitset<int, bits<unsigned char> >, itl::list<int> >;
case FreeChoice::_2:
return new sorted_associative_validater< interval_bitset<int, bits<unsigned short> >, itl::list<int> >;
case FreeChoice::_3:
Modified: sandbox/itl/boost/validate/driver/sorted_associative_map_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/sorted_associative_map_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/sorted_associative_map_driver.hpp 2009-11-30 10:38:13 EST (Mon, 30 Nov 2009)
@@ -103,7 +103,7 @@
//-----------------------------------------------------------------
case RootType::interval_map: {
switch(neutronizerChoice) {
- case NeutronHandlerType::partial_absorber: return new sorted_associative_validater<interval_map<int,int,partial_absorber>, itl::list<std::pair<int,int> > >;
+ case NeutronHandlerType::partial_absorber: return new sorted_associative_validater<interval_map<int,int,partial_absorber>, itl::list<std::pair<int,int> > >;
case NeutronHandlerType::partial_enricher: return new sorted_associative_validater<interval_map<int,int,partial_enricher>, itl::list<std::pair<int,int> > >;
case NeutronHandlerType::total_absorber: return new sorted_associative_validater<interval_map<int,int,total_absorber >, itl::list<std::pair<int,int> > >;
case NeutronHandlerType::total_enricher: return new sorted_associative_validater<interval_map<int,int,total_enricher >, itl::list<std::pair<int,int> > >;
Modified: sandbox/itl/boost/validate/laws/atomic_equivalence.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/atomic_equivalence.hpp (original)
+++ sandbox/itl/boost/validate/laws/atomic_equivalence.hpp 2009-11-30 10:38:13 EST (Mon, 30 Nov 2009)
@@ -38,27 +38,27 @@
// g
// -----------------------------------------------------------------------------
template <typename SegmentsT,
- typename TargetsT = typename SegmentsT::atomized_type,
- template<class,class,template<class>class>class Algorithm = itl::std_copy_forward,
- template<class>class TargetIterator = std::insert_iterator,
- template<class,class>class Atomizer = itl::Interval::Atomize,
+ typename TargetsT = typename SegmentsT::atomized_type,
+ template<class,class,template<class>class>class Algorithm = itl::std_copy_forward,
+ template<class>class TargetIterator = std::insert_iterator,
+ template<class,class>class Atomizer = itl::Interval::Atomize,
template<class>class Equality = itl::std_equal >
class UnaryAtomicEquivalence :
public Law<UnaryAtomicEquivalence<SegmentsT, TargetsT,
- Algorithm, TargetIterator,
- Atomizer, Equality>,
+ Algorithm, TargetIterator,
+ Atomizer, Equality>,
LOKI_TYPELIST_1(SegmentsT),
- LOKI_TYPELIST_2(TargetsT,TargetsT) >
+ LOKI_TYPELIST_2(TargetsT,TargetsT) >
{
/** S: SegmentsT, T: TargetsT, I: InputIterator
- Alg<S,T,I>: an algortihm on interval containers S
- that results in a container T via iterator I.
- For all S a: Alg<E,T,I>(atomize(a)) == Alg<S,T,I>(a)
+ Alg<S,T,I>: an algortihm on interval containers S
+ that results in a container T via iterator I.
+ For all S a: Alg<E,T,I>(atomize(a)) == Alg<S,T,I>(a)
Input = (a := inVal1)
Output = (lhs_result, rhs_result)
*/
public:
- typedef typename SegmentsT::atomized_type ElementsT;
+ typedef typename SegmentsT::atomized_type ElementsT;
std::string name()const { return "UnnaryAtomicEquivalence"; }
std::string formula()const { return "For all S a: Alg<E,T,I>(atomize(a)) == Alg<S,T,I>(a)"; }
@@ -67,7 +67,7 @@
{
return
"EleEq<"
- + type_to_string<SegmentsT>::apply()+","
+ + type_to_string<SegmentsT>::apply()+","
+ type_to_string<TargetsT>::apply() +","
+ Algorithm<ElementsT,TargetsT,TargetIterator>::struct_abbreviation() +">";
}
@@ -76,17 +76,17 @@
bool holds()
{
- // For all S a: Alg<E,T,I>(atomize(a)) == Alg<S,T,I>(a)
+ // For all S a: Alg<E,T,I>(atomize(a)) == Alg<S,T,I>(a)
// --- left hand side --------------------------------------------------
- TargetsT lhs;
+ TargetsT lhs;
SegmentsT segmental_a = this->template getInputValue<operand_a>();
- ElementsT elemental_a;
- Atomizer<ElementsT,SegmentsT>()(elemental_a, segmental_a);
- Algorithm<ElementsT,TargetsT,TargetIterator>::apply(elemental_a, lhs);
+ ElementsT elemental_a;
+ Atomizer<ElementsT,SegmentsT>()(elemental_a, segmental_a);
+ Algorithm<ElementsT,TargetsT,TargetIterator>::apply(elemental_a, lhs);
// --- right hand side -------------------------------------------------
TargetsT rhs;
- Algorithm<SegmentsT,TargetsT,TargetIterator>::apply_elemental(segmental_a, rhs);
+ Algorithm<SegmentsT,TargetsT,TargetIterator>::apply_elemental(segmental_a, rhs);
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
@@ -96,7 +96,7 @@
bool debug_holds()
{
- return holds();
+ return holds();
}
size_t size()const
@@ -123,37 +123,37 @@
// o
// -----------------------------------------------------------------------------
template <typename SegmentsT,
- typename TargetsT = typename SegmentsT::atomized_type,
- template<class,class,template<class>class>class Algorithm = itl::std_set_union_forward,
- template<class>class TargetIterator = std::insert_iterator,
- template<class,class>class Atomizer = itl::Interval::Atomize,
+ typename TargetsT = typename SegmentsT::atomized_type,
+ template<class,class,template<class>class>class Algorithm = itl::std_set_union_forward,
+ template<class>class TargetIterator = std::insert_iterator,
+ template<class,class>class Atomizer = itl::Interval::Atomize,
template<class>class Equality = itl::std_equal >
class BinaryAtomicEquivalence :
public Law<BinaryAtomicEquivalence<SegmentsT, TargetsT,
- Algorithm, TargetIterator,
- Atomizer, Equality>,
+ Algorithm, TargetIterator,
+ Atomizer, Equality>,
LOKI_TYPELIST_2(SegmentsT,SegmentsT),
- LOKI_TYPELIST_2(TargetsT,TargetsT) >
+ LOKI_TYPELIST_2(TargetsT,TargetsT) >
{
/** S: SegmentsT, T: TargetsT, I: InputIterator
- Alg<S,T,I>: an algortihm on interval containers S
- that results in a container T via iterator I.
- For all S a,b: Alg<S,T,I>(atomize(a), atomize(b)) == Alg<S,T,I>(a,b)
+ Alg<S,T,I>: an algortihm on interval containers S
+ that results in a container T via iterator I.
+ For all S a,b: Alg<S,T,I>(atomize(a), atomize(b)) == Alg<S,T,I>(a,b)
Input = (a := inVal1)
Output = (lhs_result, rhs_result)
*/
public:
- typedef typename SegmentsT::atomized_type ElementsT;
+ typedef typename SegmentsT::atomized_type ElementsT;
std::string name()const { return "BinaryAtomicEquivalence"; }
std::string formula()const
- { return "For all S a: Alg<E,T,I>(f(a),f(b)) == Alg<S,T,I>(a,b)"; }
+ { return "For all S a: Alg<E,T,I>(f(a),f(b)) == Alg<S,T,I>(a,b)"; }
std::string typeString()const
{
return
"EleEq<"
- + type_to_string<SegmentsT>::apply()+","
+ + type_to_string<SegmentsT>::apply()+","
+ type_to_string<TargetsT>::apply() +","
+ Algorithm<ElementsT,TargetsT,TargetIterator>::struct_abbreviation() +">";
}
@@ -162,19 +162,19 @@
bool holds()
{
- // For all S a: Alg<E,T,I>(atomize(a)) == Alg<S,T,I>(a)
+ // For all S a: Alg<E,T,I>(atomize(a)) == Alg<S,T,I>(a)
// --- left hand side --------------------------------------------------
- TargetsT lhs;
+ TargetsT lhs;
SegmentsT segmental_a = this->template getInputValue<operand_a>();
SegmentsT segmental_b = this->template getInputValue<operand_b>();
- ElementsT elemental_a, elemental_b;
- Atomizer<ElementsT,SegmentsT>()(elemental_a, segmental_a);
- Atomizer<ElementsT,SegmentsT>()(elemental_b, segmental_b);
- Algorithm<ElementsT,TargetsT,TargetIterator>::apply(elemental_a, elemental_b, lhs);
+ ElementsT elemental_a, elemental_b;
+ Atomizer<ElementsT,SegmentsT>()(elemental_a, segmental_a);
+ Atomizer<ElementsT,SegmentsT>()(elemental_b, segmental_b);
+ Algorithm<ElementsT,TargetsT,TargetIterator>::apply(elemental_a, elemental_b, lhs);
// --- right hand side -------------------------------------------------
TargetsT rhs;
- Algorithm<SegmentsT,TargetsT,TargetIterator>::apply_elemental(segmental_a, segmental_b, rhs);
+ Algorithm<SegmentsT,TargetsT,TargetIterator>::apply_elemental(segmental_a, segmental_b, rhs);
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
@@ -184,7 +184,7 @@
bool debug_holds()
{
- return holds();
+ return holds();
}
size_t size()const
Modified: sandbox/itl/boost/validate/std/algorithm/copy.hpp
==============================================================================
--- sandbox/itl/boost/validate/std/algorithm/copy.hpp (original)
+++ sandbox/itl/boost/validate/std/algorithm/copy.hpp 2009-11-30 10:38:13 EST (Mon, 30 Nov 2009)
@@ -18,73 +18,73 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_copy_forward
{
- static void apply(const SourceT& source, TargetT& target)
- {
- std::copy(source.begin(), source.end(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
- }
-
- static void apply_elemental(const SourceT& source, TargetT& target)
- {
- std::copy(source.elements_begin(), source.elements_end(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
- }
+ static void apply(const SourceT& source, TargetT& target)
+ {
+ std::copy(source.begin(), source.end(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
+ }
+
+ static void apply_elemental(const SourceT& source, TargetT& target)
+ {
+ std::copy(source.elements_begin(), source.elements_end(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
+ }
- static std::string struct_abbreviation(){ return "cpy_f"; }
+ static std::string struct_abbreviation(){ return "cpy_f"; }
};
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_copy_backward
{
- static void apply(const SourceT& source, TargetT& target)
- {
- std::copy(source.rbegin(), source.rend(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
- }
-
- static void apply_elemental(const SourceT& source, TargetT& target)
- {
- std::copy(source.elements_rbegin(), source.elements_rend(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
- }
+ static void apply(const SourceT& source, TargetT& target)
+ {
+ std::copy(source.rbegin(), source.rend(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
+ }
+
+ static void apply_elemental(const SourceT& source, TargetT& target)
+ {
+ std::copy(source.elements_rbegin(), source.elements_rend(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
+ }
- static std::string struct_abbreviation(){ return "cpy_b"; }
+ static std::string struct_abbreviation(){ return "cpy_b"; }
};
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_reverse_copy_forward
{
- static void apply(const SourceT& source, TargetT& target)
- {
- std::reverse_copy(source.begin(), source.end(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
- }
-
- static void apply_elemental(const SourceT& source, TargetT& target)
- {
- std::reverse_copy(source.elements_begin(), source.elements_end(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
- }
+ static void apply(const SourceT& source, TargetT& target)
+ {
+ std::reverse_copy(source.begin(), source.end(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
+ }
+
+ static void apply_elemental(const SourceT& source, TargetT& target)
+ {
+ std::reverse_copy(source.elements_begin(), source.elements_end(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
+ }
- static std::string struct_abbreviation(){ return "rcpy_f"; }
+ static std::string struct_abbreviation(){ return "rcpy_f"; }
};
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_reverse_copy_backward
{
- static void apply(const SourceT& source, TargetT& target)
- {
- std::reverse_copy(source.rbegin(), source.rend(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
- }
-
- static void apply_elemental(const SourceT& source, TargetT& target)
- {
- std::reverse_copy(source.elements_rbegin(), source.elements_rend(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
- }
+ static void apply(const SourceT& source, TargetT& target)
+ {
+ std::reverse_copy(source.rbegin(), source.rend(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
+ }
+
+ static void apply_elemental(const SourceT& source, TargetT& target)
+ {
+ std::reverse_copy(source.elements_rbegin(), source.elements_rend(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
+ }
- static std::string struct_abbreviation(){ return "rcpy_b"; }
+ static std::string struct_abbreviation(){ return "rcpy_b"; }
};
Modified: sandbox/itl/boost/validate/std/algorithm/set_algo.hpp
==============================================================================
--- sandbox/itl/boost/validate/std/algorithm/set_algo.hpp (original)
+++ sandbox/itl/boost/validate/std/algorithm/set_algo.hpp 2009-11-30 10:38:13 EST (Mon, 30 Nov 2009)
@@ -20,38 +20,38 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_includes_forward
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
- {
- target = std::includes(left.begin(), left.end(),
- right.begin(), right.end());
- }
-
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
- {
- target = std::includes(left.elements_begin(), left.elements_end(),
- right.elements_begin(), right.elements_end());
- }
+ static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ target = std::includes(left.begin(), left.end(),
+ right.begin(), right.end());
+ }
+
+ static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ target = std::includes(left.elements_begin(), left.elements_end(),
+ right.elements_begin(), right.elements_end());
+ }
- static std::string struct_abbreviation(){ return "C=f"; }
+ static std::string struct_abbreviation(){ return "C=f"; }
};
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_includes_backward
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
- {
- target = std::includes(left.rbegin(), left.rend(),
- right.rbegin(), right.rend());
- }
-
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
- {
- target = std::includes(left.elements_rbegin(), left.elements_rend(),
- right.elements_rbegin(), right.elements_rend());
- }
+ static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ target = std::includes(left.rbegin(), left.rend(),
+ right.rbegin(), right.rend());
+ }
+
+ static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ target = std::includes(left.elements_rbegin(), left.elements_rend(),
+ right.elements_rbegin(), right.elements_rend());
+ }
- static std::string struct_abbreviation(){ return "C=b"; }
+ static std::string struct_abbreviation(){ return "C=b"; }
};
@@ -60,44 +60,44 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_set_union_forward
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
- {
- std::set_union(left.begin(), left.end(), right.begin(), right.end(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
- }
-
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
- {
- std::set_union(
- left.elements_begin(), left.elements_end(),
- right.elements_begin(), right.elements_end(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
- );
- }
+ static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ std::set_union(left.begin(), left.end(), right.begin(), right.end(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
+ }
+
+ static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ std::set_union(
+ left.elements_begin(), left.elements_end(),
+ right.elements_begin(), right.elements_end(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
+ );
+ }
- static std::string struct_abbreviation(){ return "+f"; }
+ static std::string struct_abbreviation(){ return "+f"; }
};
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_set_union_backward
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
- {
- std::set_union(left.rbegin(), left.rend(), right.rbegin(), right.rend(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
- }
-
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
- {
- std::set_union(
- left.elements_rbegin(), left.elements_rend(),
- right.elements_rbegin(), right.elements_rend(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
- );
- }
+ static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ std::set_union(left.rbegin(), left.rend(), right.rbegin(), right.rend(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
+ }
+
+ static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ std::set_union(
+ left.elements_rbegin(), left.elements_rend(),
+ right.elements_rbegin(), right.elements_rend(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
+ );
+ }
- static std::string struct_abbreviation(){ return "+b"; }
+ static std::string struct_abbreviation(){ return "+b"; }
};
@@ -106,44 +106,44 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_set_difference_forward
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
- {
- std::set_difference(left.begin(), left.end(), right.begin(), right.end(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
- }
-
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
- {
- std::set_difference(
- left.elements_begin(), left.elements_end(),
- right.elements_begin(), right.elements_end(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
- );
- }
+ static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ std::set_difference(left.begin(), left.end(), right.begin(), right.end(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
+ }
+
+ static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ std::set_difference(
+ left.elements_begin(), left.elements_end(),
+ right.elements_begin(), right.elements_end(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
+ );
+ }
- static std::string struct_abbreviation(){ return "-f"; }
+ static std::string struct_abbreviation(){ return "-f"; }
};
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_set_difference_backward
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
- {
- std::set_difference(left.rbegin(), left.rend(), right.rbegin(), right.rend(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
- }
-
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
- {
- std::set_difference(
- left.elements_rbegin(), left.elements_rend(),
- right.elements_rbegin(), right.elements_rend(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
- );
- }
+ static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ std::set_difference(left.rbegin(), left.rend(), right.rbegin(), right.rend(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
+ }
+
+ static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ std::set_difference(
+ left.elements_rbegin(), left.elements_rend(),
+ right.elements_rbegin(), right.elements_rend(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
+ );
+ }
- static std::string struct_abbreviation(){ return "-b"; }
+ static std::string struct_abbreviation(){ return "-b"; }
};
@@ -152,44 +152,44 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_set_intersection_forward
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
- {
- std::set_intersection(left.begin(), left.end(), right.begin(), right.end(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
- }
-
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
- {
- std::set_intersection(
- left.elements_begin(), left.elements_end(),
- right.elements_begin(), right.elements_end(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
- );
- }
+ static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ std::set_intersection(left.begin(), left.end(), right.begin(), right.end(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
+ }
+
+ static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ std::set_intersection(
+ left.elements_begin(), left.elements_end(),
+ right.elements_begin(), right.elements_end(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
+ );
+ }
- static std::string struct_abbreviation(){ return "^f"; }
+ static std::string struct_abbreviation(){ return "^f"; }
};
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_set_intersection_backward
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
- {
- std::set_intersection(left.rbegin(), left.rend(), right.rbegin(), right.rend(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
- }
-
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
- {
- std::set_intersection(
- left.elements_rbegin(), left.elements_rend(),
- right.elements_rbegin(), right.elements_rend(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
- );
- }
+ static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ std::set_intersection(left.rbegin(), left.rend(), right.rbegin(), right.rend(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
+ }
+
+ static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ std::set_intersection(
+ left.elements_rbegin(), left.elements_rend(),
+ right.elements_rbegin(), right.elements_rend(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
+ );
+ }
- static std::string struct_abbreviation(){ return "^b"; }
+ static std::string struct_abbreviation(){ return "^b"; }
};
@@ -198,44 +198,44 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_set_symmetric_difference_forward
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
- {
- std::set_symmetric_difference(left.begin(), left.end(), right.begin(), right.end(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
- }
-
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
- {
- std::set_symmetric_difference(
- left.elements_begin(), left.elements_end(),
- right.elements_begin(), right.elements_end(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
- );
- }
+ static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ std::set_symmetric_difference(left.begin(), left.end(), right.begin(), right.end(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
+ }
+
+ static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ std::set_symmetric_difference(
+ left.elements_begin(), left.elements_end(),
+ right.elements_begin(), right.elements_end(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
+ );
+ }
- static std::string struct_abbreviation(){ return "&f"; }
+ static std::string struct_abbreviation(){ return "&f"; }
};
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_set_symmetric_difference_backward
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
- {
- std::set_symmetric_difference(left.rbegin(), left.rend(), right.rbegin(), right.rend(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
- }
-
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
- {
- std::set_symmetric_difference(
- left.elements_rbegin(), left.elements_rend(),
- right.elements_rbegin(), right.elements_rend(),
- InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
- );
- }
+ static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ std::set_symmetric_difference(left.rbegin(), left.rend(), right.rbegin(), right.rend(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
+ }
+
+ static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ {
+ std::set_symmetric_difference(
+ left.elements_rbegin(), left.elements_rend(),
+ right.elements_rbegin(), right.elements_rend(),
+ InsertIterator<TargetT>(target, typename TargetT::iterator(target.end()))
+ );
+ }
- static std::string struct_abbreviation(){ return "&b"; }
+ static std::string struct_abbreviation(){ return "&b"; }
};
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-11-30 10:38:13 EST (Mon, 30 Nov 2009)
@@ -147,14 +147,14 @@
start = posix_time::ptime(posix_time::microsec_clock::local_time());
// In order to measure small time intervals, evaluation must be repeated.
- //std::cout << idx << " "; //CL..
- //if(idx==0)
- //{
- // int dbg_ = 1;
- //}
+ //std::cout << idx << " "; //CL..
+ //if(idx==0)
+ //{
+ // int dbg_ = 1;
+ //}
- for(int repeat=0; repeat<_repeat_count; repeat++)
- law_is_violated = !_law.holds();
+ 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());
Modified: sandbox/itl/boost/validate/validater/sorted_associative_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/sorted_associative_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/sorted_associative_validater.hpp 2009-11-30 10:38:13 EST (Mon, 30 Nov 2009)
@@ -53,20 +53,20 @@
_lawChoice.setMaxWeights(sum_of_shares);
int rest_shares = sum_of_shares, item_index = 0;
- _lawChoice[copy_fore ] = share(Laws_size, item_index, rest_shares);
- _lawChoice[copy_back ] = share(Laws_size, item_index, rest_shares);
- _lawChoice[reverse_copy_fore ] = share(Laws_size, item_index, rest_shares);
- _lawChoice[reverse_copy_back ] = share(Laws_size, item_index, rest_shares);
- _lawChoice[includes_fore ] = share(Laws_size, item_index, rest_shares);
- _lawChoice[includes_back ] = share(Laws_size, item_index, rest_shares);
- _lawChoice[set_union_fore ] = share(Laws_size, item_index, rest_shares);
- _lawChoice[set_union_back ] = share(Laws_size, item_index, rest_shares);
- _lawChoice[set_difference_fore ] = share(Laws_size, item_index, rest_shares);
- _lawChoice[set_difference_back ] = share(Laws_size, item_index, rest_shares);
- _lawChoice[set_intersection_fore ] = share(Laws_size, item_index, rest_shares);
- _lawChoice[set_intersection_back ] = share(Laws_size, item_index, rest_shares);
- _lawChoice[set_symmetric_difference_fore] = share(Laws_size, item_index, rest_shares);
- _lawChoice[set_symmetric_difference_back] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[copy_fore ] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[copy_back ] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[reverse_copy_fore ] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[reverse_copy_back ] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[includes_fore ] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[includes_back ] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[set_union_fore ] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[set_union_back ] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[set_difference_fore ] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[set_difference_back ] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[set_intersection_fore ] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[set_intersection_back ] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[set_symmetric_difference_fore] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[set_symmetric_difference_back] = share(Laws_size, item_index, rest_shares);
_lawChoice.init();
}
@@ -76,20 +76,20 @@
{
switch(_lawChoice.some())
{
- case copy_fore : return new LawValidater< UnaryAtomicEquivalence<Type, TargetT, std_copy_forward >, RandomGentor>;
- case copy_back : return new LawValidater< UnaryAtomicEquivalence<Type, TargetT, std_copy_backward >, RandomGentor>;
- case reverse_copy_fore : return new LawValidater< UnaryAtomicEquivalence<Type, TargetT, std_reverse_copy_forward >, RandomGentor>;
- case reverse_copy_back : return new LawValidater< UnaryAtomicEquivalence<Type, TargetT, std_reverse_copy_backward >, RandomGentor>;
- case includes_fore : return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_includes_forward >, RandomGentor>;
- case includes_back : return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_includes_backward >, RandomGentor>;
- case set_union_fore : return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_union_forward >, RandomGentor>;
- case set_union_back : return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_union_backward >, RandomGentor>;
- case set_difference_fore: return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_difference_forward >, RandomGentor>;
- case set_difference_back: return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_difference_backward>, RandomGentor>;
- case set_intersection_fore: return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_intersection_forward >, RandomGentor>;
- case set_intersection_back: return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_intersection_backward>, RandomGentor>;
- case set_symmetric_difference_fore: return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_symmetric_difference_forward >, RandomGentor>;
- case set_symmetric_difference_back: return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_symmetric_difference_backward>, RandomGentor>;
+ case copy_fore : return new LawValidater< UnaryAtomicEquivalence<Type, TargetT, std_copy_forward >, RandomGentor>;
+ case copy_back : return new LawValidater< UnaryAtomicEquivalence<Type, TargetT, std_copy_backward >, RandomGentor>;
+ case reverse_copy_fore : return new LawValidater< UnaryAtomicEquivalence<Type, TargetT, std_reverse_copy_forward >, RandomGentor>;
+ case reverse_copy_back : return new LawValidater< UnaryAtomicEquivalence<Type, TargetT, std_reverse_copy_backward >, RandomGentor>;
+ case includes_fore : return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_includes_forward >, RandomGentor>;
+ case includes_back : return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_includes_backward >, RandomGentor>;
+ case set_union_fore : return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_union_forward >, RandomGentor>;
+ case set_union_back : return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_union_backward >, RandomGentor>;
+ case set_difference_fore: return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_difference_forward >, RandomGentor>;
+ case set_difference_back: return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_difference_backward>, RandomGentor>;
+ case set_intersection_fore: return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_intersection_forward >, RandomGentor>;
+ case set_intersection_back: return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_intersection_backward>, RandomGentor>;
+ case set_symmetric_difference_fore: return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_symmetric_difference_forward >, RandomGentor>;
+ case set_symmetric_difference_back: return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_symmetric_difference_backward>, RandomGentor>;
default: return NULL;
}
}
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-11-30 10:38:13 EST (Mon, 30 Nov 2009)
@@ -46,16 +46,16 @@
lbs.add(0).add(3).add(5);
- InterBitsT::element_reverse_iterator rit_ = lbs.elements_rend();
- InterBitsT::element_reverse_iterator revbeg = lbs.elements_rbegin();
+ InterBitsT::element_reverse_iterator rit_ = lbs.elements_rend();
+ InterBitsT::element_reverse_iterator revbeg = lbs.elements_rbegin();
- cout << "{";
- while(!(rit_ == revbeg))
- {
- --rit_;
- cout << *rit_ << " ";
- }
- cout << "}";
+ cout << "{";
+ while(!(rit_ == revbeg))
+ {
+ --rit_;
+ cout << *rit_ << " ";
+ }
+ cout << "}";
}
@@ -66,20 +66,20 @@
InterBitsT lbs;
lbs
- .add(-50).add(-62).add(-63).add(-64).add(-65)
- .add(-17).add(-20).add(-31).add(-32).add(-33)
- .add(-1).add(-2).add(-4).add(-7).add(-8).add(-9).add(-15).add(-16)
- .add(0)
- .add(1).add(2).add(4).add(7).add(8).add(9).add(15).add(16)
- .add(17).add(20).add(31).add(32).add(33)
- .add(50).add(62).add(63).add(64).add(65)
- ;
+ .add(-50).add(-62).add(-63).add(-64).add(-65)
+ .add(-17).add(-20).add(-31).add(-32).add(-33)
+ .add(-1).add(-2).add(-4).add(-7).add(-8).add(-9).add(-15).add(-16)
+ .add(0)
+ .add(1).add(2).add(4).add(7).add(8).add(9).add(15).add(16)
+ .add(17).add(20).add(31).add(32).add(33)
+ .add(50).add(62).add(63).add(64).add(65)
+ ;
- lbs.show_segments();
- cout << lbs << endl;
+ lbs.show_segments();
+ cout << lbs << endl;
InterBitsT::element_iterator it = lbs.elements_begin();
- int ele;
+ int ele;
cout << "{";
while(it != lbs.elements_end())
{
@@ -98,66 +98,66 @@
BOOST_AUTO_TEST_CASE(itv_set_reverted_backwards)
{
typedef interval_set<int> InterSetT;
- InterSetT itv_set;
+ InterSetT itv_set;
- itv_set;
- InterSetT::element_reverse_iterator rit;
- rit = itv_set.elements_rend();
- while(rit != itv_set.elements_rbegin())
- {
- cout << *rit << endl;
- --rit;
- }
-
- itv_set.add(0).add(1).add(3);
-
- rit = itv_set.elements_rend();
-
- if(rit != itv_set.elements_rbegin())
- --rit;
-
- cout << "{";
- while(rit != itv_set.elements_rbegin())
- {
- cout << *rit << " ";
- --rit;
- }
+ itv_set;
+ InterSetT::element_reverse_iterator rit;
+ rit = itv_set.elements_rend();
+ while(rit != itv_set.elements_rbegin())
+ {
+ cout << *rit << endl;
+ --rit;
+ }
+
+ itv_set.add(0).add(1).add(3);
+
+ rit = itv_set.elements_rend();
+
+ if(rit != itv_set.elements_rbegin())
+ --rit;
+
+ cout << "{";
+ while(rit != itv_set.elements_rbegin())
+ {
+ cout << *rit << " ";
+ --rit;
+ }
- BOOST_ASSERT(rit == itv_set.elements_rbegin());
- cout << *rit << "}\n";
+ BOOST_ASSERT(rit == itv_set.elements_rbegin());
+ cout << *rit << "}\n";
}
BOOST_AUTO_TEST_CASE(itv_set_backwards)
{
typedef interval_set<int> InterSetT;
- InterSetT itv_set;
+ InterSetT itv_set;
+
+ itv_set;
+ InterSetT::element_iterator rit;
+ rit = itv_set.elements_end();
+ while(rit != itv_set.elements_begin())
+ {
+ cout << *rit << endl;
+ --rit;
+ }
+
+ itv_set.add(0).add(1).add(3);
- itv_set;
- InterSetT::element_iterator rit;
- rit = itv_set.elements_end();
- while(rit != itv_set.elements_begin())
- {
- cout << *rit << endl;
- --rit;
- }
-
- itv_set.add(0).add(1).add(3);
-
- rit = itv_set.elements_end();
-
- if(rit != itv_set.elements_begin())
- --rit;
-
- cout << "{";
- while(rit != itv_set.elements_begin())
- {
- cout << *rit << " ";
- --rit;
- }
+ rit = itv_set.elements_end();
+
+ if(rit != itv_set.elements_begin())
+ --rit;
+
+ cout << "{";
+ while(rit != itv_set.elements_begin())
+ {
+ cout << *rit << " ";
+ --rit;
+ }
- BOOST_ASSERT(rit == itv_set.elements_begin());
- cout << *rit << "}\n";
+ BOOST_ASSERT(rit == itv_set.elements_begin());
+ cout << *rit << "}\n";
}
@@ -168,22 +168,22 @@
InterBitsT lbs;
lbs
- .add(-50).add(-62).add(-63).add(-64).add(-65)
- .add(-17).add(-20).add(-31).add(-32).add(-33)
- .add(-1).add(-2).add(-4).add(-7).add(-8).add(-9).add(-15).add(-16)
- .add(0)
- .add(1).add(2).add(4).add(7).add(8).add(9).add(15).add(16)
- .add(17).add(20).add(31).add(32).add(33)
- .add(50).add(62).add(63).add(64).add(65)
- ;
+ .add(-50).add(-62).add(-63).add(-64).add(-65)
+ .add(-17).add(-20).add(-31).add(-32).add(-33)
+ .add(-1).add(-2).add(-4).add(-7).add(-8).add(-9).add(-15).add(-16)
+ .add(0)
+ .add(1).add(2).add(4).add(7).add(8).add(9).add(15).add(16)
+ .add(17).add(20).add(31).add(32).add(33)
+ .add(50).add(62).add(63).add(64).add(65)
+ ;
- lbs.show_segments();
- cout << lbs << endl;
+ lbs.show_segments();
+ cout << lbs << endl;
InterBitsT::element_reverse_iterator it = lbs.elements_rend();
- InterBitsT::element_reverse_iterator rbeg_eq_at_64 = lbs.elements_rbegin();
- int ele;
- --it;
+ InterBitsT::element_reverse_iterator rbeg_eq_at_64 = lbs.elements_rbegin();
+ int ele;
+ --it;
cout << "{";
while(it != lbs.elements_rbegin())
{
@@ -207,20 +207,20 @@
InterBitsT lbs;
lbs
- .add(-50).add(-62).add(-63).add(-64).add(-65)
- .add(-17).add(-20).add(-31).add(-32).add(-33)
- .add(-1).add(-2).add(-4).add(-7).add(-8).add(-9).add(-15).add(-16)
- .add(0)
- .add(1).add(2).add(4).add(7).add(8).add(9).add(15).add(16)
- .add(17).add(20).add(31).add(32).add(33)
- .add(50).add(62).add(63).add(64).add(65)
- ;
+ .add(-50).add(-62).add(-63).add(-64).add(-65)
+ .add(-17).add(-20).add(-31).add(-32).add(-33)
+ .add(-1).add(-2).add(-4).add(-7).add(-8).add(-9).add(-15).add(-16)
+ .add(0)
+ .add(1).add(2).add(4).add(7).add(8).add(9).add(15).add(16)
+ .add(17).add(20).add(31).add(32).add(33)
+ .add(50).add(62).add(63).add(64).add(65)
+ ;
- lbs.show_segments();
- cout << lbs << endl;
+ lbs.show_segments();
+ cout << lbs << endl;
InterBitsT::element_reverse_iterator it = lbs.elements_rbegin();
- int ele;
+ int ele;
cout << "{";
while(it != lbs.elements_rend())
{
@@ -243,21 +243,21 @@
InterBitsT lbs;
lbs
- .add(-50).add(-62).add(-63).add(-64).add(-65)
- .add(-17).add(-20).add(-31).add(-32).add(-33)
- .add(-1).add(-2).add(-4).add(-7).add(-8).add(-9).add(-15).add(-16)
- .add(0)
- .add(1).add(2).add(4).add(7).add(8).add(9).add(15).add(16)
- .add(17).add(20).add(31).add(32).add(33)
- .add(50).add(62).add(63).add(64).add(65)
- ;
+ .add(-50).add(-62).add(-63).add(-64).add(-65)
+ .add(-17).add(-20).add(-31).add(-32).add(-33)
+ .add(-1).add(-2).add(-4).add(-7).add(-8).add(-9).add(-15).add(-16)
+ .add(0)
+ .add(1).add(2).add(4).add(7).add(8).add(9).add(15).add(16)
+ .add(17).add(20).add(31).add(32).add(33)
+ .add(50).add(62).add(63).add(64).add(65)
+ ;
- lbs.show_segments();
- cout << lbs << endl;
+ lbs.show_segments();
+ cout << lbs << endl;
InterBitsT::element_iterator it = lbs.elements_end();
- int ele;
- --it;
+ int ele;
+ --it;
cout << "{";
while(it != lbs.elements_begin())
{
@@ -282,20 +282,20 @@
InterBitsT lbs;
lbs
- .add(-50).add(-62).add(-63).add(-64).add(-65)
- .add(-17).add(-20).add(-31).add(-32).add(-33)
- .add(-1).add(-2).add(-4).add(-7).add(-8).add(-9).add(-15).add(-16)
- .add(0)
- .add(1).add(2).add(4).add(7).add(8).add(9).add(15).add(16)
- .add(17).add(20).add(31).add(32).add(33)
- .add(50).add(62).add(63).add(64).add(65)
- ;
+ .add(-50).add(-62).add(-63).add(-64).add(-65)
+ .add(-17).add(-20).add(-31).add(-32).add(-33)
+ .add(-1).add(-2).add(-4).add(-7).add(-8).add(-9).add(-15).add(-16)
+ .add(0)
+ .add(1).add(2).add(4).add(7).add(8).add(9).add(15).add(16)
+ .add(17).add(20).add(31).add(32).add(33)
+ .add(50).add(62).add(63).add(64).add(65)
+ ;
- lbs.show_segments();
- cout << lbs << endl;
+ lbs.show_segments();
+ cout << lbs << endl;
InterBitsT::element_iterator it = lbs.elements_begin();
- int ele;
+ int ele;
cout << "{";
while(it != lbs.elements_end())
{
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-11-30 10:38:13 EST (Mon, 30 Nov 2009)
@@ -108,18 +108,18 @@
// hint_insertion
//> TestLawT;
- //typedef UnaryAtomicEquivalence
- //<
- // itl::interval_bitset<int,itl::bits16>,
- // itl::list<int>,
- // itl::std_reverse_copy_forward
- //> TestLawT;
+ //typedef UnaryAtomicEquivalence
+ //<
+ // itl::interval_bitset<int,itl::bits16>,
+ // itl::list<int>,
+ // itl::std_reverse_copy_forward
+ //> TestLawT;
typedef BinaryAtomicEquivalence
<
- itl::interval_bitset<int,itl::bits16>,
- itl::list<int>,
- itl::std_includes_forward
+ itl::interval_bitset<int,itl::bits16>,
+ itl::list<int>,
+ itl::std_includes_forward
> TestLawT;
@@ -132,8 +132,8 @@
GentorProfileSgl::it()->set_std_profile(32,1);
test_law.set_trials_count(test_count);
- TestLawT law;
- cout << law.typeString() << endl;
+ TestLawT law;
+ cout << law.typeString() << endl;
std::cout << "Start\n";
start = ptime(microsec_clock::local_time());
test_law.run();
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