Subject: [Boost-commit] svn:boost r50552 - in sandbox/itl: boost/itl boost/validate/laws libs/itl/doc libs/itl/example/month_and_week_grid libs/itl/example/user_groups libs/itl/test 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 09:57:06
Author: jofaber
Date: 2009-01-12 09:57:04 EST (Mon, 12 Jan 2009)
New Revision: 50552
URL: http://svn.boost.org/trac/boost/changeset/50552
Log:
Refactored. Replaced intersection op *= and * by OP_INPLACE_INTERSECT and OP_INTERSECT.
Stable {msvc-9.0, partly congcc-4.3-a7}
Text files modified:
sandbox/itl/boost/itl/functors.hpp | 4 +-
sandbox/itl/boost/itl/interval.hpp | 4 +-
sandbox/itl/boost/itl/interval_base_map.hpp | 34 +++++++++++--------
sandbox/itl/boost/itl/interval_base_set.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 | 36 ++++++++++----------
sandbox/itl/libs/itl/doc/concepts.qbk | 10 ++--
sandbox/itl/libs/itl/doc/interface.qbk | 2
sandbox/itl/libs/itl/doc/semantics.qbk | 68 ++++++++++++++++++++--------------------
sandbox/itl/libs/itl/example/month_and_week_grid/month_and_week_grid.cpp | 2
sandbox/itl/libs/itl/example/user_groups/user_groups.cpp | 2
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 | 6 +++
21 files changed, 169 insertions(+), 156 deletions(-)
Modified: sandbox/itl/boost/itl/functors.hpp
==============================================================================
--- sandbox/itl/boost/itl/functors.hpp (original)
+++ sandbox/itl/boost/itl/functors.hpp 2009-01-12 09:57:04 EST (Mon, 12 Jan 2009)
@@ -188,13 +188,13 @@
: public neutron_based_inplace_combine<Type>
{
void operator()(Type& object, const Type& operand)const
- { object *= operand; }
+ { object OP_INPLACE_INTERSECT operand; }
static Type neutron() { return boost::itl::neutron<Type>::value(); }
};
template<>
- inline std::string unary_template_to_string<inplace_star>::apply() { return "*="; }
+ inline std::string unary_template_to_string<inplace_star>::apply() { return "&="; }
// ------------------------------------------------------------------------
template <typename Type> struct inplace_slash
Modified: sandbox/itl/boost/itl/interval.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval.hpp (original)
+++ sandbox/itl/boost/itl/interval.hpp 2009-01-12 09:57:04 EST (Mon, 12 Jan 2009)
@@ -162,7 +162,7 @@
\subsection user_groups_subsec User Groups: Union and intersecion of histories
Example user_groups.cpp shows how interval_maps can be unified (+=) or
- intersected (*=) to calculate desired informations.
+ intersected (&=) to calculate desired informations.
We have a group of
admin users and of medcial staff, who have different authorisations in
@@ -1165,7 +1165,7 @@
// operators
// ----------------------------------------------------------------------------
template <class DomainT, ITL_COMPARE Compare>
-itl::interval<DomainT,Compare>& operator *= ( itl::interval<DomainT,Compare>& section,
+itl::interval<DomainT,Compare>& operator OP_INPLACE_INTERSECT ( itl::interval<DomainT,Compare>& section,
const itl::interval<DomainT,Compare>& sectant)
{
section.intersect(section, sectant);
Modified: sandbox/itl/boost/itl/interval_base_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_map.hpp 2009-01-12 09:57:04 EST (Mon, 12 Jan 2009)
@@ -707,7 +707,7 @@
//-----------------------------------------------------------------------------
/** @name H.mor: Morphic modifiers */
-//@{
+
/// Removal of neutral element values
/** All value pairs \c (I,y) that have neutral elements \c y==codomain_type()
@@ -746,7 +746,7 @@
const_FOR_IMPLMAP(it)
dom += (*it).KEY_VALUE;
}
-//@}
+
@@ -757,7 +757,7 @@
as a generalized find operation on interval maps.
All find operations can be expressed by means of intersection \ref intersect
- or \ref operator *=. Searching for an interval in an interval map yields
+ or \ref operator &=. Searching for an interval in an interval map yields
an interval map anyway in the general case.
*/
//@}
@@ -814,27 +814,23 @@
std::string as_string() const;
//@}
-/** @name T: For discrete domain datatypes only that implement operators <tt>++</tt>
- and <tt>--</tt>
- */
-//@{
- /** Smallest element of the map (wrt. the partial ordering on DomainT).
+ /* Smallest element of the map (wrt. the partial ordering on DomainT).
first() does not exist for continuous datatypes and open interval bounds.
*/
DomainT first()const { return (*(_map.begin())).KEY_VALUE.first(); } // JODO NONCONT
- /** Largest element of the map (wrt. the partial ordering on DomainT).
+ /* Largest element of the map (wrt. the partial ordering on DomainT).
first() does not exist for continuous datatypes and open interval bounds.
*/
DomainT last()const { return (*(_map.rbegin())).KEY_VALUE.last(); } // JODO NONCONT
- /** Sum of associated elements of the map
+ /* Sum of associated elements of the map
<b>Nicht getestet</b> */
CodomainT sum()const;
- /** Set interval bounds to the type <tt>bt</tt> for intervals in the map.
+ /** Set interval bounds to the type <tt>bt</tt> for intervals in the map.
Interval bounds of different types are created by opeations on
interval maps. This function allows to reset them uniformly without,
@@ -844,10 +840,6 @@
void uniformBounds( typename interval<DomainT>::bound_types bt);
void closeLeftBounds();
-//@}
-
- void recJoin();
-
template<typename IteratorT>
static const key_type& key_value(IteratorT& value_){ return (*value_).first; }
@@ -1235,6 +1227,18 @@
class SubType,
class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
>
+inline bool operator != (const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
+ const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
+{
+ return !(lhs == rhs);
+}
+
+
+template
+<
+ class SubType,
+ class DomainT, class CodomainT, class Traits, ITL_COMPARE Compare, ITL_COMBINE Combine, ITL_SECTION Section, template<class,ITL_COMPARE>class Interval, ITL_ALLOC Alloc
+>
inline bool is_protonic_equal(const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
{
Modified: sandbox/itl/boost/itl/interval_base_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_set.hpp 2009-01-12 09:57:04 EST (Mon, 12 Jan 2009)
@@ -338,7 +338,7 @@
/** Perform intersection of <tt>*this</tt> and <tt>x</tt>; assign result
to <tt>*this</tt>
- Aufruf <tt>x *= y</tt> bedeutet <tt>x = x geschnitten mit y </tt>
+ Aufruf <tt>x &= y</tt> bedeutet <tt>x = x geschnitten mit y </tt>
*/
//@}
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 09:57: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 *=
+operator OP_INPLACE_INTERSECT
(
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 *
+operator OP_INTERSECT
(
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) *= operand;
+ return ObjectT(object) OP_INPLACE_INTERSECT operand;
}
//-----------------------------------------------------------------------------
@@ -624,7 +624,7 @@
class IntervalMap
>
IntervalMap<DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>&
-operator *=
+operator OP_INPLACE_INTERSECT
(
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 *
+operator OP_INTERSECT
(
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) *= operand;
+ return ObjectT(object) OP_INPLACE_INTERSECT 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 09:57: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 *=
+operator OP_INPLACE_INTERSECT
(
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 *
+operator OP_INTERSECT
(
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) *= operand;
+ return ObjectT(object) OP_INPLACE_INTERSECT operand;
}
//-----------------------------------------------------------------------------
@@ -310,7 +310,7 @@
template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
IntervalSet<DomainT,Compare,Interval,Alloc>&
-operator *=
+operator OP_INPLACE_INTERSECT
(
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 *
+operator OP_INTERSECT
(
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) *= operand;
+ return ObjectT(object) OP_INPLACE_INTERSECT operand;
}
//-----------------------------------------------------------------------------
@@ -356,7 +356,7 @@
template<class, ITL_COMPARE, template<class,ITL_COMPARE>class, ITL_ALLOC>class IntervalSet
>
IntervalSet<DomainT,Compare,Interval,Alloc>&
-operator *=
+operator OP_INPLACE_INTERSECT
(
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 *= interval_type(value);
+ return object OP_INPLACE_INTERSECT 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 *
+operator OP_INTERSECT
(
const IntervalSet<DomainT,Compare,Interval,Alloc>& object,
const DomainT& operand
)
{
typedef IntervalSet<DomainT,Compare,Interval,Alloc> ObjectT;
- return ObjectT(object) *= operand;
+ return ObjectT(object) OP_INPLACE_INTERSECT operand;
}
//-----------------------------------------------------------------------------
Modified: sandbox/itl/boost/itl/map.hpp
==============================================================================
--- sandbox/itl/boost/itl/map.hpp (original)
+++ sandbox/itl/boost/itl/map.hpp 2009-01-12 09:57: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 *= (const map& x2)
+ map& operator OP_INPLACE_INTERSECT (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 *= (const set_type& x2)
+ map& operator OP_INPLACE_INTERSECT (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 09:57:04 EST (Mon, 12 Jan 2009)
@@ -126,6 +126,9 @@
//------------------------------------------------------------------------------
#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 09:57: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 *= (const set& x) { Set::intersect(*this, x); return *this; }
+ set& operator OP_INPLACE_INTERSECT (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 09:57:04 EST (Mon, 12 Jan 2009)
@@ -131,7 +131,7 @@
{
/** a + (b * c) == (a + b) * (a + c)
a(1)(b(2)c) == (a(1)b)(2)(a(1)c)
- computed using inplace operators +=, += and *=
+ computed using inplace operators +=, += and &=
Input = (a := inVal1, b := inVal2, c := inVal3)
Output = (lhs_result, rhs_result)
*/
@@ -229,15 +229,15 @@
: public Law<InplaceDeMorgan<Type,Operator1,Operator2,Equality>,
LOKI_TYPELIST_3(Type,Type,Type), LOKI_TYPELIST_2(Type,Type)>
{
- /** a - (b + c) == (a - b) * (a - c)
+ /** a - (b + c) == (a - b) & (a - c)
a - (b(1)c) == (a - b)(2)(a - c)
- computed using inplace operators +=, += and *=
+ computed using inplace operators +=, += and &=
Input = (a := inVal1, b := inVal2, c := inVal3)
Output = (lhs_result, rhs_result)
*/
public:
std::string name()const { return "InplacePlusDeMorgan"; }
- std::string formula()const { return "a - (b + c) == (a - b) * (a - c) 'inplace'"; }
+ std::string formula()const { return "a - (b + c) == (a - b) & (a - c) 'inplace'"; }
std::string typeString()const
{
@@ -251,7 +251,7 @@
bool holds()
{
- // a - (b + c) == (a - b) * (a - c)
+ // a - (b + c) == (a - b) & (a - c)
// --- left hand side ------------------------
Type b_plus_c = this->template getInputValue<operand_b>();
Operator1<Type>()(b_plus_c, this->template getInputValue<operand_c>());
@@ -267,7 +267,7 @@
Type a_minus_c = this->template getInputValue<operand_a>();
a_minus_c -= this->template getInputValue<operand_c>();
- // rhs := (a - b) * (a - c)
+ // rhs := (a - b) & (a - c)
Type rhs = a_minus_b;
Operator2<Type>()(rhs, a_minus_c);
@@ -298,7 +298,7 @@
LOKI_TYPELIST_3(Type,Type,Type), LOKI_TYPELIST_2(Type,Type)>
{
/** (a + b) - c == (a - c) + (b - c)
- computed using inplace operators +=, -= and *=
+ computed using inplace operators +=, -= and &=
Input = (a := inVal1, b := inVal2, c := inVal3)
Output = (lhs_result, rhs_result)
*/
@@ -391,14 +391,14 @@
: public Law<InplaceSymmetricDifference<Type>,
LOKI_TYPELIST_2(Type,Type), LOKI_TYPELIST_2(Type,Type)>
{
- /** (a + b) - (a * b) == (a - b) + (b - a)
- computed using inplace operators +=, += and *=
+ /** (a + b) - (a & b) == (a - b) + (b - a)
+ computed using inplace operators +=, += and &=
Input = (a := inVal1, b := inVal2)
Output = (lhs_result, rhs_result)
*/
public:
std::string name()const { return "Inplace Symmetric Difference"; }
- std::string formula()const { return "(a+b) - (a*b) == (a-b) + (b-a) 'inplace'"; }
+ std::string formula()const { return "(a+b) - (a&b) == (a-b) + (b-a) 'inplace'"; }
std::string typeString()const
{
@@ -415,7 +415,7 @@
a_plus_b += this->template getInputValue<operand_b>();
Type a_sec_b = this->template getInputValue<operand_a>();
- a_sec_b *= this->template getInputValue<operand_b>();
+ a_sec_b OP_INPLACE_INTERSECT 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 *= this->template getInputValue<operand_b>();
+ a_sec_b OP_INPLACE_INTERSECT this->template getInputValue<operand_b>();
std::cout << "a_sec_b=" << a_sec_b.as_string() << std::endl;
@@ -488,14 +488,14 @@
: public Law<SectionAbsorbtion<MapT>,
LOKI_TYPELIST_2(MapT, typename MapT::set_type), LOKI_TYPELIST_2(MapT,MapT)>
{
- /** a - (a * b) == a - b
- computed using inplace operators -= and *=
+ /** a - (a & b) == a - b
+ computed using inplace operators -= and &=
Input = (a := inVal1, b := inVal2)
Output = (lhs_result, rhs_result)
*/
public:
std::string name()const { return "SectionAbsorbtion"; }
- std::string formula()const { return "map a, set b: a - (a * b) == a - b 'inplace'"; }
+ std::string formula()const { return "map a, set b: a - (a & b) == a - b 'inplace'"; }
std::string typeString()const
{
@@ -507,11 +507,11 @@
bool holds()
{
- // a - (a * b) == a - b
+ // a - (a & b) == a - b
// --- left hand side ------------------------
- // lhs := a - (a * b)
+ // lhs := a - (a & b)
MapT a_sec_b = this->template getInputValue<operand_a>();
- a_sec_b *= this->template getInputValue<operand_b>();
+ a_sec_b OP_INPLACE_INTERSECT this->template getInputValue<operand_b>();
MapT lhs = this->template getInputValue<operand_a>();
lhs -= a_sec_b;
Modified: sandbox/itl/libs/itl/doc/concepts.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/concepts.qbk (original)
+++ sandbox/itl/libs/itl/doc/concepts.qbk 2009-01-12 09:57:04 EST (Mon, 12 Jan 2009)
@@ -37,7 +37,7 @@
On the __conceptual__ aspect
-* in __itv__ implements a set of elements partially.
+* an __itv__ implements a set of elements partially.
* an __itv_set__ implements a set of elements.
* an __itv_map__ implements a map of element value pairs.
@@ -67,8 +67,8 @@
[[] [] [`Set operator + (const Set& s1, const Set& s2)`]]
[[set difference] [inplace][`Set& operator -= (Set& s1, const Set& s2)`] ]
[[] [] [`Set operator - (const Set& s1, const Set& s2)`]]
-[[set intersection][inplace][`Set& operator *= (Set& s1, const Set& s2)`] ]
-[[] [] [`Set operator * (const Set& s1, const Set& s2)`]]
+[[set intersection][inplace][`Set& operator &= (Set& s1, const Set& s2)`] ]
+[[] [] [`Set operator & (const Set& s1, const Set& s2)`]]
]
Equality on `Sets` is not implemented as `operator ==`, because `operator ==`
@@ -108,8 +108,8 @@
[[] [] [`Map operator + (const Map& s1, const Map& s2)`]]
[[set difference] [inplace][`Map& operator -= (Map& s1, const Map& s2)`] ]
[[] [] [`Map operator - (const Map& s1, const Map& s2)`]]
-[[set intersection][inplace][`Map& operator *= (Map& s1, const Map& s2)`] ]
-[[] [] [`Map operator * (const Map& s1, const Map& s2)`]]
+[[set intersection][inplace][`Map& operator &= (Map& s1, const Map& s2)`] ]
+[[] [] [`Map operator & (const Map& s1, const Map& s2)`]]
]
As one can see, on the abstract kernel the signatures of the itl's `Set` and `Map`
Modified: sandbox/itl/libs/itl/doc/interface.qbk
==============================================================================
--- sandbox/itl/libs/itl/doc/interface.qbk (original)
+++ sandbox/itl/libs/itl/doc/interface.qbk 2009-01-12 09:57:04 EST (Mon, 12 Jan 2009)
@@ -386,7 +386,7 @@
[[['*Intersection*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
[[void intersect(T&, const P&)const] [__i] [__eiS][__eiS __bpM][ ] [ ] [ ] [ ]]
[[void add_intersection(T&, const P&)const][][__eiS][__eiS __bpM][ ] [ ] [ ] [ ]]
-[[T& operator*=(T&, const P&)] [__i] [__eiS][__eiS __bpM][?__eS][?__bM] [ ] [ ]]
+[[T& operator&=(T&, const P&)] [__i] [__eiS][__eiS __bpM][?__eS][?__bM] [ ] [ ]]
[[['*Iterator related*]] [ ] [ ] [ ] [ ] [ ] [ ] [ ]]
[[J begin()] [ ] [2] [2] [2] [2] [2] [2]]
[[J end()] [ ] [2] [2] [2] [2] [2] [2]]
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 09:57:04 EST (Mon, 12 Jan 2009)
@@ -149,11 +149,11 @@
[h5 Laws on set intersection]
For the operation ['*set intersection*] available as
-`operator *, *=, &, &=` these laws were validated:
+`operator &, &=` these laws were validated:
``
-Associativity<S,*,== >: S a,b,c; a*(b*c) == (a*b)*c
-Commutativity<S,*,== >: S a,b; a*b == b*a
+Associativity<S,&,== >: S a,b,c; a&(b&c) == (a&b)&c
+Commutativity<S,&,== >: S a,b; a&b == b&a
``
Neutrality has *not* been validated to avoid
@@ -171,7 +171,7 @@
SelfRemovability<S,-,== >: S a; a - a == S()
``
-Summarized in the next table are laws that use `+`, `*` and `-`
+Summarized in the next table are laws that use `+`, `&` and `-`
as a single operation. For all validated laws,
the left and right hand sides of the equations
are lexicographically equal, as denoted by `==` in the cells
@@ -190,17 +190,17 @@
Laws, like distributivity, that use more than one operation can
sometimes be instantiated for different sequences of operators
as can be seen below. In the two instantiations of the distributivity
-laws operators `+` and `*` are swapped. So we can have small operator
-signatures like `+,*` and `*,+` to describe such instantiations,
+laws operators `+` and `&` are swapped. So we can have small operator
+signatures like `+,&` and `&,+` to describe such instantiations,
which will be used below.
Not all instances of distributivity laws hold for lexicographical equality.
Therefore they are denoted using a /variable/ equality `=v=` below.
``
- Distributivity<S,+,*,=v= > : S a,b,c; a + (b * c) =v= (a + b) * (a + c)
- Distributivity<S,*,+,=v= > : S a,b,c; a * (b + c) =v= (a * b) + (a * c)
+ Distributivity<S,+,&,=v= > : S a,b,c; a + (b & c) =v= (a + b) * (a + c)
+ Distributivity<S,&,+,=v= > : S a,b,c; a * (b + c) =v= (a * b) + (a * c)
RightDistributivity<S,+,-,=v= > : S a,b,c; (a + b) - c =v= (a - c) + (b - c)
-RightDistributivity<S,*,-,=v= > : S a,b,c; (a * b) - c =v= (a - c) * (b - c)
+RightDistributivity<S,&,-,=v= > : S a,b,c; (a * b) - c =v= (a - c) * (b - c)
``
The next table shows the relationship between
@@ -210,12 +210,12 @@
used equality relation.
``
- +,* *,+
+ +,& &,+
Distributivity joining == ==
separating == ==
splitting =e= =e=
- +,- *,-
+ +,- &,-
RightDistributivity joining == ==
separating == ==
splitting =e= ==
@@ -254,12 +254,12 @@
below is an adaption for the binary set difference `-`, which is
also called ['*relative complement*].
``
-DeMorgan<S,+,*,=v= > : S a,b,c; a - (b + c) =v= (a - b) * (a - c)
-DeMorgan<S,*,+,=v= > : S a,b,c; a - (b * c) =v= (a - b) + (a - c)
+DeMorgan<S,+,&,=v= > : S a,b,c; a - (b + c) =v= (a - b) * (a - c)
+DeMorgan<S,&,+,=v= > : S a,b,c; a - (b & c) =v= (a - b) + (a - c)
``
``
- +,* *,+
+ +,& &,+
DeMorgan joining == ==
separating == =e=
splitting == =e=
@@ -429,8 +429,8 @@
Neutrality<C,+,== > : C a; a+C() == a
Commutativity<C,+,== >: C a,b; a+b == b+a
-Associativity<C,*,== >: C a,b,c; a*(b*c) ==(a*b)*c
-Commutativity<C,*,== >: C a,b; a*b == b*a
+Associativity<C,*,== >: C a,b,c; a&(b&c) ==(a&b)&c
+Commutativity<C,*,== >: C a,b; a&b == b&a
RightNeutrality<C,-,== > : C a; a-C() == a
SelfRemovability<C,-,=v= >: C a; a - a =v= C()
@@ -442,7 +442,7 @@
if the map is not a `neutron_absorber`.
``
- + * -
+ + & -
Associativity == ==
Neutrality == ==
Commutativity == ==
@@ -453,10 +453,10 @@
[h5 Distributivity Laws]
``
- Distributivity<C,+,*,=v= > : C a,b,c; a + (b * c) =v= (a + b) * (a + c)
- Distributivity<C,*,+,=v= > : C a,b,c; a * (b + c) =v= (a * b) + (a * c)
+ Distributivity<C,+,&,=v= > : C a,b,c; a + (b & c) =v= (a + b) * (a + c)
+ Distributivity<C,&,+,=v= > : C a,b,c; a * (b + c) =v= (a * b) + (a * c)
RightDistributivity<C,+,-,=v= > : C a,b,c; (a + b) - c =v= (a - c) + (b - c)
-RightDistributivity<C,*,-,=v= > : C a,b,c; (a * b) - c =v= (a - c) * (b - c)
+RightDistributivity<C,&,-,=v= > : C a,b,c; (a * b) - c =v= (a - c) * (b - c)
``
Results for the distributivity laws are almost identical to
@@ -465,12 +465,12 @@
holds for lexicographical equality.
``
- +,* *,+
+ +,& &,+
Distributivity joining == ==
splitting neutron_absorber =e= =e=
neutron_enricher =e= ==
- +,- *,-
+ +,- &,-
RightDistributivity joining == ==
splitting =e= ==
``
@@ -478,12 +478,12 @@
[h5 DeMorgan's Law and Symmetric Difference]
``
-DeMorgan<C,+,*,=v= > : C a,b,c; a - (b + c) =v= (a - b) * (a - c)
-DeMorgan<C,*,+,=v= > : C a,b,c; a - (b * c) =v= (a - b) + (a - c)
+DeMorgan<C,+,&,=v= > : C a,b,c; a - (b + c) =v= (a - b) * (a - c)
+DeMorgan<C,&,+,=v= > : C a,b,c; a - (b & c) =v= (a - b) + (a - c)
``
``
- +,* *,+
+ +,& &,+
DeMorgan joining == ==
splitting == =e=
``
@@ -569,17 +569,17 @@
[h5 Intersection on Quantifiers]
Another difference between `Collectors` and `Quantifiers`
-is the semantics of `operator *`, that has the meaning of
+is the semantics of `operator &`, that has the meaning of
set intersection for `Collectors`.
-For the /aggregate on overlap principle/ the operation `*`
+For the /aggregate on overlap principle/ the operation `&`
has to be passed to combine associated values on overlap
of intervals or collision of keys. This can not be done
for `Quantifiers`, since numeric types do not implement
intersection.
For `CodomainT` types that are not models of `Sets`
-`operator *` is defined as aggregation on the intersection
+`operator &` is defined as aggregation on the intersection
of the domains.
``
//Pseudocode example:
@@ -594,7 +594,7 @@
For `Quantifier` that is a model of an `InfiniteVector`
and which is therefore defined for every key value of
-the `DomainT` type, this definition of `operator *`
+the `DomainT` type, this definition of `operator &`
degenerates to the same sematics that `operaotor +`
implements:
``
@@ -624,8 +624,8 @@
Neutrality<Q,+,== > : Q a; a+Q() == a
Commutativity<Q,+,== >: Q a,b; a+b == b+a
-Associativity<Q,*,== >: Q a,b,c; a*(b*c) ==(a*b)*c
-Commutativity<Q,*,== >: Q a,b; a*b == b*a
+Associativity<Q,*,== >: Q a,b,c; a&(b&c) ==(a&b)&c
+Commutativity<Q,*,== >: Q a,b; a&b == b&a
RightNeutrality<Q,-,== > : Q a; a-Q() == a
SelfRemovability<Q,-,=v= >: Q a; a - a =v= Q()
@@ -635,7 +635,7 @@
valid for `Collectors`:
``
- + * -
+ + & -
Associativity == ==
Neutrality == ==
Commutativity == ==
@@ -645,12 +645,12 @@
In addition also symmetrical difference is valid for
`Qunatifiers` and the
-modified `operator *`.
+modified `operator &`.
``
SymmetricDifference<Q,== > : Q a,b,c; (a + b) - (a * b) == (a - b) + (b - a)
``
For a `TotalQuantifier` `Qt` symmetrical difference degenerates to
-a trivial form since `operator *` and `operator +` become identical
+a trivial form since `operator &` and `operator +` become identical
``
SymmetricDifference<Qt,== > : Qt a,b,c; (a + b) - (a + b) == (a - b) + (b - a) == 0
``
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 09:57:04 EST (Mon, 12 Jan 2009)
@@ -81,7 +81,7 @@
// For a period of two months, starting from today, the function
// computes a partitioning for months and weeks using intersection
-// operator *= on split_interval_sets.
+// operator &= on split_interval_sets.
void month_and_time_grid()
{
date someday = day_clock::local_day();
Modified: sandbox/itl/libs/itl/example/user_groups/user_groups.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/user_groups/user_groups.cpp (original)
+++ sandbox/itl/libs/itl/example/user_groups/user_groups.cpp 2009-01-12 09:57:04 EST (Mon, 12 Jan 2009)
@@ -114,7 +114,7 @@
MembershipT all_users = med_users + admin_users;
- MembershipT super_users = med_users * admin_users;
+ MembershipT super_users = med_users & admin_users;
MembershipT::iterator med_ = med_users.begin();
cout << "----- Membership of medical staff -----------------------------------\n";
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 09:57:04 EST (Mon, 12 Jan 2009)
@@ -99,9 +99,9 @@
BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
//insecting emptieness
- (mt_map *= mt_u1) *= mt_u1;
+ (mt_map OP_INPLACE_INTERSECT mt_u1) OP_INPLACE_INTERSECT mt_u1;
BOOST_CHECK_EQUAL(mt_map, IntervalMapT());
- (mt_map *= mt_interval) *= mt_interval;
+ (mt_map OP_INPLACE_INTERSECT mt_interval) OP_INPLACE_INTERSECT 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) *= right;
+ (section += left) OP_INPLACE_INTERSECT 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 *= propagation. Intersectin on those types
+ // that can be implemented via OP_INPLACE_INTERSECT 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
- // *= [1 8)
+ // OP_INPLACE_INTERSECT [1 8)
//map_AB -> [1 3) [6 8)
// 1 1
- // *= [2 7)
+ // OP_INPLACE_INTERSECT [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 *= I1_8D;
+ map_AB OP_INPLACE_INTERSECT 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 *= I1_8D) *= I2_7D;
+ (map_AB OP_INPLACE_INTERSECT I1_8D) OP_INPLACE_INTERSECT 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
- // *= [1 4) [5 8)
+ // OP_INPLACE_INTERSECT [1 4) [5 8)
//map_AB -> [1 3) [6 8)
// 1 1
- // *= [2 4) [5 7)
+ // OP_INPLACE_INTERSECT [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 *= set_B;
+ map_AB OP_INPLACE_INTERSECT 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
- // *= 1
+ // OP_INPLACE_INTERSECT 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 *= v1;
+ //map_AB OP_INPLACE_INTERSECT 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 09:57:04 EST (Mon, 12 Jan 2009)
@@ -532,21 +532,21 @@
// split_interval_set
//--------------------------------------------------------------------------
//split_A [0 3) [6 9)
- // *= [1 8)
+ // OP_INPLACE_INTERSECT [1 8)
//split_AB -> [1 3) [6 8)
- // *= [2 7)
+ // OP_INPLACE_INTERSECT [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 *= I1_8D;
+ split_AB OP_INPLACE_INTERSECT I1_8D;
split_ab.add(I1_3D).add(I6_8D);
BOOST_CHECK_EQUAL( split_AB, split_ab );
split_AB = split_A;
- (split_AB *= I1_8D) *= I2_7D;
+ (split_AB OP_INPLACE_INTERSECT I1_8D) OP_INPLACE_INTERSECT 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)
- // *= 1
+ // OP_INPLACE_INTERSECT 1
//split_AB -> [1]
// += (1 7)
// -> [1](1 7)
split_A.add(I0_3D).add(I6_9D);
split_AB = split_A;
- split_AB *= v1;
+ split_AB OP_INPLACE_INTERSECT v1;
split_ab.clear();
split_ab.add(v1);
BOOST_CHECK_EQUAL( split_AB, split_ab );
split_AB = split_A;
- (split_AB *= v1) += interval<T>::open(v1,v7);
+ (split_AB OP_INPLACE_INTERSECT 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 *= [1 2)[2 4) [5 8)
+ //split_B OP_INPLACE_INTERSECT [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 *= split_B;
+ split_AB OP_INPLACE_INTERSECT 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 *= [1 2)[2 4) [5 8)
+ //sep_B OP_INPLACE_INTERSECT [1 2)[2 4) [5 8)
//split_AB -> [1 2)[2 3) [6 8)
split_AB = split_A;
sep_B = split_B;
- split_AB *= sep_B;
+ split_AB OP_INPLACE_INTERSECT 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 *= [1 4) [5 8)
+ //join_B OP_INPLACE_INTERSECT [1 4) [5 8)
//split_AB -> [1 3) [6 8)
split_AB = split_A;
join_B = split_B;
- split_AB *= join_B;
+ split_AB OP_INPLACE_INTERSECT 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 *= [1 2)[2 4) [5 8)
+ //sep_B OP_INPLACE_INTERSECT [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 *= sep_B;
+ sep_AB OP_INPLACE_INTERSECT 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 *= [1 2)[2 4) [5 8)
+ //split_B OP_INPLACE_INTERSECT [1 2)[2 4) [5 8)
//sep_AB -> [1 2)[2 3) [6 8)
sep_AB = split_A;
- sep_AB *= split_B;
+ sep_AB OP_INPLACE_INTERSECT 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 *= [1 4) [5 8)
+ //join_B OP_INPLACE_INTERSECT [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 *= join_B;
+ sep_AB OP_INPLACE_INTERSECT 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 *= [1 4) [5 8)
+ //join_B OP_INPLACE_INTERSECT [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 *= sep_B;
+ join_AB OP_INPLACE_INTERSECT 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 *= [1 2)[2 4) [5 8)
+ //split_B OP_INPLACE_INTERSECT [1 2)[2 4) [5 8)
//join_AB -> [1 3) [6 8)
join_AB = split_A;
- join_AB *= split_B;
+ join_AB OP_INPLACE_INTERSECT 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 *= [1 2)[2 4) [5 8)
+ //sep_B OP_INPLACE_INTERSECT [1 2)[2 4) [5 8)
//join_AB -> [1 3) [6 8)
join_AB = split_A;
- join_AB *= sep_B;
+ join_AB OP_INPLACE_INTERSECT 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 09:57: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 *= mt_interval) *= mt_interval;
+ (mt_set OP_INPLACE_INTERSECT mt_interval) OP_INPLACE_INTERSECT mt_interval;
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
//insecting emptieness with elements
- (mt_set *= v1) *= v0;
+ (mt_set OP_INPLACE_INTERSECT v1) OP_INPLACE_INTERSECT v0;
BOOST_CHECK_EQUAL(mt_set, IntervalSet<T>());
//insecting emptieness with intervals
- (mt_set *= I1_1I) *= I0_1I;
+ (mt_set OP_INPLACE_INTERSECT I1_1I) OP_INPLACE_INTERSECT 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) *= right;
+ (section += left) OP_INPLACE_INTERSECT right;
(complement += all) -= section;
(all2 += section) += complement;
@@ -466,21 +466,21 @@
// IntervalSet
//--------------------------------------------------------------------------
//split_A [0 3) [6 9)
- // *= [1 8)
+ // OP_INPLACE_INTERSECT [1 8)
//split_AB -> [1 3) [6 8)
- // *= [2 7)
+ // OP_INPLACE_INTERSECT [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 *= I1_8D;
+ split_AB OP_INPLACE_INTERSECT I1_8D;
split_ab.add(I1_3D).add(I6_8D);
BOOST_CHECK_EQUAL( split_AB, split_ab );
split_AB = split_A;
- (split_AB *= I1_8D) *= I2_7D;
+ (split_AB OP_INPLACE_INTERSECT I1_8D) OP_INPLACE_INTERSECT 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)
- // *= 1
+ // OP_INPLACE_INTERSECT 1
//split_AB -> [1]
// += (1 7)
// -> [1](1 7)
split_A.add(I0_3D).add(I6_9D);
split_AB = split_A;
- split_AB *= v1;
+ split_AB OP_INPLACE_INTERSECT v1;
split_ab.clear();
split_ab.add(v1);
BOOST_CHECK_EQUAL( split_AB, split_ab );
split_AB = split_A;
- (split_AB *= v1) += interval<T>::open(v1,v7);
+ (split_AB OP_INPLACE_INTERSECT 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 09:57: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 *= I0_3D;
+ section = I3_7D; section OP_INPLACE_INTERSECT 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 *= I0_5D;
+ section = I3_7D; section OP_INPLACE_INTERSECT I0_5D;
BOOST_CHECK_EQUAL( section, interval<T>::rightopen(v3, v5) );
interval<T> I0_9D = interval<T>::rightopen(v0,v9);
- section = I3_7D; section *= I0_9D;
+ section = I3_7D; section OP_INPLACE_INTERSECT I0_9D;
BOOST_CHECK_EQUAL( section, I3_7D );
interval<T> I4_5I = interval<T>::closed(v4,v5);
- section = I3_7D; section *= I4_5I;
+ section = I3_7D; section OP_INPLACE_INTERSECT I4_5I;
BOOST_CHECK_EQUAL( section, I4_5I );
interval<T> C4_6D = interval<T>::open(v4,v6);
- section = I3_7D; section *= C4_6D;
+ section = I3_7D; section OP_INPLACE_INTERSECT C4_6D;
BOOST_CHECK_EQUAL( section, C4_6D );
interval<T> C4_9I = interval<T>::leftopen(v4,v9);
- section = I3_7D; section *= C4_9I;
+ section = I3_7D; section OP_INPLACE_INTERSECT C4_9I;
BOOST_CHECK_EQUAL( section, interval<T>::open(v4,v7) );
interval<T> I7_9I = interval<T>::closed(v7,v9);
- section = I3_7D; section *= I7_9I;
+ section = I3_7D; section OP_INPLACE_INTERSECT 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 09:57:04 EST (Mon, 12 Jan 2009)
@@ -509,7 +509,7 @@
xx_uni_yy += yy;
xx_sec_yy = xx;
- xx_sec_yy *= yy;
+ xx_sec_yy OP_INPLACE_INTERSECT 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 09:57:04 EST (Mon, 12 Jan 2009)
@@ -241,6 +241,12 @@
sec_map += make_pair(interval<int>::rightopen(3,7), 3);
//sec_map *= QuantifierT(make_pair(interval<int>::rightopen(3,7), 1));
+ QuantifierT sec_map2;
+
+ if(sec_map != sec_map2)
+ cout << "geht doch\n";
+
+
cout << "sec_map: " << sec_map << endl;
}