|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r57266 - in sandbox/itl: boost/itl boost/itl_xt boost/validate/driver boost/validate/gentor boost/validate/type libs/itl/example/month_and_week_grid_ libs/itl/test/test_casual_ libs/itl_xt/test/meta_functors_
From: afojgo_at_[hidden]
Date: 2009-10-31 19:45:43
Author: jofaber
Date: 2009-10-31 19:45:42 EDT (Sat, 31 Oct 2009)
New Revision: 57266
URL: http://svn.boost.org/trac/boost/changeset/57266
Log:
Boostifying: Replaced TABs for the latest changes. Stable {msvc-8.0, 9.0, 10.0; gcc-3.4.4, gcc-4.3.2}
Text files modified:
sandbox/itl/boost/itl/rational.hpp | 12 +-
sandbox/itl/boost/itl_xt/bits.hpp | 152 +++++++++++++++++-----------------
sandbox/itl/boost/itl_xt/interval_bitset.hpp | 174 ++++++++++++++++++++--------------------
sandbox/itl/boost/validate/driver/interval_bitset_driver.hpp | 10 +-
sandbox/itl/boost/validate/driver/itl_driver.hpp | 2
sandbox/itl/boost/validate/gentor/gentorprofile.hpp | 6
sandbox/itl/boost/validate/gentor/randomgentor.hpp | 2
sandbox/itl/boost/validate/type/bits.hpp | 10 +-
sandbox/itl/boost/validate/type/nat.hpp | 4
sandbox/itl/libs/itl/example/month_and_week_grid_/month_and_week_grid.cpp | 4
sandbox/itl/libs/itl/test/test_casual_/test_casual.cpp | 12 +-
sandbox/itl/libs/itl_xt/test/meta_functors_/meta_functors.cpp | 2
12 files changed, 195 insertions(+), 195 deletions(-)
Modified: sandbox/itl/boost/itl/rational.hpp
==============================================================================
--- sandbox/itl/boost/itl/rational.hpp (original)
+++ sandbox/itl/boost/itl/rational.hpp 2009-10-31 19:45:42 EDT (Sat, 31 Oct 2009)
@@ -22,12 +22,12 @@
namespace boost{namespace itl
{
- template<class Integral>
- struct is_continuous<boost::rational<Integral> >
- {
- typedef is_continuous<boost::rational<Integral> > type;
- BOOST_STATIC_CONSTANT(bool, value = true);
- };
+ template<class Integral>
+ struct is_continuous<boost::rational<Integral> >
+ {
+ typedef is_continuous<boost::rational<Integral> > type;
+ BOOST_STATIC_CONSTANT(bool, value = true);
+ };
}} // namespace itl boost
Modified: sandbox/itl/boost/itl_xt/bits.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/bits.hpp (original)
+++ sandbox/itl/boost/itl_xt/bits.hpp 2009-10-31 19:45:42 EDT (Sat, 31 Oct 2009)
@@ -25,19 +25,19 @@
namespace bitcount
{
- template<typename WordT, bit_range_type Digits>
- struct count
- {
- typedef WordT word_type;
- typedef count<word_type,Digits> type;
+ template<typename WordT, bit_range_type Digits>
+ struct count
+ {
+ typedef WordT word_type;
+ typedef count<word_type,Digits> type;
- static bit_range_type apply(WordT value);
- };
+ static bit_range_type apply(WordT value);
+ };
}
template<class NaturalT> class bits
- : equality_comparable < bits<NaturalT>
+ : equality_comparable < bits<NaturalT>
, less_than_comparable < bits<NaturalT>
, incrementable < bits<NaturalT>
, decrementable < bits<NaturalT>
@@ -54,30 +54,30 @@
, xorable2 < bits<NaturalT>, bit_range_type
> > > > > > > > > > > > > >
//^ & - | + ^ & - | + ++ -- < ==
- //element container
+ //element container
{
public:
typedef NaturalT word_type;
- typedef bit_range_type bit_type;
+ typedef bit_range_type bit_type;
typedef bit_type element_type; // pretty short: 0 <= max < digits
typedef bit_type size_type;
- BOOST_STATIC_CONSTANT(bit_type, digits = std::numeric_limits<NaturalT>::digits);
+ BOOST_STATIC_CONSTANT(bit_type, digits = std::numeric_limits<NaturalT>::digits);
bits():_bits(){}
explicit bits(word_type value):_bits(value){}
word_type word()const{ return _bits; }
- bits& add(bit_type value){_bits |= (1 << value); return *this; }
- bits& subtract(bit_type value){_bits &= ~(1 << value); return *this; }
- bits& intersect(bit_type value){_bits &= (1 << value); return *this; }
- bits& flip(bit_type value){_bits ^= (1 << value); return *this; }
-
- bits& operator += (bit_type value){ return add(value); }
- bits& operator |= (bit_type value){ return add(value); }
- bits& operator -= (bit_type value){ return subtract(value); }
- bits& operator &= (bit_type value){ return intersect(value); }
- bits& operator ^= (bit_type value){ return flip(value); }
+ bits& add(bit_type value){_bits |= (1 << value); return *this; }
+ bits& subtract(bit_type value){_bits &= ~(1 << value); return *this; }
+ bits& intersect(bit_type value){_bits &= (1 << value); return *this; }
+ bits& flip(bit_type value){_bits ^= (1 << value); return *this; }
+
+ bits& operator += (bit_type value){ return add(value); }
+ bits& operator |= (bit_type value){ return add(value); }
+ bits& operator -= (bit_type value){ return subtract(value); }
+ bits& operator &= (bit_type value){ return intersect(value); }
+ bits& operator ^= (bit_type value){ return flip(value); }
bits& operator += (const bits& value){_bits |= value._bits; return *this;}
bits& operator |= (const bits& value){_bits |= value._bits; return *this;}
@@ -87,11 +87,11 @@
bool operator < (const bits& value)const{return _bits < value._bits;}
bool operator == (const bits& value)const{return _bits == value._bits;}
- bool empty()const { return _bits == 0; }
- bool contains(element_type element)const { return 0 != ((1 << element) & _bits); }
- bool contains(const bits& sub)const { return inclusion::subset==inclusion_compare(sub,*this); }
- size_type cardinality()const{ return bitcount::count<word_type, digits>::apply(_bits); }
- size_type size()const { return cardinality(); }
+ bool empty()const { return _bits == 0; }
+ bool contains(element_type element)const { return 0 != ((1 << element) & _bits); }
+ bool contains(const bits& sub)const { return inclusion::subset==inclusion_compare(sub,*this); }
+ size_type cardinality()const{ return bitcount::count<word_type, digits>::apply(_bits); }
+ size_type size()const { return cardinality(); }
private:
word_type _bits;
@@ -130,89 +130,89 @@
static unsigned char table[] =
{
- 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
- 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
- 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
- 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
- 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
- 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
- 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
- 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
+ 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+ 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+ 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+ 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+ 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+ 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+ 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+ 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
};
template<>
struct count<nat8, 8>
{
- typedef nat8 word_type;
- typedef count<word_type,8> type;
+ typedef nat8 word_type;
+ typedef count<word_type,8> type;
- static bit_range_type apply(word_type value){ return table[value];}
+ static bit_range_type apply(word_type value){ return table[value];}
};
template<>
struct count<nat16, 16>
{
- typedef nat16 word_type;
- typedef count<word_type,16> type;
+ typedef nat16 word_type;
+ typedef count<word_type,16> type;
- static bit_range_type apply(word_type value)
- {
- return table[ value & 0xff]
- + table[(value >> 8) & 0xff];
- }
+ static bit_range_type apply(word_type value)
+ {
+ return table[ value & 0xff]
+ + table[(value >> 8) & 0xff];
+ }
};
template<>
struct count<nat32, 32>
{
- typedef nat32 word_type;
- typedef count<word_type,32> type;
+ typedef nat32 word_type;
+ typedef count<word_type,32> type;
- static bit_range_type apply(word_type value)
- {
- return table[ value & 0xfful]
- + table[(value >> 8) & 0xfful]
- + table[(value >> 16) & 0xfful]
- + table[(value >> 24) & 0xfful];
- }
+ static bit_range_type apply(word_type value)
+ {
+ return table[ value & 0xfful]
+ + table[(value >> 8) & 0xfful]
+ + table[(value >> 16) & 0xfful]
+ + table[(value >> 24) & 0xfful];
+ }
};
//template<>
//struct count<unsigned int, 32>
//{
-// typedef unsigned int word_type;
-// typedef count<word_type,32> type;
+// typedef unsigned int word_type;
+// typedef count<word_type,32> type;
//
-// static bit_range_type apply(word_type value)
-// {
-// return table[ value & 0xfful]
-// + table[(value >> 8) & 0xfful]
-// + table[(value >> 16) & 0xfful]
-// + table[(value >> 24) & 0xfful];
-// }
+// static bit_range_type apply(word_type value)
+// {
+// return table[ value & 0xfful]
+// + table[(value >> 8) & 0xfful]
+// + table[(value >> 16) & 0xfful]
+// + table[(value >> 24) & 0xfful];
+// }
//
//};
template<>
struct count<nat64, 64>
{
- typedef nat64 word_type;
- typedef count<word_type,64> type;
+ typedef nat64 word_type;
+ typedef count<word_type,64> type;
- static bit_range_type compute(word_type value)
- {
- return table[ value & 0xffull]
- + table[(value >> 8) & 0xffull]
- + table[(value >> 16) & 0xffull]
- + table[(value >> 24) & 0xffull]
- + table[(value >> 32) & 0xffull]
- + table[(value >> 40) & 0xffull]
- + table[(value >> 48) & 0xffull]
- + table[(value >> 56) & 0xffull];
- ;
- }
+ static bit_range_type compute(word_type value)
+ {
+ return table[ value & 0xffull]
+ + table[(value >> 8) & 0xffull]
+ + table[(value >> 16) & 0xffull]
+ + table[(value >> 24) & 0xffull]
+ + table[(value >> 32) & 0xffull]
+ + table[(value >> 40) & 0xffull]
+ + table[(value >> 48) & 0xffull]
+ + table[(value >> 56) & 0xffull];
+ ;
+ }
};
} // namespace bitcount
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-10-31 19:45:42 EDT (Sat, 31 Oct 2009)
@@ -22,7 +22,7 @@
template
<
typename DomainT = unsigned long,
- typename BitSetT = itl::bits<unsigned long>,
+ typename BitSetT = itl::bits<unsigned long>,
ITL_COMPARE Compare = ITL_COMPARE_INSTANCE(std::less, DomainT),
template<class, ITL_COMPARE>class Interval = boost::itl::interval,
ITL_ALLOC Alloc = std::allocator
@@ -61,20 +61,20 @@
typedef DomainT element_type; // 0 .. 2^digits(element_type)-1
typedef DomainT condensed_type; // 0 .. (2^digits(element_type)-1)/digits(word_type)
typedef typename BitSetT::word_type word_type; // 0 .. 2^digits(word_type)-1
- typedef typename BitSetT::bit_type bit_type; // 0 .. digits(word_type)
+ typedef typename BitSetT::bit_type bit_type; // 0 .. digits(word_type)
typedef BitSetT bitset_type;
typedef BitSetT data_type;
- typedef typename std::size_t size_type;
+ typedef typename std::size_t size_type;
typedef typename interval_bitmap_type::interval_type interval_type;
typedef interval_type segment_type;
typedef typename interval_bitmap_type::key_type key_type;
typedef typename interval_bitmap_type::value_type value_type;
- typedef typename interval_bitmap_type::iterator iterator;
- typedef typename interval_bitmap_type::const_iterator const_iterator;
+ typedef typename interval_bitmap_type::iterator iterator;
+ typedef typename interval_bitmap_type::const_iterator const_iterator;
- typedef typename itl::set<DomainT,Compare,Alloc> atomized_type;
+ typedef typename itl::set<DomainT,Compare,Alloc> atomized_type;
public:
bool operator ==(const interval_bitset& rhs)const{ return _map == rhs._map; }
@@ -98,38 +98,38 @@
interval_bitset& operator &=(const interval_type& rhs){return intersect(rhs);}
interval_bitset& operator ^=(const interval_type& rhs){return flip(rhs); }
- interval_bitset& operator +=(const value_type& rhs) {_map += rhs; return *this;}
+ interval_bitset& operator +=(const value_type& rhs) {_map += rhs; return *this;}
- interval_bitset& add (const interval_type& rhs){return segment_apply(&interval_bitset::add_, rhs);}
+ interval_bitset& add (const interval_type& rhs){return segment_apply(&interval_bitset::add_, rhs);}
interval_bitset& subtract (const interval_type& rhs){return segment_apply(&interval_bitset::subtract_, rhs);}
interval_bitset& intersect(const interval_type& rhs){return segment_apply(&interval_bitset::intersect_,rhs);}
interval_bitset& flip (const interval_type& rhs){return segment_apply(&interval_bitset::flip_, rhs);}
- interval_bitset& add (const element_type& rhs) {return segment_apply(&interval_bitset::add_, interval_type(rhs));}
+ interval_bitset& add (const element_type& rhs) {return segment_apply(&interval_bitset::add_, interval_type(rhs));}
interval_bitset& subtract (const element_type& rhs) {return segment_apply(&interval_bitset::subtract_, interval_type(rhs));}
interval_bitset& intersect(const element_type& rhs) {return segment_apply(&interval_bitset::intersect_,interval_type(rhs));}
interval_bitset& flip (const element_type& rhs) {return segment_apply(&interval_bitset::flip_, interval_type(rhs));}
- void clear(){ _map.clear(); }
- bool empty()const{ return _map.clear(); }
- size_type cardinality()const;
- size_type size()const { return cardinality(); }
- size_type interval_count()const { return _map.interval_count(); }
- size_type iterative_size()const { return _map.iterative_size(); }
-
- bool contains(element_type element)const{ return _map(element>>shift).contains(element & mask); }
- bool contains(const segment_type& segment)const;
- bool contains(const interval_bitset& sub)const { return _map.contains(sub._map); }
- bool contained_in(const interval_bitset& super)const{ return _map.contained_in(super._map); }
+ void clear(){ _map.clear(); }
+ bool empty()const{ return _map.clear(); }
+ size_type cardinality()const;
+ size_type size()const { return cardinality(); }
+ size_type interval_count()const { return _map.interval_count(); }
+ size_type iterative_size()const { return _map.iterative_size(); }
+
+ bool contains(element_type element)const{ return _map(element>>shift).contains(element & mask); }
+ bool contains(const segment_type& segment)const;
+ bool contains(const interval_bitset& sub)const { return _map.contains(sub._map); }
+ bool contained_in(const interval_bitset& super)const{ return _map.contained_in(super._map); }
void show_segments()const;
void show_matrix(const char off_on[2] = " 1")const;
- std::string as_string()const{ return _map.as_string(); }
+ std::string as_string()const{ return _map.as_string(); }
- iterator begin() { return _map.begin(); }
- const_iterator begin()const{ return _map.begin(); }
- iterator end() { return _map.end(); }
- const_iterator end()const { return _map.end(); }
+ iterator begin() { return _map.begin(); }
+ const_iterator begin()const{ return _map.begin(); }
+ iterator end() { return _map.end(); }
+ const_iterator end()const { return _map.end(); }
private:
typedef typename interval_bitmap_type::segment_type seg_type;
@@ -143,15 +143,15 @@
all = ~static_cast<word_type>(0),
top = w1 << (digits-w1);
- typedef itl::bits<unsigned char> PartsT;
- enum { inner_part = 0, sub_part = 1, super_part = 2, inter_part = 4 };
+ typedef itl::bits<unsigned char> PartsT;
+ enum { inner_part = 0, sub_part = 1, super_part = 2, inter_part = 4 };
typedef void (interval_bitset::*segment_combiner)(element_type, element_type, bitset_type);
- word_type from_lower_to(word_type bit)const{return bit==digits-w1 ? all : (1<<(bit+1))-1;}
+ word_type from_lower_to(word_type bit)const{return bit==digits-w1 ? all : (1<<(bit+1))-1;}
word_type to_upper_from(word_type bit)const{return bit==digits-w1 ? top : ~((1<<bit)-1); }
- interval_bitset& segment_apply(segment_combiner combine, const interval_type& operand)
+ interval_bitset& segment_apply(segment_combiner combine, const interval_type& operand)
{ // same as
condensed_type base = operand.first() >> shift, // operand.first()/ divisor
ceil = operand.last() >> shift; // operand.last() / divisor
@@ -176,12 +176,12 @@
return *this;
}
- PartsT partition(bitset_type& sub, condensed_type& lo,
- bitset_type& inter,
- condensed_type& up, bitset_type& super,
- const segment_type& segment)const;
+ PartsT partition(bitset_type& sub, condensed_type& lo,
+ bitset_type& inter,
+ condensed_type& up, bitset_type& super,
+ const segment_type& segment)const;
- void add_(DomainT lo, DomainT up, BitSetT bits){_map += value_type(interval_type::rightopen(lo,up), bits);}
+ void add_(DomainT lo, DomainT up, BitSetT bits){_map += value_type(interval_type::rightopen(lo,up), bits);}
void subtract_(DomainT lo, DomainT up, BitSetT bits){_map -= value_type(interval_type::rightopen(lo,up), bits);}
void intersect_(DomainT lo, DomainT up, BitSetT bits){_map &= value_type(interval_type::rightopen(lo,up), bits);}
void flip_(DomainT lo, DomainT up, BitSetT bits){_map ^= value_type(interval_type::rightopen(lo,up), bits);}
@@ -191,18 +191,18 @@
};
-template<class DomainT, class BitSetT, ITL_COMPARE Compare, template<class, ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, template<class, ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
typename interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::PartsT
interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::partition
(
- bitset_type& sub, condensed_type& lo,
+ bitset_type& sub, condensed_type& lo,
bitset_type& inter,
condensed_type& up, bitset_type& super,
const segment_type& segment
)const
{
- if(segment.empty())
- return PartsT();
+ if(segment.empty())
+ return PartsT();
condensed_type base = segment.first() >> shift, // segment.first()/ divisor
ceil = segment.last() >> shift; // segment.last() / divisor
@@ -210,79 +210,79 @@
ceil_rest = segment.last() & mask ; // segment.last() % divisor
if(base == ceil) // [first, last] are within one bitset
- {
- inter = bitset_type(to_upper_from(base_rest) & from_lower_to(ceil_rest));
- lo = base; up = ceil;
- return PartsT(inner_part);
- }
+ {
+ inter = bitset_type(to_upper_from(base_rest) & from_lower_to(ceil_rest));
+ lo = base; up = ceil;
+ return PartsT(inner_part);
+ }
else // [first, last] spread over more than one bitset (chunk)
{
- PartsT parts;
+ PartsT parts;
lo = base_rest == 0 ? base : base+1, // begin of mid part
up = ceil_rest == mask ? ceil+1 : ceil ; // end of mid part
- word_type dbg_all = all;
- condensed_type dbg_up = up;
+ word_type dbg_all = all;
+ condensed_type dbg_up = up;
if(base_rest > 0) // Bitset of base interval has to be filled from base_rest to last
- {
- sub = bitset_type(to_upper_from(base_rest));
- parts.add(sub_part);
- }
+ {
+ sub = bitset_type(to_upper_from(base_rest));
+ parts.add(sub_part);
+ }
if(ceil_rest < mask) // Bitset of ceil interval has to be filled from first to ceil_rest
- {
- super = bitset_type(from_lower_to(ceil_rest));
- parts += super_part;
- }
+ {
+ super = bitset_type(from_lower_to(ceil_rest));
+ parts += super_part;
+ }
if(lo < up) // For the middle part all bits have to be set.
- {
- inter = bitset_type(all);
- parts |= inter_part;
- }
+ {
+ inter = bitset_type(all);
+ parts |= inter_part;
+ }
return parts;
}
}
-template<class DomainT, class BitSetT, ITL_COMPARE Compare, template<class, ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, template<class, ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
bool interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::contains(const segment_type& segment)const
{
- if(segment.empty())
- return true; // Emptieness is contained in everything
+ if(segment.empty())
+ return true; // Emptieness is contained in everything
- condensed_type lo, up ;
- bitset_type subs, inters, supers;
- PartsT parts = partition(subs, lo, inters, up, supers, segment);
-
- if(parts.contains(inner_part))
- return _map(lo).contains(inters);
- else
- {
- if(parts.contains(sub_part) && !_map(lo-1).contains(subs))
- return false;
- if(parts.contains(super_part) && !_map(up).contains(supers))
- return false;
- if(parts.contains(inter_part) && !_map.contains(seg_type(interval_type::rightopen(lo,up), inters)) )
- return false;
+ condensed_type lo, up ;
+ bitset_type subs, inters, supers;
+ PartsT parts = partition(subs, lo, inters, up, supers, segment);
+
+ if(parts.contains(inner_part))
+ return _map(lo).contains(inters);
+ else
+ {
+ if(parts.contains(sub_part) && !_map(lo-1).contains(subs))
+ return false;
+ if(parts.contains(super_part) && !_map(up).contains(supers))
+ return false;
+ if(parts.contains(inter_part) && !_map.contains(seg_type(interval_type::rightopen(lo,up), inters)) )
+ return false;
- return true;
- }
+ return true;
+ }
}
-template<class DomainT, class BitSetT, ITL_COMPARE Compare, template<class, ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, template<class, ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
typename interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::size_type
- interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::cardinality()const
+ interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::cardinality()const
{
- size_type cardinality = 0;
- ITL_const_FORALL(typename interval_bitmap_type, it_, _map)
- cardinality += (it_->second.cardinality() * it_->first.cardinality());
- return cardinality;
+ size_type cardinality = 0;
+ ITL_const_FORALL(typename interval_bitmap_type, it_, _map)
+ cardinality += (it_->second.cardinality() * it_->first.cardinality());
+ return cardinality;
}
-template<class DomainT, class BitSetT, ITL_COMPARE Compare, template<class, ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, template<class, ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
void interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::show_segments()const
{
for(typename interval_bitmap_type::const_iterator it_ = _map.begin();
@@ -294,7 +294,7 @@
}
}
-template<class DomainT, class BitSetT, ITL_COMPARE Compare, template<class, ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, template<class, ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
void interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>::show_matrix(const char off_on[2])const
{
typename interval_bitmap_type::const_iterator iter = _map.begin();
@@ -307,9 +307,9 @@
}
}
-template<class DomainT, class BitSetT, ITL_COMPARE Compare, template<class, ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
+template<class DomainT, class BitSetT, ITL_COMPARE Compare, template<class, ITL_COMPARE>class Interval, ITL_ALLOC Alloc>
bool is_element_equal(const interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& left,
- const interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& right)
+ const interval_bitset<DomainT,BitSetT,Compare,Interval,Alloc>& right)
{ return left == right; }
Modified: sandbox/itl/boost/validate/driver/interval_bitset_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/interval_bitset_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/interval_bitset_driver.hpp 2009-10-31 19:45:42 EDT (Sat, 31 Oct 2009)
@@ -54,15 +54,15 @@
switch(freeChoice)
{
case FreeChoice::_1:
- return new itl_set_validater< interval_bitset<int, bits<unsigned char> > >;
+ return new itl_set_validater< interval_bitset<int, bits<unsigned char> > >;
case FreeChoice::_2:
- return new itl_order_validater< interval_bitset<int, bits<unsigned short> > >;
+ return new itl_order_validater< interval_bitset<int, bits<unsigned short> > >;
case FreeChoice::_3:
- return new itl_set_validater< interval_bitset<int, bits<unsigned int> > >;
+ return new itl_set_validater< interval_bitset<int, bits<unsigned int> > >;
case FreeChoice::_4:
- return new itl_order_validater< interval_bitset<int, bits<unsigned long> > >;
+ return new itl_order_validater< interval_bitset<int, bits<unsigned long> > >;
case FreeChoice::_5:
- return new itl_order_validater< interval_bitset<int, bits<unsigned long long> > >;
+ return new itl_order_validater< interval_bitset<int, bits<unsigned long long> > >;
default: return choiceError(ITL_LOCATION("freeChoice:\n"), freeChoice, _freeChoice);
} //switch()
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-10-31 19:45:42 EDT (Sat, 31 Oct 2009)
@@ -270,7 +270,7 @@
ChoiceT _domainChoice;
ChoiceT _codomainChoice;
ChoiceT _neutronizerChoice;
- ChoiceT _freeChoice;
+ ChoiceT _freeChoice;
private:
algebra_validater* _validater;
Modified: sandbox/itl/boost/validate/gentor/gentorprofile.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/gentorprofile.hpp (original)
+++ sandbox/itl/boost/validate/gentor/gentorprofile.hpp 2009-10-31 19:45:42 EDT (Sat, 31 Oct 2009)
@@ -168,9 +168,9 @@
{
static interval<unsigned int> get()
{
- interval<cnat> inter_val = GentorProfileSgl::it()->range_nat();
- return interval<unsigned int>::rightopen(inter_val.lower(), inter_val.upper());
- }
+ interval<cnat> inter_val = GentorProfileSgl::it()->range_nat();
+ return interval<unsigned int>::rightopen(inter_val.lower(), inter_val.upper());
+ }
};
template<>
Modified: sandbox/itl/boost/validate/gentor/randomgentor.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/randomgentor.hpp (original)
+++ sandbox/itl/boost/validate/gentor/randomgentor.hpp 2009-10-31 19:45:42 EDT (Sat, 31 Oct 2009)
@@ -549,7 +549,7 @@
// // itvGentor->setMaxIntervalLength(GentorProfileSgl::it()->maxIntervalLength());
// // gentor.setDomainGentor(itvGentor);
// //}
- ////JODO
+ ////JODO
// static void apply(RandomGentor<interval_bitset<IntegralT,BitSetT> >& gentor)
// {
// gentor.setRangeOfSampleSize(GentorProfileSgl::it()->range_ContainerSize());
Modified: sandbox/itl/boost/validate/type/bits.hpp
==============================================================================
--- sandbox/itl/boost/validate/type/bits.hpp (original)
+++ sandbox/itl/boost/validate/type/bits.hpp 2009-10-31 19:45:42 EDT (Sat, 31 Oct 2009)
@@ -22,7 +22,7 @@
public:
typedef NaturalT chunk_type;
typedef NaturalT element_type;
- typedef std::size_t size_type;
+ typedef std::size_t size_type;
bits():_bits(){}
explicit bits(NaturalT value):_bits(value){}
@@ -35,11 +35,11 @@
bool operator < (const bits& value)const{return _bits < value._bits;}
bool operator == (const bits& value)const{return _bits == value._bits;}
- bool contains(element_type element)const{return 0 !=(_bits & element);}
- bool contains(const bits& value)const; //JODO
- bool contained_in(const bits& value)const; //JODO
+ bool contains(element_type element)const{return 0 !=(_bits & element);}
+ bool contains(const bits& value)const; //JODO
+ bool contained_in(const bits& value)const; //JODO
- size_type cardinality()const{}
+ size_type cardinality()const{}
private:
NaturalT _bits;
Modified: sandbox/itl/boost/validate/type/nat.hpp
==============================================================================
--- sandbox/itl/boost/validate/type/nat.hpp (original)
+++ sandbox/itl/boost/validate/type/nat.hpp 2009-10-31 19:45:42 EDT (Sat, 31 Oct 2009)
@@ -43,7 +43,7 @@
return *this;
}
- /*CL
+ /*CL
cnat& operator ^= (const cnat& right) //JODO should not be required
{
_value ^= right._value;
@@ -54,7 +54,7 @@
_value &= right._value;
return *this;
}
- */
+ */
//CL operator int()const{ return (_value); }
operator unsigned int()const{ return (_value); }
Modified: sandbox/itl/libs/itl/example/month_and_week_grid_/month_and_week_grid.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/month_and_week_grid_/month_and_week_grid.cpp (original)
+++ sandbox/itl/libs/itl/example/month_and_week_grid_/month_and_week_grid.cpp 2009-10-31 19:45:42 EDT (Sat, 31 Oct 2009)
@@ -18,8 +18,8 @@
x == {[1,2)[2,3)[3,4)}
\endcode
... using this property we can intersect splitting interval containers
- in order to iterate over intervals accounting for all changes of
- interval borders.
+ in order to iterate over intervals accounting for all changes of
+ interval borders.
In this example we provide an intersection of two split_interval_sets
representing a month and week time grid.
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-10-31 19:45:42 EDT (Sat, 31 Oct 2009)
@@ -43,13 +43,13 @@
typedef split_interval_map<int,int> SplitIntervalMapT;
typedef interval_map<int,int> IntervalMapT;
- interval_bitset<nat> ibs;
+ interval_bitset<nat> ibs;
- ibs += interval<nat>::rightopen(0,64);
- int sz = ibs.size();
- cout << ibs.size() << endl;
+ ibs += interval<nat>::rightopen(0,64);
+ int sz = ibs.size();
+ cout << ibs.size() << endl;
- bool contains = ibs.contains(interval<nat>(11,63));
- cout << "contains=" << contains << endl;
+ bool contains = ibs.contains(interval<nat>(11,63));
+ cout << "contains=" << contains << endl;
}
Modified: sandbox/itl/libs/itl_xt/test/meta_functors_/meta_functors.cpp
==============================================================================
--- sandbox/itl/libs/itl_xt/test/meta_functors_/meta_functors.cpp (original)
+++ sandbox/itl/libs/itl_xt/test/meta_functors_/meta_functors.cpp 2009-10-31 19:45:42 EDT (Sat, 31 Oct 2009)
@@ -162,7 +162,7 @@
int value()const { return _value; }
std::string as_string()const
- { return itl::to_string<int>::apply(_value); }
+ { return itl::to_string<int>::apply(_value); }
private:
int _value;
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