|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r50554 - in sandbox/itl: boost/itl boost/validate/laws libs/itl/doc libs/itl/example/man_power libs/itl/example/month_and_week_grid libs/itl/test libs/itl/test/test_interval_map_mixed libs/itl/test/test_interval_set_mixed libs/itl/test/test_itl_interval libs/itl_xt/test libs/itl_xt/test/meta_functors
From: afojgo_at_[hidden]
Date: 2009-01-12 11:52:05
Author: jofaber
Date: 2009-01-12 11:52:04 EST (Mon, 12 Jan 2009)
New Revision: 50554
URL: http://svn.boost.org/trac/boost/changeset/50554
Log:
Refactored. Replaced OP_INPLACE_INTERSECT and OP_INTERSECT by intersection op *= and *.
Stable {msvc-9.0, partly congcc-4.3-a7}
Text files modified:
sandbox/itl/boost/itl/functors.hpp | 2
sandbox/itl/boost/itl/interval.hpp | 2
sandbox/itl/boost/itl/interval_maps.hpp | 12 ++++----
sandbox/itl/boost/itl/interval_sets.hpp | 20 ++++++++--------
sandbox/itl/boost/itl/map.hpp | 4 +-
sandbox/itl/boost/itl/notate.hpp | 3 --
sandbox/itl/boost/itl/set.hpp | 2
sandbox/itl/boost/validate/laws/set_laws.h | 6 ++--
sandbox/itl/libs/itl/doc/semantics.qbk | 23 ++++++++++--------
sandbox/itl/libs/itl/example/man_power/man_power.cpp | 6 ++--
sandbox/itl/libs/itl/example/month_and_week_grid/month_and_week_grid.cpp | 6 ++--
sandbox/itl/libs/itl/test/test_interval_map_mixed/test_interval_map_mixed.cpp | 48 +++++++++++++++++++-------------------
sandbox/itl/libs/itl/test/test_interval_map_shared.hpp | 26 ++++++++++----------
sandbox/itl/libs/itl/test/test_interval_set_mixed/test_interval_set_mixed.cpp | 50 ++++++++++++++++++++--------------------
sandbox/itl/libs/itl/test/test_interval_set_shared.hpp | 22 ++++++++--------
sandbox/itl/libs/itl/test/test_itl_interval/test_itl_interval.cpp | 14 +++++-----
sandbox/itl/libs/itl_xt/test/itvsettester.h | 2
sandbox/itl/libs/itl_xt/test/meta_functors/meta_functors.cpp | 4 +-
18 files changed, 126 insertions(+), 126 deletions(-)
Modified: sandbox/itl/boost/itl/functors.hpp
==============================================================================
--- sandbox/itl/boost/itl/functors.hpp (original)
+++ sandbox/itl/boost/itl/functors.hpp 2009-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -188,7 +188,7 @@
: public neutron_based_inplace_combine<Type>
{
void operator()(Type& object, const Type& operand)const
- { object OP_INPLACE_INTERSECT operand; }
+ { object &= operand; }
static Type neutron() { return boost::itl::neutron<Type>::value(); }
};
Modified: sandbox/itl/boost/itl/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval.hpp (original)
+++ sandbox/itl/boost/itl/interval.hpp 2009-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -1165,7 +1165,7 @@
// operators
// ----------------------------------------------------------------------------
template <class DomainT, ITL_COMPARE Compare>
-itl::interval<DomainT,Compare>& operator OP_INPLACE_INTERSECT ( itl::interval<DomainT,Compare>& section,
+itl::interval<DomainT,Compare>& operator &= ( itl::interval<DomainT,Compare>& section,
const itl::interval<DomainT,Compare>& sectant)
{
section.intersect(section, sectant);
Modified: sandbox/itl/boost/itl/interval_maps.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_maps.hpp (original)
+++ sandbox/itl/boost/itl/interval_maps.hpp 2009-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -579,7 +579,7 @@
class SectanT
>
interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
-operator OP_INPLACE_INTERSECT
+operator &=
(
interval_base_map<SubType,DomainT,CodomainT,
Traits,Compare,Combine,Section,Interval,Alloc>& object,
@@ -601,14 +601,14 @@
class SectanT
>
interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
-operator OP_INTERSECT
+operator &
(
const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
const SectanT& operand
)
{
typedef interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
- return ObjectT(object) OP_INPLACE_INTERSECT operand;
+ return ObjectT(object) &= operand;
}
//-----------------------------------------------------------------------------
@@ -624,7 +624,7 @@
class IntervalMap
>
IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
-operator OP_INPLACE_INTERSECT
+operator &=
(
IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
@@ -650,14 +650,14 @@
class IntervalMap
>
IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>
-operator OP_INTERSECT
+operator &
(
const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& object,
const IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& operand
)
{
typedef IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc> ObjectT;
- return ObjectT(object) OP_INPLACE_INTERSECT operand;
+ return ObjectT(object) &= operand;
}
//-----------------------------------------------------------------------------
Modified: sandbox/itl/boost/itl/interval_sets.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_sets.hpp (original)
+++ sandbox/itl/boost/itl/interval_sets.hpp 2009-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -250,7 +250,7 @@
template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
interval_base_set<SubType,DomainT,Compare,Interval,Alloc>&
-operator OP_INPLACE_INTERSECT
+operator &=
(
interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& object,
const IntervalSet <DomainT,Compare,Interval,Alloc>& operand
@@ -291,14 +291,14 @@
template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
interval_base_set<SubType,DomainT,Compare,Interval,Alloc>
-operator OP_INTERSECT
+operator &
(
const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& object,
const IntervalSet <DomainT,Compare,Interval,Alloc>& operand
)
{
typedef interval_base_set<SubType,DomainT,Compare,Interval,Alloc> ObjectT;
- return ObjectT(object) OP_INPLACE_INTERSECT operand;
+ return ObjectT(object) &= operand;
}
//-----------------------------------------------------------------------------
@@ -310,7 +310,7 @@
template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
IntervalSet<DomainT,Compare,Interval,Alloc>&
-operator OP_INPLACE_INTERSECT
+operator &=
(
IntervalSet<DomainT,Compare,Interval,Alloc>& object,
const typename IntervalSet<DomainT,Compare,Interval,Alloc>::interval_type& interval
@@ -337,14 +337,14 @@
template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
IntervalSet<DomainT,Compare,Interval,Alloc>
-operator OP_INTERSECT
+operator &
(
const IntervalSet<DomainT,Compare,Interval,Alloc>& object,
const typename IntervalSet<DomainT,Compare,Interval,Alloc>::interval_type& operand
)
{
typedef IntervalSet<DomainT,Compare,Interval,Alloc> ObjectT;
- return ObjectT(object) OP_INPLACE_INTERSECT operand;
+ return ObjectT(object) &= operand;
}
//-----------------------------------------------------------------------------
@@ -356,7 +356,7 @@
template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
IntervalSet<DomainT,Compare,Interval,Alloc>&
-operator OP_INPLACE_INTERSECT
+operator &=
(
IntervalSet<DomainT,Compare,Interval,Alloc>& object,
const DomainT& value
@@ -364,7 +364,7 @@
{
typedef typename IntervalSet<DomainT,Compare,Interval,Alloc>
::interval_type interval_type;
- return object OP_INPLACE_INTERSECT interval_type(value);
+ return object &= interval_type(value);
}
template
@@ -374,14 +374,14 @@
template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
IntervalSet<DomainT,Compare,Interval,Alloc>
-operator OP_INTERSECT
+operator &
(
const IntervalSet<DomainT,Compare,Interval,Alloc>& object,
const DomainT& operand
)
{
typedef IntervalSet<DomainT,Compare,Interval,Alloc> ObjectT;
- return ObjectT(object) OP_INPLACE_INTERSECT operand;
+ return ObjectT(object) &= operand;
}
//-----------------------------------------------------------------------------
Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2009-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -259,7 +259,7 @@
//JODO
/** Intersect map \c x2 and \c *this.
So \c *this becomes the intersection of \c *this and \c x2 */
- map& operator OP_INPLACE_INTERSECT (const map& x2)
+ map& operator &= (const map& x2)
{
if(Traits::emits_neutrons) return *this += x2;
else{ Map::intersect(*this, x2); return *this; }
@@ -267,7 +267,7 @@
/** Intersect set \c x2 and \c *this.
So \c *this becomes the intersection of \c *this and \c x2 */
- map& operator OP_INPLACE_INTERSECT (const set_type& x2)
+ map& operator &= (const set_type& x2)
{ Map::intersect(*this, x2); return *this; }
/** \c key_value allows for a uniform access to \c key_values which is
Modified: sandbox/itl/boost/itl/notate.hpp
==============================================================================
--- sandbox/itl/boost/itl/notate.hpp (original)
+++ sandbox/itl/boost/itl/notate.hpp 2009-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -126,9 +126,6 @@
//------------------------------------------------------------------------------
#define ITL_ALLOC template<class>class
-#define OP_INTERSECT &
-#define OP_INPLACE_INTERSECT &=
-
//------------------------------------------------------------------------------
namespace boost{namespace itl
{
Modified: sandbox/itl/boost/itl/set.hpp
==============================================================================
--- sandbox/itl/boost/itl/set.hpp (original)
+++ sandbox/itl/boost/itl/set.hpp 2009-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -172,7 +172,7 @@
/** Intersect set \c x2 \c *this.
So \c *this becomes the intersection of \c *this and \c x2 */
- set& operator OP_INPLACE_INTERSECT (const set& x) { Set::intersect(*this, x); return *this; }
+ set& operator &= (const set& x) { Set::intersect(*this, x); return *this; }
/** \c key_value allows for a uniform access to \c key_values which is
is used for common algorithms on sets and maps. */
Modified: sandbox/itl/boost/validate/laws/set_laws.h
==============================================================================
--- sandbox/itl/boost/validate/laws/set_laws.h (original)
+++ sandbox/itl/boost/validate/laws/set_laws.h 2009-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -415,7 +415,7 @@
a_plus_b += this->template getInputValue<operand_b>();
Type a_sec_b = this->template getInputValue<operand_a>();
- a_sec_b OP_INPLACE_INTERSECT this->template getInputValue<operand_b>();
+ a_sec_b &= this->template getInputValue<operand_b>();
Type lhs = a_plus_b;
lhs -= a_sec_b;
@@ -446,7 +446,7 @@
std::cout << "a_plus_b=" << a_plus_b.as_string() << std::endl;
Type a_sec_b = this->template getInputValue<operand_a>();
- a_sec_b OP_INPLACE_INTERSECT this->template getInputValue<operand_b>();
+ a_sec_b &= this->template getInputValue<operand_b>();
std::cout << "a_sec_b=" << a_sec_b.as_string() << std::endl;
@@ -511,7 +511,7 @@
// --- left hand side ------------------------
// lhs := a - (a & b)
MapT a_sec_b = this->template getInputValue<operand_a>();
- a_sec_b OP_INPLACE_INTERSECT this->template getInputValue<operand_b>();
+ a_sec_b &= this->template getInputValue<operand_b>();
MapT lhs = this->template getInputValue<operand_a>();
lhs -= a_sec_b;
Modified: sandbox/itl/libs/itl/doc/semantics.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/semantics.qbk (original)
+++ sandbox/itl/libs/itl/doc/semantics.qbk 2009-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -39,8 +39,12 @@
that implements a
[@http://www.sgi.com/tech/stl/StrictWeakOrdering.html strict weak ordering]
(see also [@http://en.wikipedia.org/wiki/Strict_weak_ordering here]).
-The semantics of `operator <` is the same as for the stl's
-AssociativeContainer, especially stl::set and stl::map:
+The semantics of `operator <` is the same as for an stl's
+[@http://www.sgi.com/tech/stl/SortedAssociativeContainer.html SortedAssociativeContainer],
+especially
+[@http://www.sgi.com/tech/stl/set.html stl::set]
+and
+[@http://www.sgi.com/tech/stl/map.html stl::map]:
``
Irreflexivity<T,< > : T a; !(a<a)
Asymmetry<T,< > : T a,b; a<b implies !(b<a)
@@ -55,23 +59,22 @@
`Compare` order to establish a unique sequence of values in
the container.
-The induced equivalence of `operator <` is lexicographical
-equality which is implementd as `operator ==`.
+The induced equivalence of `operator <` is
+lexicographical equality
+which is implementd as `operator ==`.
``
//equivalence induced by strict weak ordering <
!(a<b) && !(b<a) implies a == b;
``
Again this
follows the semantics of the *stl*.
-Lexicographical equality is finer than the equality
+Lexicographical equality is stronger than the equality
of elements. Two containers that contain the same elements
can be lexicographically unqueal, if their elements are
-differently sorted.
-
-Lexicographical comparison belongs to the __iterative__
-aspect. Of all the different sequences that are valid
+differently sorted. Lexicographical comparison belongs to
+the __bi_iterative__ aspect. Of all the different sequences that are valid
for unordered sets and maps, one such sequence is
-selected by the Compare order of elements. Based on
+selected by the `Compare` order of elements. Based on
this selection a unique iteration is possible.
[h4 Subset Ordering and Element Equality]
Modified: sandbox/itl/libs/itl/example/man_power/man_power.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/man_power/man_power.cpp (original)
+++ sandbox/itl/libs/itl/example/man_power/man_power.cpp 2009-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -52,7 +52,7 @@
for(; week_iter <= scope.last(); ++week_iter)
weekends += interval<date>::rightopen(*week_iter, *week_iter + days(2));
- weekends *= scope; // cut off the surplus
+ weekends &= scope; // cut off the surplus
return weekends;
}
@@ -96,7 +96,7 @@
// But Claudia only works 8 hours on regular working days so we do
// an intersection of the interval_map with the interval_set worktime:
- claudias_working_hours *= worktime;
+ claudias_working_hours &= worktime;
// Yet, in addition Claudia has her own absence times like
interval<date> claudias_seminar (from_string("2008-09-16"),
@@ -119,7 +119,7 @@
bodos_working_hours += make_pair(scope, 4);
// Bodo works only on regular working days
- bodos_working_hours *= worktime;
+ bodos_working_hours &= worktime;
// Bodos additional absence times
interval<date> bodos_flu(from_string("2008-09-19"), from_string("2008-09-29"));
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-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -56,7 +56,7 @@
for(; month_iter <= scope.last(); ++month_iter)
month_grid += interval<date>::rightopen(*month_iter, *month_iter + months(1));
- month_grid *= scope; // cut off the surplus
+ month_grid &= scope; // cut off the surplus
return month_grid;
}
@@ -74,7 +74,7 @@
for(; week_iter <= scope.last(); ++week_iter)
week_grid.insert(interval<date>::rightopen(*week_iter, *week_iter + weeks(1)));
- week_grid *= scope; // cut off the surplus
+ week_grid &= scope; // cut off the surplus
return week_grid;
}
@@ -92,7 +92,7 @@
// Compute a month grid
date_grid month_and_week_grid = month_grid(itv);
// Intersection of the month and week grids:
- month_and_week_grid *= week_grid(itv);
+ month_and_week_grid &= week_grid(itv);
cout << "interval : " << itv.first() << " - " << itv.last()
<< " month and week partitions:" << endl;
Modified: sandbox/itl/libs/itl/test/test_interval_map_mixed/test_interval_map_mixed.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_mixed/test_interval_map_mixed.cpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_mixed/test_interval_map_mixed.cpp 2009-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -755,21 +755,21 @@
// split_interval_map
//--------------------------------------------------------------------------
//split_A [0 3) [6 9)
- // *= [1 8)
+ // &= [1 8)
//split_AB -> [1 3) [6 8)
- // *= [2 7)
+ // &= [2 7)
// -> [2 3) [6 7)
SplitIntervalMapT split_A, split_B, split_AB, split_ab, split_ab2;
split_A.add(I0_3D_1).add(I6_9D_1);
split_AB = split_A;
- split_AB *= I1_8D_1;
+ split_AB &= I1_8D_1;
split_ab.add(I1_3D_2).add(I6_8D_2);
BOOST_CHECK_EQUAL( split_AB, split_ab );
split_AB = split_A;
- (split_AB *= I1_8D_1) *= I2_7D_1;
+ (split_AB &= I1_8D_1) &= I2_7D_1;
split_ab2.add(I2_3D_3).add(I6_7D_3);
BOOST_CHECK_EQUAL( split_AB, split_ab2 );
@@ -778,7 +778,7 @@
//--------------------------------------------------------------------------
//split_A [0 3) [6 9)
// 1 1
- // *= 1
+ // &= 1
// 1
//split_AB -> [1]
// 2
@@ -789,15 +789,15 @@
split_A.clear();
split_A.add(I0_3D_1).add(I6_9D_1);
split_AB = split_A;
- split_AB *= mapping_pair<T,U>(v1,u1);
+ split_AB &= mapping_pair<T,U>(v1,u1);
split_ab.clear();
split_ab.add(mapping_pair<T,U>(v1,u2));
BOOST_CHECK_EQUAL( split_AB, split_ab );
split_AB = split_A;
- //(split_AB *= mapping_pair<T,U>(v1,u1)) += make_pair(interval<T>::open(v1,v7), u1); //JODO
- split_AB *= mapping_pair<T,U>(v1,u1);
+ //(split_AB &= mapping_pair<T,U>(v1,u1)) += make_pair(interval<T>::open(v1,v7), u1); //JODO
+ split_AB &= mapping_pair<T,U>(v1,u1);
split_AB += make_pair(interval<T>::open(v1,v7), u2);
split_ab2.clear();
split_ab2 += make_pair(interval<T>::rightopen(v1,v7), u2);
@@ -854,21 +854,21 @@
// split_interval_map
//--------------------------------------------------------------------------
//split_A [0 3) [6 9)
- // *= [1 8)
+ // &= [1 8)
//split_AB -> [1 3) [6 8)
- // *= [2 7)
+ // &= [2 7)
// -> [2 3) [6 7)
SplitIntervalMapT split_A, split_B, split_AB, split_ab, split_ab2;
split_A.add(I0_3D_1).add(I6_9D_1);
split_AB = split_A;
- split_AB *= I1_8D;
+ split_AB &= I1_8D;
split_ab.add(I1_3D_1).add(I6_8D_1);
BOOST_CHECK_EQUAL( split_AB, split_ab );
split_AB = split_A;
- (split_AB *= I1_8D) *= I2_7D;
+ (split_AB &= I1_8D) &= I2_7D;
split_ab2.add(I2_3D_1).add(I6_7D_1);
BOOST_CHECK_EQUAL( split_AB, split_ab2 );
@@ -876,7 +876,7 @@
//--------------------------------------------------------------------------
//split_A [0 3) [6 9)
// 1 1
- // *= 1
+ // &= 1
// 1
//split_AB -> [1]
// 2
@@ -887,15 +887,15 @@
split_A.clear();
split_A.add(I0_3D_1).add(I6_9D_1);
split_AB = split_A;
- split_AB *= v1;
+ split_AB &= v1;
split_ab.clear();
split_ab.add(mapping_pair<T,U>(v1,u1));
BOOST_CHECK_EQUAL( split_AB, split_ab );
split_AB = split_A;
- //(split_AB *= mapping_pair<T,U>(v1,u1)) += make_pair(interval<T>::open(v1,v7), u1); //JODO
- split_AB *= interval<T>(v1);
+ //(split_AB &= mapping_pair<T,U>(v1,u1)) += make_pair(interval<T>::open(v1,v7), u1); //JODO
+ split_AB &= interval<T>(v1);
split_AB += make_pair(interval<T>::open(v1,v7), u1);
split_ab2.clear();
split_ab2 += make_pair(interval<T>::rightopen(v1,v7), u1);
@@ -953,7 +953,7 @@
//--------------------------------------------------------------------------
//split_A [0 3) [6 9)
// 1 1
- //split_B *= [1 2)[2 4) [5 8)
+ //split_B &= [1 2)[2 4) [5 8)
// 1 1 1
//split_AB -> [1 2)[2 3) [6 8)
// 2 2 2
@@ -965,19 +965,19 @@
split_ab.add(I1_2D_2).add(I2_3D_2).add(I6_8D_2);
split_ab_jn.add(I1_3D_2).add(I6_8D_2);
split_AB = split_A;
- split_AB *= split_B;
+ split_AB &= split_B;
BOOST_CHECK_EQUAL( split_AB.iterative_size(), 3 );
BOOST_CHECK_EQUAL( split_AB, split_ab );
//split_A [0 3) [6 9)
// 1 1
- //join_B *= [1 4) [5 8)
+ //join_B &= [1 4) [5 8)
// 1 1
//split_AB -> [1 3) [6 8)
// 2 2
split_AB = split_A;
join_B = split_B;
- split_AB *= join_B;
+ split_AB &= join_B;
BOOST_CHECK_EQUAL( split_AB.iterative_size(), 2 );
BOOST_CHECK_EQUAL( split_AB, split_ab_jn );
@@ -1034,7 +1034,7 @@
//--------------------------------------------------------------------------
//split_A [0 3) [6 9)
// 1 1
- //split_B *= [1 2)[2 4) [5 8)
+ //split_B &= [1 2)[2 4) [5 8)
//split_AB -> [1 2)[2 3) [6 8)
// 1 1 1
SplitIntervalMapT split_A, split_AB, split_ab, split_ab_jn;
@@ -1047,18 +1047,18 @@
split_ab.add(I1_2D_1).add(I2_3D_1).add(I6_8D_1);
split_ab_jn.add(I1_3D_1).add(I6_8D_1);
split_AB = split_A;
- split_AB *= split_B;
+ split_AB &= split_B;
BOOST_CHECK_EQUAL( split_AB.iterative_size(), 3 );
BOOST_CHECK_EQUAL( split_AB, split_ab );
//split_A [0 3) [6 9)
// 1 1
- //join_B *= [1 4) [5 8)
+ //join_B &= [1 4) [5 8)
//split_AB -> [1 3) [6 8)
// 1 1
split_AB = split_A;
join_B = split_B;
- split_AB *= join_B;
+ split_AB &= join_B;
BOOST_CHECK_EQUAL( split_AB.iterative_size(), 2 );
BOOST_CHECK_EQUAL( split_AB, split_ab_jn );
Modified: sandbox/itl/libs/itl/test/test_interval_map_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_map_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_map_shared.hpp 2009-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -99,9 +99,9 @@
BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
//insecting emptieness
- (mt_map OP_INPLACE_INTERSECT mt_u1) OP_INPLACE_INTERSECT mt_u1;
+ (mt_map &= mt_u1) &= mt_u1;
BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
- (mt_map OP_INPLACE_INTERSECT mt_interval) OP_INPLACE_INTERSECT mt_interval;
+ (mt_map &= mt_interval) &= mt_interval;
BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
@@ -489,7 +489,7 @@
BOOST_CHECK_EQUAL( is_disjoint(left, right), false );
(all += left) += right;
- (section += left) OP_INPLACE_INTERSECT right;
+ (section += left) &= right;
all -= section;
complement += all;
//complement.erase(I3_5I);
@@ -497,7 +497,7 @@
BOOST_CHECK_EQUAL( is_disjoint(section, complement), true );
//JODO: There seems to be no intersection on maps of non set codomain type
- // that can be implemented via OP_INPLACE_INTERSECT propagation. Intersectin on those types
+ // that can be implemented via &= propagation. Intersectin on those types
// could be dome elementic defining it via intersection on the set of pairs.
//if(boost::is_same<T,int>::value)
//{
@@ -569,23 +569,23 @@
//--------------------------------------------------------------------------
//map_A [0 3) [6 9)
// 1 1
- // OP_INPLACE_INTERSECT [1 8)
+ // &= [1 8)
//map_AB -> [1 3) [6 8)
// 1 1
- // OP_INPLACE_INTERSECT [2 7)
+ // &= [2 7)
// -> [2 3) [6 7)
// 1 1
IntervalMap<T,U> map_A, map_AB, map_ab, map_ab2;
interval_set<T> set_B;
map_A.add(I0_3D_1).add(I6_9D_1);
map_AB = map_A;
- map_AB OP_INPLACE_INTERSECT I1_8D;
+ map_AB &= I1_8D;
map_ab.add(I1_3D_1).add(I6_8D_1);
BOOST_CHECK_EQUAL( map_AB, map_ab );
map_AB = map_A;
- (map_AB OP_INPLACE_INTERSECT I1_8D) OP_INPLACE_INTERSECT I2_7D;
+ (map_AB &= I1_8D) &= I2_7D;
map_ab2.add(I2_3D_1).add(I6_7D_1);
BOOST_CHECK_EQUAL( map_AB, map_ab2 );
@@ -593,10 +593,10 @@
//--------------------------------------------------------------------------
//map_A [0 3) [6 9)
// 1 1
- // OP_INPLACE_INTERSECT [1 4) [5 8)
+ // &= [1 4) [5 8)
//map_AB -> [1 3) [6 8)
// 1 1
- // OP_INPLACE_INTERSECT [2 4) [5 7)
+ // &= [2 4) [5 7)
// -> [2 3) [6 7)
// 1 1
map_A.clear();
@@ -604,7 +604,7 @@
set_B.add(I1_4D).add(I5_8D);
map_AB = map_A;
- map_AB OP_INPLACE_INTERSECT set_B;
+ map_AB &= set_B;
map_ab.clear();
map_ab.add(I1_3D_1).add(I6_8D_1);
BOOST_CHECK_EQUAL( map_AB, map_ab );
@@ -612,7 +612,7 @@
//--------------------------------------------------------------------------
//map_A [0 3) [6 9)
// 1 1
- // OP_INPLACE_INTERSECT 1
+ // &= 1
//map_AB -> [1]
// 1
@@ -620,7 +620,7 @@
//map_A.clear();
//map_A.add(I0_3D_1).add(I6_9D_1);
//map_AB = map_A;
- //map_AB OP_INPLACE_INTERSECT v1;
+ //map_AB &= v1;
//map_ab.clear();
//map_ab.add(v1);
Modified: sandbox/itl/libs/itl/test/test_interval_set_mixed/test_interval_set_mixed.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_mixed/test_interval_set_mixed.cpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_mixed/test_interval_set_mixed.cpp 2009-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -532,21 +532,21 @@
// split_interval_set
//--------------------------------------------------------------------------
//split_A [0 3) [6 9)
- // OP_INPLACE_INTERSECT [1 8)
+ // &= [1 8)
//split_AB -> [1 3) [6 8)
- // OP_INPLACE_INTERSECT [2 7)
+ // &= [2 7)
// -> [2 3) [6 7)
split_interval_set<T> split_A, split_B, split_AB, split_ab, split_ab2;
split_A.add(I0_3D).add(I6_9D);
split_AB = split_A;
- split_AB OP_INPLACE_INTERSECT I1_8D;
+ split_AB &= I1_8D;
split_ab.add(I1_3D).add(I6_8D);
BOOST_CHECK_EQUAL( split_AB, split_ab );
split_AB = split_A;
- (split_AB OP_INPLACE_INTERSECT I1_8D) OP_INPLACE_INTERSECT I2_7D;
+ (split_AB &= I1_8D) &= I2_7D;
split_ab2.add(I2_3D).add(I6_7D);
BOOST_CHECK_EQUAL( split_AB, split_ab2 );
@@ -554,20 +554,20 @@
//--------------------------------------------------------------------------
//split_A [0 3) [6 9)
- // OP_INPLACE_INTERSECT 1
+ // &= 1
//split_AB -> [1]
// += (1 7)
// -> [1](1 7)
split_A.add(I0_3D).add(I6_9D);
split_AB = split_A;
- split_AB OP_INPLACE_INTERSECT v1;
+ split_AB &= v1;
split_ab.clear();
split_ab.add(v1);
BOOST_CHECK_EQUAL( split_AB, split_ab );
split_AB = split_A;
- (split_AB OP_INPLACE_INTERSECT v1) += interval<T>::open(v1,v7);
+ (split_AB &= v1) += interval<T>::open(v1,v7);
split_ab2.clear();
split_ab2 += interval<T>::rightopen(v1,v7);
@@ -600,7 +600,7 @@
// split_interval_set
//--------------------------------------------------------------------------
//split_A [0 3) [6 9)
- //split_B OP_INPLACE_INTERSECT [1 2)[2 4) [5 8)
+ //split_B &= [1 2)[2 4) [5 8)
//split_AB -> [1 2)[2 3) [6 8)
split_interval_set<T> split_A, split_B, split_AB, split_ab, split_ab_jn;
separate_interval_set<T> sep_A, sep_B, sep_AB, sep_ab;
@@ -611,25 +611,25 @@
split_ab.add(I1_2D).add(I2_3D).add(I6_8D);
split_ab_jn.add(I1_3D).add(I6_8D);
split_AB = split_A;
- split_AB OP_INPLACE_INTERSECT split_B;
+ split_AB &= split_B;
BOOST_CHECK_EQUAL( split_AB.iterative_size(), 3 );
BOOST_CHECK_EQUAL( split_AB, split_ab );
//split_A [0 3) [6 9)
- //sep_B OP_INPLACE_INTERSECT [1 2)[2 4) [5 8)
+ //sep_B &= [1 2)[2 4) [5 8)
//split_AB -> [1 2)[2 3) [6 8)
split_AB = split_A;
sep_B = split_B;
- split_AB OP_INPLACE_INTERSECT sep_B;
+ split_AB &= sep_B;
BOOST_CHECK_EQUAL( split_AB.iterative_size(), 3 );
BOOST_CHECK_EQUAL( split_AB, split_ab );
//split_A [0 3) [6 9)
- //join_B OP_INPLACE_INTERSECT [1 4) [5 8)
+ //join_B &= [1 4) [5 8)
//split_AB -> [1 3) [6 8)
split_AB = split_A;
join_B = split_B;
- split_AB OP_INPLACE_INTERSECT join_B;
+ split_AB &= join_B;
BOOST_CHECK_EQUAL( split_AB.iterative_size(), 2 );
BOOST_CHECK_EQUAL( split_AB, split_ab_jn );
@@ -638,34 +638,34 @@
// separate_interval_set
//--------------------------------------------------------------------------
//sep_A [0 3) [6 9)
- //sep_B OP_INPLACE_INTERSECT [1 2)[2 4) [5 8)
+ //sep_B &= [1 2)[2 4) [5 8)
//sep_AB -> [1 2)[2 3) [6 8)
sep_ab = split_ab;
BOOST_CHECK_EQUAL( sep_ab.iterative_size(), 3 );
sep_AB = split_A;
sep_B = split_B;
- sep_AB OP_INPLACE_INTERSECT sep_B;
+ sep_AB &= sep_B;
BOOST_CHECK_EQUAL( sep_AB.iterative_size(), 3 );
BOOST_CHECK_EQUAL( sep_AB, sep_ab );
//sep_A [0 3) [6 9)
- //split_B OP_INPLACE_INTERSECT [1 2)[2 4) [5 8)
+ //split_B &= [1 2)[2 4) [5 8)
//sep_AB -> [1 2)[2 3) [6 8)
sep_AB = split_A;
- sep_AB OP_INPLACE_INTERSECT split_B;
+ sep_AB &= split_B;
BOOST_CHECK_EQUAL( sep_AB.iterative_size(), 3 );
BOOST_CHECK_EQUAL( sep_AB, sep_ab );
//sep_A [0 3) [6 9)
- //join_B OP_INPLACE_INTERSECT [1 4) [5 8)
+ //join_B &= [1 4) [5 8)
//sep_AB -> [1 3) [6 8)
separate_interval_set<T> sep_ab_jn = split_ab_jn;
sep_AB = split_A;
join_B = split_B;
- sep_AB OP_INPLACE_INTERSECT join_B;
+ sep_AB &= join_B;
BOOST_CHECK_EQUAL( sep_AB.iterative_size(), 2 );
BOOST_CHECK_EQUAL( sep_AB, sep_ab_jn );
@@ -674,32 +674,32 @@
// separate_interval_set
//--------------------------------------------------------------------------
//join_A [0 3) [6 9)
- //join_B OP_INPLACE_INTERSECT [1 4) [5 8)
+ //join_B &= [1 4) [5 8)
//join_AB -> [1 3) [6 8)
join_ab = split_ab;
BOOST_CHECK_EQUAL( join_ab.iterative_size(), 2 );
join_AB = split_A;
join_B = split_B;
- join_AB OP_INPLACE_INTERSECT sep_B;
+ join_AB &= sep_B;
BOOST_CHECK_EQUAL( join_AB.iterative_size(), 2 );
BOOST_CHECK_EQUAL( join_AB, join_ab );
//join_A [0 3) [6 9)
- //split_B OP_INPLACE_INTERSECT [1 2)[2 4) [5 8)
+ //split_B &= [1 2)[2 4) [5 8)
//join_AB -> [1 3) [6 8)
join_AB = split_A;
- join_AB OP_INPLACE_INTERSECT split_B;
+ join_AB &= split_B;
BOOST_CHECK_EQUAL( join_AB.iterative_size(), 2 );
BOOST_CHECK_EQUAL( join_AB, join_ab );
//join_A [0 3) [6 9)
- //sep_B OP_INPLACE_INTERSECT [1 2)[2 4) [5 8)
+ //sep_B &= [1 2)[2 4) [5 8)
//join_AB -> [1 3) [6 8)
join_AB = split_A;
- join_AB OP_INPLACE_INTERSECT sep_B;
+ join_AB &= sep_B;
BOOST_CHECK_EQUAL( join_AB.iterative_size(), 2 );
BOOST_CHECK_EQUAL( join_AB, join_ab );
Modified: sandbox/itl/libs/itl/test/test_interval_set_shared.hpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_interval_set_shared.hpp (original)
+++ sandbox/itl/libs/itl/test/test_interval_set_shared.hpp 2009-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -84,13 +84,13 @@
//insecting emptieness
//mt_set.insect(mt_interval).insect(mt_interval);
//BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
- (mt_set OP_INPLACE_INTERSECT mt_interval) OP_INPLACE_INTERSECT mt_interval;
+ (mt_set &= mt_interval) &= mt_interval;
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
//insecting emptieness with elements
- (mt_set OP_INPLACE_INTERSECT v1) OP_INPLACE_INTERSECT v0;
+ (mt_set &= v1) &= v0;
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
//insecting emptieness with intervals
- (mt_set OP_INPLACE_INTERSECT I1_1I) OP_INPLACE_INTERSECT I0_1I;
+ (mt_set &= I1_1I) &= I0_1I;
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
//-------------------------------------------------------------------------
@@ -411,7 +411,7 @@
BOOST_CHECK_EQUAL( is_disjoint(left, right), false );
(all += left) += right;
- (section += left) OP_INPLACE_INTERSECT right;
+ (section += left) &= right;
(complement += all) -= section;
(all2 += section) += complement;
@@ -466,21 +466,21 @@
// IntervalSet
//--------------------------------------------------------------------------
//split_A [0 3) [6 9)
- // OP_INPLACE_INTERSECT [1 8)
+ // &= [1 8)
//split_AB -> [1 3) [6 8)
- // OP_INPLACE_INTERSECT [2 7)
+ // &= [2 7)
// -> [2 3) [6 7)
IntervalSet<T> split_A, split_B, split_AB, split_ab, split_ab2;
split_A.add(I0_3D).add(I6_9D);
split_AB = split_A;
- split_AB OP_INPLACE_INTERSECT I1_8D;
+ split_AB &= I1_8D;
split_ab.add(I1_3D).add(I6_8D);
BOOST_CHECK_EQUAL( split_AB, split_ab );
split_AB = split_A;
- (split_AB OP_INPLACE_INTERSECT I1_8D) OP_INPLACE_INTERSECT I2_7D;
+ (split_AB &= I1_8D) &= I2_7D;
split_ab2.add(I2_3D).add(I6_7D);
BOOST_CHECK_EQUAL( split_AB, split_ab2 );
@@ -488,20 +488,20 @@
//--------------------------------------------------------------------------
//split_A [0 3) [6 9)
- // OP_INPLACE_INTERSECT 1
+ // &= 1
//split_AB -> [1]
// += (1 7)
// -> [1](1 7)
split_A.add(I0_3D).add(I6_9D);
split_AB = split_A;
- split_AB OP_INPLACE_INTERSECT v1;
+ split_AB &= v1;
split_ab.clear();
split_ab.add(v1);
BOOST_CHECK_EQUAL( split_AB, split_ab );
split_AB = split_A;
- (split_AB OP_INPLACE_INTERSECT v1) += interval<T>::open(v1,v7);
+ (split_AB &= v1) += interval<T>::open(v1,v7);
split_ab2.clear();
split_ab2 += interval<T>::rightopen(v1,v7);
Modified: sandbox/itl/libs/itl/test/test_itl_interval/test_itl_interval.cpp
==============================================================================
--- sandbox/itl/libs/itl/test/test_itl_interval/test_itl_interval.cpp (original)
+++ sandbox/itl/libs/itl/test/test_itl_interval/test_itl_interval.cpp 2009-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -239,33 +239,33 @@
interval<T> I3_7D = interval<T>::rightopen(v3,v7);
interval<T> I0_3D = interval<T>::rightopen(v0,v3);
- section = I3_7D; section OP_INPLACE_INTERSECT I0_3D;
+ section = I3_7D; section &= I0_3D;
BOOST_CHECK_EQUAL( I0_3D.is_disjoint(I3_7D), true );
BOOST_CHECK_EQUAL( section.empty(), true );
BOOST_CHECK_EQUAL( section, interval<T>() );
interval<T> I0_5D = interval<T>::rightopen(v0,v5);
- section = I3_7D; section OP_INPLACE_INTERSECT I0_5D;
+ section = I3_7D; section &= I0_5D;
BOOST_CHECK_EQUAL( section, interval<T>::rightopen(v3, v5) );
interval<T> I0_9D = interval<T>::rightopen(v0,v9);
- section = I3_7D; section OP_INPLACE_INTERSECT I0_9D;
+ section = I3_7D; section &= I0_9D;
BOOST_CHECK_EQUAL( section, I3_7D );
interval<T> I4_5I = interval<T>::closed(v4,v5);
- section = I3_7D; section OP_INPLACE_INTERSECT I4_5I;
+ section = I3_7D; section &= I4_5I;
BOOST_CHECK_EQUAL( section, I4_5I );
interval<T> C4_6D = interval<T>::open(v4,v6);
- section = I3_7D; section OP_INPLACE_INTERSECT C4_6D;
+ section = I3_7D; section &= C4_6D;
BOOST_CHECK_EQUAL( section, C4_6D );
interval<T> C4_9I = interval<T>::leftopen(v4,v9);
- section = I3_7D; section OP_INPLACE_INTERSECT C4_9I;
+ section = I3_7D; section &= C4_9I;
BOOST_CHECK_EQUAL( section, interval<T>::open(v4,v7) );
interval<T> I7_9I = interval<T>::closed(v7,v9);
- section = I3_7D; section OP_INPLACE_INTERSECT I7_9I;
+ section = I3_7D; section &= I7_9I;
BOOST_CHECK_EQUAL( I3_7D.exclusive_less(I7_9I), true );
BOOST_CHECK_EQUAL( I3_7D.is_disjoint(I7_9I), true );
BOOST_CHECK_EQUAL( section.empty(), true );
Modified: sandbox/itl/libs/itl_xt/test/itvsettester.h
==============================================================================
--- sandbox/itl/libs/itl_xt/test/itvsettester.h (original)
+++ sandbox/itl/libs/itl_xt/test/itvsettester.h 2009-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -509,7 +509,7 @@
xx_uni_yy += yy;
xx_sec_yy = xx;
- xx_sec_yy OP_INPLACE_INTERSECT yy;
+ xx_sec_yy &= yy;
lhs = xx_uni_yy;
lhs -= xx_sec_yy;
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-01-12 11:52:04 EST (Mon, 12 Jan 2009)
@@ -226,8 +226,8 @@
typedef interval_map<int,int> QuantifierT;
QuantifierT sec_map;
sec_map += make_pair(interval<int>::rightopen(1,5), 1);
- sec_map *= make_pair(interval<int>::rightopen(3,7), 1);
- //sec_map *= QuantifierT(make_pair(interval<int>::rightopen(3,7), 1));
+ sec_map &= make_pair(interval<int>::rightopen(3,7), 1);
+ //sec_map &= QuantifierT(make_pair(interval<int>::rightopen(3,7), 1));
cout << "sec_map: " << sec_map << endl;
}
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