[/
    Copyright (c) 2008-2010 Joachim Faulhaber

    Distributed under the Boost Software License, Version 1.0.
    (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt)
]


[/ //= Equivalences and Orderings ===================================================]
[section Equivalences and Orderings]

[section Synopsis][/ Equivalences and Orderings]

[table
[[['*Equivalences and Orderings*]][__ch_itvs__][__ch_itv_sets__][__ch_itv_maps__][__ch_ele_sets__][__ch_ele_maps__]]
[[['Segment Ordering]]                         [ ]       [ ]      [ ]     [ ]      [ ]   ]
[[`bool operator == (const T&, const T&)`]     [1]       [1]      [1]     [1]      [1]   ]
[[`bool operator != (const T&, const T&)`]     [1]       [1]      [1]     [1]      [1]   ]
[[`bool operator <  (const T&, const T&)`]     [1]       [1]      [1]     [1]      [1]   ]
[[`bool operator >  (const T&, const T&)`]     [1]       [1]      [1]     [1]      [1]   ]
[[`bool operator <= (const T&, const T&)`]     [1]       [1]      [1]     [1]      [1]   ]
[[`bool operator >= (const T&, const T&)`]     [1]       [1]      [1]     [1]      [1]   ]
[[['Element Ordering]]                         [ ]       [ ]      [ ]     [ ]      [ ]   ]
[[`bool is_element_equal(const T&, const P&)`] [ ]     [__S]    [__M]     [1]      [1]   ]
[[`bool is_element_less(const T&, const P&)`]  [ ]     [__S]    [__M]     [1]      [1]   ]
[[`bool is_element_greater(const T&, const P&)`][ ]    [__S]    [__M]     [1]      [1]   ]
[[['Distinct Equality]]                        [ ]       [ ]      [ ]     [ ]      [ ]   ]
[[`bool is_distinct_equal(const T&, const P&)`][ ]       [ ]    [__M]     [ ]      [1]   ]
]


[endsect][/ Synopsis Equivalences and Orderings]

[section Less on Intervals]

[table
[[ ]    [Types][]]
[[`x < y`]   [__i]   [`x` begins before `y` or, for equal beginnings `x` ends before `y`]]
]

[endsect][/ Less on Intervals]

[section Lexicographical Ordering][/ Equivalences and Orderings]

All common equality and compare operators are defined for
all objects of the *icl*. For all *icl* containers
equality and compare operators implement lexicographical
equality and lexicographical comparison, that depends on
the equality of template parameter `Compare`.
This includes the less ordering on intervals, that can be
perceived as the sequence of elements between their lower and upper
bound. This generalized lexicogrphical comparison in intervals
can also be specified this way:

[table
[]
[[`x < y`]  [`:=`]  [`x` begins before `y` or, for equal beginnings `x` ends before `y`.]]
              
[[]         []      [The other operators can be deduced in the usual way]]
[[`x > y`]  [`:=`]  [`y < x`] ] 
[[`x <= y`] [`:=`]  [`!(y < x)`] ] 
[[`x >= y`] [`:=`]  [`!(x < y)`] ] 
[[`x == y`] [`:=`]  [`!(x < y) && !(y < x)` induced equivalence] ] 
[[`x != y`] [`:=`]  [`!(x == y)`] ] 
]


Equality and compare operators are defined for all *icl*
objects but there are no overloads between different types.

Containers of different segmentation are different,
even if their elements are the same:
``
split_interval_set<time> w1, w2; //Pseudocode
w1 = {[Mon       ..       Sun)}; //split_interval_set containing a week
w2 = {[Mon .. Fri)[Sat .. Sun)}; //Same week split in work and week end parts.
w1 == w2;                        //false: Different segmentation
is_element_equal(w1,w2);         //true:  Same elements contained  
``   

[*Complexity] is ['*linear*] in the `iterative_size` of the shorter
container to compare.

[endsect][/ Lexicographical Ordering; Equivalences and Orderings]


[/ ----------------------------------------------------------------------------]

[section Sequential Element Ordering][/ Equivalences and Orderings]

The ['*Sequential Element Ordering*] abstracts from the way in which
elements of interval containers are clustered into intervals:
it's ['*segmentation*].

So these equality and compare operations can be applied within
interval container types. The admissible type combinations are summarized
in the next overload table.

``
// overload tables for
bool is_element_equal  (const T&, const P&)
bool is_element_less   (const T&, const P&)
bool is_element_greater(const T&, const P&)

element containers:     interval containers:  
T\P| s m                T\P| S1 S2 S3 M1 M3    
---+----                ---+---------------    
s  | 1                  S1 | 1  1  1    
m  |   1                S2 | 1  1  1    
                        S3 | 1  1  1
                        M1 |          1  1
                        M3 |          1  1
``

For element containers lexicographical equality and
sequential element equality are identical.

The *complexity* of sequential element comparison functions
is ['*linear*] in the `iterative_size` of the larger
container.

[endsect]

[section Distinct Equality]

['*Distinct Equality*] is an equality predicate that is available
for __icl_maps__ and __itv_maps__. It yields true, if
two maps are sequential element equal except for value
pairs whose associated values are identity elements.

[*Complexity] is linear in the `iterative_size` of the
larger container to compare.

[endsect]


['*See also . . .*]
[table
[]
[[[link boost_icl.semantics.orderings_and_equivalences ['*Semantics*]]]]
]
['*Back to section . . .*]
[table
[]
[[[link function_synopsis_table ['*Function Synopsis*]]]]
[[[link boost_icl.interface ['*Interface*]]                          ]]
]

[endsect][/ Equivalences and Orderings]