[DEV] add v1.66.0

This commit is contained in:
2018-01-12 21:47:58 +01:00
parent 87059bb1af
commit a97e9ae7d4
49032 changed files with 7668950 additions and 0 deletions

View File

@@ -0,0 +1,231 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Collectors: Maps of Sets</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Icl">
<link rel="up" href="../semantics.html" title="Semantics">
<link rel="prev" href="maps.html" title="Maps">
<link rel="next" href="quantifiers__maps_of_numbers.html" title="Quantifiers: Maps of Numbers">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="maps.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../semantics.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="quantifiers__maps_of_numbers.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_icl.semantics.collectors__maps_of_sets"></a><a class="link" href="collectors__maps_of_sets.html" title="Collectors: Maps of Sets">Collectors:
Maps of Sets</a>
</h3></div></div></div>
<p>
Icl <code class="computeroutput"><span class="identifier">Collectors</span></code>, behave like
<code class="computeroutput"><span class="identifier">Sets</span></code>. This can be understood
easily, if we consider, that every map of sets can be transformed to an equivalent
set of pairs. For instance in the pseudocode below map <code class="computeroutput"><span class="identifier">m</span></code>
</p>
<pre class="programlisting"><span class="identifier">icl</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span><span class="identifier">set</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">m</span> <span class="special">=</span> <span class="special">{(</span><span class="number">1</span><span class="special">-&gt;{</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">}),</span> <span class="special">(</span><span class="number">2</span><span class="special">-&gt;{</span><span class="number">1</span><span class="special">})};</span>
</pre>
<p>
is equivalent to set <code class="computeroutput"><span class="identifier">s</span></code>
</p>
<pre class="programlisting"><span class="identifier">icl</span><span class="special">::</span><span class="identifier">set</span><span class="special">&lt;</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">s</span> <span class="special">=</span> <span class="special">{(</span><span class="number">1</span><span class="special">,</span><span class="number">1</span><span class="special">),(</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">),</span> <span class="comment">//representing 1-&gt;{1,2}</span>
<span class="special">(</span><span class="number">2</span><span class="special">,</span><span class="number">1</span><span class="special">)</span> <span class="special">};</span> <span class="comment">//representing 2-&gt;{1}</span>
</pre>
<p>
</p>
<p>
Also the results of add, subtract and other operations on <code class="computeroutput"><span class="identifier">map</span>
<span class="identifier">m</span></code> and <code class="computeroutput"><span class="identifier">set</span>
<span class="identifier">s</span></code> preserves the equivalence of
the containers <span class="emphasis"><em><span class="bold"><strong>almost</strong></span></em></span>
perfectly:
</p>
<pre class="programlisting"><span class="identifier">m</span> <span class="special">+=</span> <span class="special">(</span><span class="number">1</span><span class="special">,</span><span class="number">3</span><span class="special">);</span>
<span class="identifier">m</span> <span class="special">==</span> <span class="special">{(</span><span class="number">1</span><span class="special">-&gt;{</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">}),</span> <span class="special">(</span><span class="number">2</span><span class="special">-&gt;{</span><span class="number">1</span><span class="special">})};</span> <span class="comment">//aggregated on collision of key value 1</span>
<span class="identifier">s</span> <span class="special">+=</span> <span class="special">(</span><span class="number">1</span><span class="special">,</span><span class="number">3</span><span class="special">);</span>
<span class="identifier">s</span> <span class="special">==</span> <span class="special">{(</span><span class="number">1</span><span class="special">,</span><span class="number">1</span><span class="special">),(</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">),(</span><span class="number">1</span><span class="special">,</span><span class="number">3</span><span class="special">),</span> <span class="comment">//representing 1-&gt;{1,2,3}</span>
<span class="special">(</span><span class="number">2</span><span class="special">,</span><span class="number">1</span><span class="special">)</span> <span class="special">};</span> <span class="comment">//representing 2-&gt;{1}</span>
</pre>
<p>
</p>
<p>
The equivalence of <code class="computeroutput"><span class="identifier">m</span></code> and
<code class="computeroutput"><span class="identifier">s</span></code> is only violated if an
empty set occurres in <code class="computeroutput"><span class="identifier">m</span></code> by
subtraction of a value pair:
</p>
<pre class="programlisting"><span class="identifier">m</span> <span class="special">-=</span> <span class="special">(</span><span class="number">2</span><span class="special">,</span><span class="number">1</span><span class="special">);</span>
<span class="identifier">m</span> <span class="special">==</span> <span class="special">{(</span><span class="number">1</span><span class="special">-&gt;{</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">}),</span> <span class="special">(</span><span class="number">2</span><span class="special">-&gt;{})};</span> <span class="comment">//aggregated on collision of key value 2</span>
<span class="identifier">s</span> <span class="special">-=</span> <span class="special">(</span><span class="number">2</span><span class="special">,</span><span class="number">1</span><span class="special">);</span>
<span class="identifier">s</span> <span class="special">==</span> <span class="special">{(</span><span class="number">1</span><span class="special">,</span><span class="number">1</span><span class="special">),(</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">),(</span><span class="number">1</span><span class="special">,</span><span class="number">3</span><span class="special">)</span> <span class="comment">//representing 1-&gt;{1,2,3}</span>
<span class="special">};</span> <span class="comment">//2-&gt;{} is not represented in s</span>
</pre>
<p>
</p>
<p>
This problem can be dealt with in two ways.
</p>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
Deleting value pairs form the Collector, if it's associated value becomes
a neutral value or <code class="computeroutput"><span class="identifier">identity_element</span></code>.
</li>
<li class="listitem">
Using a different equality, called distinct equality in the laws to validate.
Distinct equality only accounts for value pairs that that carry values
unequal to the <code class="computeroutput"><span class="identifier">identity_element</span></code>.
</li>
</ol></div>
<p>
Solution (1) led to the introduction of map traits, particularly trait <span class="emphasis"><em><span class="bold"><strong>partial_absorber</strong></span></em></span>, which is the default
setting in all icl's map templates.
</p>
<p>
Solution (2), is applied to check the semantics of icl::Maps for the partial_enricher
trait that does not delete value pairs that carry identity elements. Distinct
equality is implemented by a non member function called <code class="computeroutput"><span class="identifier">is_distinct_equal</span></code>.
Throughout this chapter distinct equality in pseudocode and law denotations
is denoted as <code class="computeroutput"><span class="special">=</span><span class="identifier">d</span><span class="special">=</span></code> operator.
</p>
<p>
The validity of the sets of laws that make up <code class="computeroutput"><span class="identifier">Set</span></code>
semantics should now be quite evident. So the following text shows the laws
that are validated for all <code class="computeroutput"><span class="identifier">Collector</span></code>
types <code class="computeroutput"><span class="identifier">C</span></code>. Which are <code class="computeroutput"><a class="link" href="../../boost/icl/map.html" title="Class template map">icl::map</a></code><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">D</span><span class="special">,</span><span class="identifier">S</span><span class="special">,</span><span class="identifier">T</span><span class="special">&gt;</span></code>,
<code class="computeroutput"><a class="link" href="../../boost/icl/interval_map.html" title="Class template interval_map">interval_map</a></code><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">D</span><span class="special">,</span><span class="identifier">S</span><span class="special">,</span><span class="identifier">T</span><span class="special">&gt;</span></code> and <code class="computeroutput"><a class="link" href="../../boost/icl/split_interval_map.html" title="Class template split_interval_map">split_interval_map</a></code><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">D</span><span class="special">,</span><span class="identifier">S</span><span class="special">,</span><span class="identifier">T</span><span class="special">&gt;</span></code> where <code class="computeroutput"><span class="identifier">CodomainT</span></code>
type <code class="computeroutput"><span class="identifier">S</span></code> is a model of <code class="computeroutput"><span class="identifier">Set</span></code> and <code class="computeroutput"><span class="identifier">Trait</span></code>
type <code class="computeroutput"><span class="identifier">T</span></code> is either <code class="computeroutput"><a class="link" href="../../boost/icl/partial_absorber.html" title="Struct partial_absorber">partial_absorber</a></code> or <code class="computeroutput"><a class="link" href="../../boost/icl/partial_enricher.html" title="Struct partial_enricher">partial_enricher</a></code>.
</p>
<h6>
<a name="boost_icl.semantics.collectors__maps_of_sets.h0"></a>
<span class="phrase"><a name="boost_icl.semantics.collectors__maps_of_sets.laws_on_set_union__set_intersection_and_set_difference"></a></span><a class="link" href="collectors__maps_of_sets.html#boost_icl.semantics.collectors__maps_of_sets.laws_on_set_union__set_intersection_and_set_difference">Laws
on set union, set intersection and set difference</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="identifier">Associativity</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,+,==</span> <span class="special">&gt;:</span> <span class="identifier">C</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="identifier">a</span><span class="special">+(</span><span class="identifier">b</span><span class="special">+</span><span class="identifier">c</span><span class="special">)</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">a</span><span class="special">+</span><span class="identifier">b</span><span class="special">)+</span><span class="identifier">c</span>
<span class="identifier">Neutrality</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,+,==</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">C</span> <span class="identifier">a</span><span class="special">;</span> <span class="identifier">a</span><span class="special">+</span><span class="identifier">C</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">a</span>
<span class="identifier">Commutativity</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,+,==</span> <span class="special">&gt;:</span> <span class="identifier">C</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">;</span> <span class="identifier">a</span><span class="special">+</span><span class="identifier">b</span> <span class="special">==</span> <span class="identifier">b</span><span class="special">+</span><span class="identifier">a</span>
<span class="identifier">Associativity</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,&amp;,==</span> <span class="special">&gt;:</span> <span class="identifier">C</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="identifier">a</span><span class="special">&amp;(</span><span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">c</span><span class="special">)</span> <span class="special">==(</span><span class="identifier">a</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">)&amp;</span><span class="identifier">c</span>
<span class="identifier">Commutativity</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,&amp;,==</span> <span class="special">&gt;:</span> <span class="identifier">C</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">;</span> <span class="identifier">a</span><span class="special">&amp;</span><span class="identifier">b</span> <span class="special">==</span> <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">a</span>
<span class="identifier">RightNeutrality</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,-,==</span> <span class="special">&gt;:</span> <span class="identifier">C</span> <span class="identifier">a</span><span class="special">;</span> <span class="identifier">a</span><span class="special">-</span><span class="identifier">C</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">a</span>
<span class="identifier">Inversion</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,-,=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">C</span> <span class="identifier">a</span><span class="special">;</span> <span class="identifier">a</span> <span class="special">-</span> <span class="identifier">a</span> <span class="special">=</span><span class="identifier">v</span><span class="special">=</span> <span class="identifier">C</span><span class="special">()</span>
</pre>
<p>
</p>
<p>
All the fundamental laws could be validated for all icl Maps in their instantiation
as Maps of Sets or Collectors. As expected, Inversion only holds for distinct
equality, if the map is not a <code class="computeroutput"><span class="identifier">partial_absorber</span></code>.
</p>
<p>
</p>
<pre class="programlisting"> <span class="special">+</span> <span class="special">&amp;</span> <span class="special">-</span>
<span class="identifier">Associativity</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">Neutrality</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">Commutativity</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">Inversion</span> <span class="identifier">partial_absorber</span> <span class="special">==</span>
<span class="identifier">partial_enricher</span> <span class="special">=</span><span class="identifier">d</span><span class="special">=</span>
</pre>
<p>
</p>
<h6>
<a name="boost_icl.semantics.collectors__maps_of_sets.h1"></a>
<span class="phrase"><a name="boost_icl.semantics.collectors__maps_of_sets.distributivity_laws"></a></span><a class="link" href="collectors__maps_of_sets.html#boost_icl.semantics.collectors__maps_of_sets.distributivity_laws">Distributivity
Laws</a>
</h6>
<p>
</p>
<pre class="programlisting"> <span class="identifier">Distributivity</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,+,&amp;,=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">C</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="identifier">a</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">&amp;</span> <span class="identifier">c</span><span class="special">)</span> <span class="special">=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">+</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">&amp;</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">+</span> <span class="identifier">c</span><span class="special">)</span>
<span class="identifier">Distributivity</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,&amp;,+,=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">C</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="identifier">a</span> <span class="special">&amp;</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">+</span> <span class="identifier">c</span><span class="special">)</span> <span class="special">=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">&amp;</span> <span class="identifier">c</span><span class="special">)</span>
<span class="identifier">RightDistributivity</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,+,-,=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">C</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">+</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">-</span> <span class="identifier">c</span> <span class="special">=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">c</span><span class="special">)</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">-</span> <span class="identifier">c</span><span class="special">)</span>
<span class="identifier">RightDistributivity</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,&amp;,-,=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">C</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">-</span> <span class="identifier">c</span> <span class="special">=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">c</span><span class="special">)</span> <span class="special">&amp;</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">-</span> <span class="identifier">c</span><span class="special">)</span>
</pre>
<p>
</p>
<p>
Results for the distributivity laws are almost identical to the validation
of sets except that for a <code class="computeroutput"><span class="identifier">partial_enricher</span>
<span class="identifier">map</span></code> the law <code class="computeroutput"><span class="special">(</span><span class="identifier">a</span> <span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">-</span>
<span class="identifier">c</span> <span class="special">==</span>
<span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">c</span><span class="special">)</span>
<span class="special">&amp;</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">-</span> <span class="identifier">c</span><span class="special">)</span></code> holds for lexicographical equality.
</p>
<p>
</p>
<pre class="programlisting"> <span class="special">+,&amp;</span> <span class="special">&amp;,+</span>
<span class="identifier">Distributivity</span> <span class="identifier">joining</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">splitting</span> <span class="identifier">partial_absorber</span> <span class="special">=</span><span class="identifier">e</span><span class="special">=</span> <span class="special">=</span><span class="identifier">e</span><span class="special">=</span>
<span class="identifier">partial_enricher</span> <span class="special">=</span><span class="identifier">e</span><span class="special">=</span> <span class="special">==</span>
<span class="special">+,-</span> <span class="special">&amp;,-</span>
<span class="identifier">RightDistributivity</span> <span class="identifier">joining</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">splitting</span> <span class="special">=</span><span class="identifier">e</span><span class="special">=</span> <span class="special">==</span>
</pre>
<p>
</p>
<h6>
<a name="boost_icl.semantics.collectors__maps_of_sets.h2"></a>
<span class="phrase"><a name="boost_icl.semantics.collectors__maps_of_sets.demorgan_s_law_and_symmetric_difference"></a></span><a class="link" href="collectors__maps_of_sets.html#boost_icl.semantics.collectors__maps_of_sets.demorgan_s_law_and_symmetric_difference">DeMorgan's
Law and Symmetric Difference</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="identifier">DeMorgan</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,+,&amp;,=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">C</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="identifier">a</span> <span class="special">-</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">+</span> <span class="identifier">c</span><span class="special">)</span> <span class="special">=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">&amp;</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">c</span><span class="special">)</span>
<span class="identifier">DeMorgan</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,&amp;,+,=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">C</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="identifier">a</span> <span class="special">-</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">&amp;</span> <span class="identifier">c</span><span class="special">)</span> <span class="special">=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">c</span><span class="special">)</span>
</pre>
<p>
</p>
<p>
</p>
<pre class="programlisting"> <span class="special">+,&amp;</span> <span class="special">&amp;,+</span>
<span class="identifier">DeMorgan</span> <span class="identifier">joining</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">splitting</span> <span class="special">==</span> <span class="special">=</span><span class="identifier">e</span><span class="special">=</span>
</pre>
<p>
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">SymmetricDifference</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,==</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">C</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">+</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">-</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">*</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">-</span> <span class="identifier">a</span><span class="special">)</span>
</pre>
<p>
</p>
<p>
Reviewing the validity tables above shows, that the sets of valid laws for
<code class="computeroutput"><span class="identifier">icl</span> <span class="identifier">Sets</span></code>
and <code class="computeroutput"><span class="identifier">icl</span> <span class="identifier">Maps</span>
<span class="identifier">of</span> <span class="identifier">Sets</span></code>
that are <span class="emphasis"><em>identity absorbing</em></span> are exactly the same. As
expected, only for Maps of Sets that represent empty sets as associated values,
called <span class="emphasis"><em>identity enrichers</em></span>, there are marginal semantic
differences.
</p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2007-2010 Joachim
Faulhaber<br>Copyright &#169; 1999-2006 Cortex Software
GmbH<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="maps.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../semantics.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="quantifiers__maps_of_numbers.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,161 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Concept Induction</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Icl">
<link rel="up" href="../semantics.html" title="Semantics">
<link rel="prev" href="quantifiers__maps_of_numbers.html" title="Quantifiers: Maps of Numbers">
<link rel="next" href="../interface.html" title="Interface">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="quantifiers__maps_of_numbers.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../semantics.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../interface.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_icl.semantics.concept_induction"></a><a class="link" href="concept_induction.html" title="Concept Induction">Concept Induction</a>
</h3></div></div></div>
<p>
Obviously we can observe the induction of semantics from the <code class="computeroutput"><span class="identifier">CodomainT</span></code> parameter into the instantiations
of icl maps.
</p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
</th>
<th>
<p>
is model of
</p>
</th>
<th>
<p>
if
</p>
</th>
<th>
<p>
example
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">Map</span><span class="special">&lt;</span><span class="identifier">D</span><span class="special">,</span><span class="identifier">Monoid</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">Modoid</span></code>
</p>
</td>
<td>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">interval_map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span><span class="identifier">string</span><span class="special">&gt;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">Map</span><span class="special">&lt;</span><span class="identifier">D</span><span class="special">,</span><span class="identifier">Set</span><span class="special">,</span><span class="identifier">Trait</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">Set</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">Trait</span><span class="special">::</span><span class="identifier">absorbs_identities</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">interval_map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">set</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span>
<span class="special">&gt;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">Map</span><span class="special">&lt;</span><span class="identifier">D</span><span class="special">,</span><span class="identifier">CommutativeMonoid</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">CommutativeMonoid</span></code>
</p>
</td>
<td>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">interval_map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span><span class="keyword">unsigned</span> <span class="keyword">int</span><span class="special">&gt;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">Map</span><span class="special">&lt;</span><span class="identifier">D</span><span class="special">,</span><span class="identifier">CommutativeGroup</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">CommutativeGroup</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">Trait</span><span class="special">::</span><span class="identifier">is_total</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">interval_map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span><span class="keyword">int</span><span class="special">,</span><span class="identifier">total_absorber</span><span class="special">&gt;</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2007-2010 Joachim
Faulhaber<br>Copyright &#169; 1999-2006 Cortex Software
GmbH<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="quantifiers__maps_of_numbers.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../semantics.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../interface.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,187 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Maps</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Icl">
<link rel="up" href="../semantics.html" title="Semantics">
<link rel="prev" href="sets.html" title="Sets">
<link rel="next" href="collectors__maps_of_sets.html" title="Collectors: Maps of Sets">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="sets.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../semantics.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="collectors__maps_of_sets.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_icl.semantics.maps"></a><a class="link" href="maps.html" title="Maps">Maps</a>
</h3></div></div></div>
<p>
By definition a map is set of pairs. So we would expect maps to obey the
same laws that are valid for sets. Yet the semantics of the <span class="bold"><strong>icl's</strong></span>
maps may be a different one, because of it's aggregating facilities, where
the aggregating combiner operations are passed to combine the map's associated
values. It turns out, that the aggregation on overlap principle induces semantic
properties to icl maps in such a way, that the set of equations that are
valid will depend on the semantics of the type <code class="computeroutput"><span class="identifier">CodomainT</span></code>
of the map's associated values.
</p>
<p>
This is less magical as it might seem at first glance. If, for instance,
we instantiate an <code class="computeroutput"><a class="link" href="../../boost/icl/interval_map.html" title="Class template interval_map">interval_map</a></code>
to collect and concatenate <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">strings</span></code>
associated to intervals,
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">interval_map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;</span> <span class="identifier">cat_map</span><span class="special">;</span>
<span class="identifier">cat_map</span> <span class="special">+=</span> <span class="identifier">make_pair</span><span class="special">(</span><span class="identifier">interval</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">rightopen</span><span class="special">(</span><span class="number">1</span><span class="special">,</span><span class="number">5</span><span class="special">),</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">(</span><span class="string">"Hello"</span><span class="special">));</span>
<span class="identifier">cat_map</span> <span class="special">+=</span> <span class="identifier">make_pair</span><span class="special">(</span><span class="identifier">interval</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">rightopen</span><span class="special">(</span><span class="number">3</span><span class="special">,</span><span class="number">7</span><span class="special">),</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">(</span><span class="string">" World"</span><span class="special">));</span>
<span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cat_map: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">cat_map</span> <span class="special">&lt;&lt;</span> <span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
we won't be able to apply <code class="computeroutput"><span class="keyword">operator</span>
<span class="special">-=</span></code>
</p>
<pre class="programlisting"><span class="comment">// This will not compile because string::operator -= is missing.</span>
<span class="identifier">cat_map</span> <span class="special">-=</span> <span class="identifier">make_pair</span><span class="special">(</span><span class="identifier">interval</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">rightopen</span><span class="special">(</span><span class="number">3</span><span class="special">,</span><span class="number">7</span><span class="special">),</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">(</span><span class="string">" World"</span><span class="special">));</span>
</pre>
<p>
because, as std::sting does not implement <code class="computeroutput"><span class="special">-=</span></code>
itself, this won't compile. So all <span class="bold"><strong>laws</strong></span>,
that rely on <code class="computeroutput"><span class="keyword">operator</span> <span class="special">-=</span></code>
or <code class="computeroutput"><span class="special">-</span></code> not only will not be valid
they can not even be stated. This reduces the set of laws that can be valid
for a richer <code class="computeroutput"><span class="identifier">CodomainT</span></code> type
to a smaller set of laws and thus to a less restricted semantics.
</p>
<p>
Currently we have investigated and validated two major instantiations of
icl::Maps,
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<span class="emphasis"><em><span class="bold"><strong>Maps of Sets</strong></span></em></span> that
will be called <span class="emphasis"><em><span class="bold"><strong>Collectors</strong></span></em></span>
and
</li>
<li class="listitem">
<span class="emphasis"><em><span class="bold"><strong>Maps of Numbers</strong></span></em></span>
which will be called <span class="emphasis"><em><span class="bold"><strong>Quantifiers</strong></span></em></span>
</li>
</ul></div>
<p>
both of which seem to have many interesting use cases for practical applications.
The semantics associated with the term <span class="emphasis"><em>Numbers</em></span> is a
<a href="http://en.wikipedia.org/wiki/Monoid" target="_top">commutative monoid</a>
for unsigned numbers and a <a href="http://en.wikipedia.org/wiki/Abelian_group" target="_top">commutative
or abelian group</a> for signed numbers. From a practical point of view
we can think of numbers as counting or quantifying the key values of the
map.
</p>
<p>
Icl <span class="emphasis"><em><span class="bold"><strong>Maps of Sets</strong></span></em></span> or
<span class="emphasis"><em><span class="bold"><strong>Collectors</strong></span></em></span> are models
of concept <code class="computeroutput"><span class="identifier">Set</span></code>. This implies
that all laws that have been stated as a semantics for <code class="computeroutput"><span class="identifier">icl</span><span class="special">::</span><span class="identifier">Sets</span></code>
in the previous chapter also hold for <code class="computeroutput"><span class="identifier">Maps</span>
<span class="identifier">of</span> <span class="identifier">Sets</span></code>.
Icl <span class="emphasis"><em><span class="bold"><strong>Maps of Numbers</strong></span></em></span>
or <span class="emphasis"><em><span class="bold"><strong>Quantifiers</strong></span></em></span> on the
contrary are not models of concept <code class="computeroutput"><span class="identifier">Set</span></code>.
But there is a substantial intersection of laws that apply both for <code class="computeroutput"><span class="identifier">Collectors</span></code> and <code class="computeroutput"><span class="identifier">Quantifiers</span></code>.
</p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Kind of Map
</p>
</th>
<th>
<p>
Alias
</p>
</th>
<th>
<p>
Behavior
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Maps of Sets
</p>
</td>
<td>
<p>
Collector
</p>
</td>
<td>
<p>
Collects items <span class="bold"><strong>for</strong></span> key values
</p>
</td>
</tr>
<tr>
<td>
<p>
Maps of Numbers
</p>
</td>
<td>
<p>
Quantifier
</p>
</td>
<td>
<p>
Counts or quantifies <span class="bold"><strong>the</strong></span> key values
</p>
</td>
</tr>
</tbody>
</table></div>
<p>
In the next two sections the law based semantics of <span class="emphasis"><em><span class="bold"><strong>Collectors</strong></span></em></span>
and <span class="emphasis"><em><span class="bold"><strong>Quantifiers</strong></span></em></span> will
be described in more detail.
</p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2007-2010 Joachim
Faulhaber<br>Copyright &#169; 1999-2006 Cortex Software
GmbH<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="sets.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../semantics.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="collectors__maps_of_sets.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,342 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Quantifiers: Maps of Numbers</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Icl">
<link rel="up" href="../semantics.html" title="Semantics">
<link rel="prev" href="collectors__maps_of_sets.html" title="Collectors: Maps of Sets">
<link rel="next" href="concept_induction.html" title="Concept Induction">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="collectors__maps_of_sets.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../semantics.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="concept_induction.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_icl.semantics.quantifiers__maps_of_numbers"></a><a class="link" href="quantifiers__maps_of_numbers.html" title="Quantifiers: Maps of Numbers">Quantifiers:
Maps of Numbers</a>
</h3></div></div></div>
<h6>
<a name="boost_icl.semantics.quantifiers__maps_of_numbers.h0"></a>
<span class="phrase"><a name="boost_icl.semantics.quantifiers__maps_of_numbers.subtraction_on_quantifiers"></a></span><a class="link" href="quantifiers__maps_of_numbers.html#boost_icl.semantics.quantifiers__maps_of_numbers.subtraction_on_quantifiers">Subtraction
on Quantifiers</a>
</h6>
<p>
With <code class="computeroutput"><span class="identifier">Sets</span></code> and <code class="computeroutput"><span class="identifier">Collectors</span></code> the semantics of <code class="computeroutput"><span class="keyword">operator</span> <span class="special">-</span></code>
is that of <span class="emphasis"><em>set difference</em></span> which means, that you can
only subtract what has been put into the container before. With <code class="computeroutput"><span class="identifier">Quantifiers</span></code> that <span class="emphasis"><em><span class="bold"><strong>count</strong></span></em></span>
or <span class="emphasis"><em><span class="bold"><strong>quantify</strong></span></em></span> their key
values in some way, the semantics of <code class="computeroutput"><span class="keyword">operator</span>
<span class="special">-</span></code> may be different.
</p>
<p>
The question is how subtraction should be defined here?
</p>
<pre class="programlisting"><span class="comment">//Pseudocode:</span>
<span class="identifier">icl</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span><span class="identifier">some_number</span><span class="special">&gt;</span> <span class="identifier">q</span> <span class="special">=</span> <span class="special">{(</span><span class="number">1</span><span class="special">-&gt;</span><span class="number">1</span><span class="special">)};</span>
<span class="identifier">q</span> <span class="special">-=</span> <span class="special">(</span><span class="number">2</span><span class="special">-&gt;</span><span class="number">1</span><span class="special">);</span>
</pre>
<p>
If type <code class="computeroutput"><span class="identifier">some_number</span></code> is <code class="computeroutput"><span class="keyword">unsigned</span></code> a <span class="emphasis"><em>set difference</em></span>
kind of subtraction make sense
</p>
<pre class="programlisting"><span class="identifier">icl</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span><span class="identifier">some_number</span><span class="special">&gt;</span> <span class="identifier">q</span> <span class="special">=</span> <span class="special">{(</span><span class="number">1</span><span class="special">-&gt;</span><span class="number">1</span><span class="special">)};</span>
<span class="identifier">q</span> <span class="special">-=</span> <span class="special">(</span><span class="number">2</span><span class="special">-&gt;</span><span class="number">1</span><span class="special">);</span> <span class="comment">// key 2 is not in the map so </span>
<span class="identifier">q</span> <span class="special">==</span> <span class="special">{(</span><span class="number">1</span><span class="special">-&gt;</span><span class="number">1</span><span class="special">)};</span> <span class="comment">// q is unchanged by 'aggregate on collision'</span>
</pre>
<p>
If <code class="computeroutput"><span class="identifier">some_number</span></code> is a <code class="computeroutput"><span class="keyword">signed</span></code> numerical type the result can also
be this
</p>
<pre class="programlisting"><span class="identifier">icl</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span><span class="identifier">some_number</span><span class="special">&gt;</span> <span class="identifier">q</span> <span class="special">=</span> <span class="special">{(</span><span class="number">1</span><span class="special">-&gt;</span><span class="number">1</span><span class="special">)};</span>
<span class="identifier">q</span> <span class="special">-=</span> <span class="special">(</span><span class="number">2</span><span class="special">-&gt;</span><span class="number">1</span><span class="special">);</span> <span class="comment">// subtracting works like </span>
<span class="identifier">q</span> <span class="special">==</span> <span class="special">{(</span><span class="number">1</span><span class="special">-&gt;</span><span class="number">1</span><span class="special">),</span> <span class="special">(</span><span class="number">2</span><span class="special">-&gt;</span> <span class="special">-</span><span class="number">1</span><span class="special">)};</span> <span class="comment">// adding the inverse element</span>
</pre>
<p>
As commented in the example, subtraction of a key value pair <code class="computeroutput"><span class="special">(</span><span class="identifier">k</span><span class="special">,</span><span class="identifier">v</span><span class="special">)</span></code> can
obviously be defined as adding the <span class="emphasis"><em><span class="bold"><strong>inverse
element</strong></span></em></span> for that key <code class="computeroutput"><span class="special">(</span><span class="identifier">k</span><span class="special">,-</span><span class="identifier">v</span><span class="special">)</span></code>, if the key is not yet stored in the map.
</p>
<h5>
<a name="boost_icl.semantics.quantifiers__maps_of_numbers.h1"></a>
<span class="phrase"><a name="boost_icl.semantics.quantifiers__maps_of_numbers.partial_and_total_quantifiers_and_infinite_vectors"></a></span><a class="link" href="quantifiers__maps_of_numbers.html#boost_icl.semantics.quantifiers__maps_of_numbers.partial_and_total_quantifiers_and_infinite_vectors">Partial
and Total Quantifiers and Infinite Vectors</a>
</h5>
<p>
Another concept, that we can think of, is that in a <code class="computeroutput"><span class="identifier">Quantifier</span></code>
every <code class="computeroutput"><span class="identifier">key_value</span></code> is initially
quantified <code class="computeroutput"><span class="number">0</span></code>-times, where <code class="computeroutput"><span class="number">0</span></code> stands for the neutral element of the numeric
<code class="computeroutput"><span class="identifier">CodomainT</span></code> type. Such a <code class="computeroutput"><span class="identifier">Quantifier</span></code> would be totally defined on
all values of it's <code class="computeroutput"><span class="identifier">DomainT</span></code>
type and can be conceived as an <code class="computeroutput"><span class="identifier">InfiniteVector</span></code>.
</p>
<p>
To create an infinite vector that is totally defined on it's domain we can
set the map's <code class="computeroutput"><span class="identifier">Trait</span></code> parameter
to the value <code class="computeroutput"><a class="link" href="../../boost/icl/total_absorber.html" title="Struct total_absorber">total_absorber</a></code>.
The <code class="computeroutput"><a class="link" href="../../boost/icl/total_absorber.html" title="Struct total_absorber">total_absorber</a></code>
trait fits specifically well with a <code class="computeroutput"><span class="identifier">Quantifier</span></code>
if it's <code class="computeroutput"><span class="identifier">CodomainT</span></code> has an
inverse element, like all signed numerical type have. As we can see later
in this section this kind of a total <code class="computeroutput"><span class="identifier">Quantifier</span></code>
has the basic properties that elements of a <a href="http://en.wikipedia.org/wiki/Vector_space" target="_top">vector
space</a> do provide.
</p>
<h6>
<a name="boost_icl.semantics.quantifiers__maps_of_numbers.h2"></a>
<span class="phrase"><a name="boost_icl.semantics.quantifiers__maps_of_numbers.intersection_on_quantifiers"></a></span><a class="link" href="quantifiers__maps_of_numbers.html#boost_icl.semantics.quantifiers__maps_of_numbers.intersection_on_quantifiers">Intersection
on Quantifiers</a>
</h6>
<p>
Another difference between <code class="computeroutput"><span class="identifier">Collectors</span></code>
and <code class="computeroutput"><span class="identifier">Quantifiers</span></code> is the semantics
of <code class="computeroutput"><span class="keyword">operator</span> <span class="special">&amp;</span></code>,
that has the meaning of set intersection for <code class="computeroutput"><span class="identifier">Collectors</span></code>.
</p>
<p>
For the <span class="emphasis"><em>aggregate on overlap principle</em></span> the operation
<code class="computeroutput"><span class="special">&amp;</span></code> has to be passed to combine
associated values on overlap of intervals or collision of keys. This can
not be done for <code class="computeroutput"><span class="identifier">Quantifiers</span></code>,
since numeric types do not implement intersection.
</p>
<p>
For <code class="computeroutput"><span class="identifier">CodomainT</span></code> types that
are not models of <code class="computeroutput"><span class="identifier">Sets</span></code> <code class="computeroutput"><span class="keyword">operator</span> <span class="special">&amp;</span> </code>
is defined as <span class="emphasis"><em>aggregation on the intersection of the domains</em></span>.
Instead of the <code class="computeroutput"><span class="identifier">codomain_intersect</span></code>
functor <code class="computeroutput"><span class="identifier">codomain_combine</span></code>
is used as aggregation operation:
</p>
<pre class="programlisting"><span class="comment">//Pseudocode example for partial Quantifiers p, q:</span>
<span class="identifier">interval_map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">p</span><span class="special">,</span> <span class="identifier">q</span><span class="special">;</span>
<span class="identifier">p</span> <span class="special">=</span> <span class="special">{[</span><span class="number">1</span> <span class="number">3</span><span class="special">)-&gt;</span><span class="number">1</span> <span class="special">};</span>
<span class="identifier">q</span> <span class="special">=</span> <span class="special">{</span> <span class="special">([</span><span class="number">2</span> <span class="number">4</span><span class="special">)-&gt;</span><span class="number">1</span><span class="special">};</span>
<span class="identifier">p</span> <span class="special">&amp;</span> <span class="identifier">q</span> <span class="special">=={</span> <span class="special">[</span><span class="number">2</span> <span class="number">3</span><span class="special">)-&gt;</span><span class="number">2</span> <span class="special">};</span>
</pre>
<p>
So an addition or aggregation of associated values is done like for <code class="computeroutput"><span class="keyword">operator</span> <span class="special">+</span></code>
but value pairs that have no common keys are not added to the result.
</p>
<p>
For a <code class="computeroutput"><span class="identifier">Quantifier</span></code> that is
a model of an <code class="computeroutput"><span class="identifier">InfiniteVector</span></code>
and which is therefore defined for every key value of the <code class="computeroutput"><span class="identifier">DomainT</span></code>
type, this definition of <code class="computeroutput"><span class="keyword">operator</span>
<span class="special">&amp;</span></code> degenerates to the same sematics
that <code class="computeroutput"><span class="identifier">operaotor</span> <span class="special">+</span></code>
implements:
</p>
<pre class="programlisting"><span class="comment">//Pseudocode example for total Quantifiers p, q:</span>
<span class="identifier">interval_map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">p</span><span class="special">,</span> <span class="identifier">q</span><span class="special">;</span>
<span class="identifier">p</span> <span class="special">=</span> <span class="special">{[</span><span class="identifier">min</span> <span class="number">1</span><span class="special">)[</span><span class="number">1</span> <span class="number">3</span><span class="special">)[</span><span class="number">3</span> <span class="identifier">max</span><span class="special">]};</span>
<span class="special">-&gt;</span><span class="number">0</span> <span class="special">-&gt;</span><span class="number">1</span> <span class="special">-&gt;</span><span class="number">0</span>
<span class="identifier">q</span> <span class="special">=</span> <span class="special">{[</span><span class="identifier">min</span> <span class="number">2</span><span class="special">)[</span><span class="number">2</span> <span class="number">4</span><span class="special">)[</span><span class="number">4</span> <span class="identifier">max</span><span class="special">]};</span>
<span class="special">-&gt;</span><span class="number">0</span> <span class="special">-&gt;</span><span class="number">1</span> <span class="special">-&gt;</span><span class="number">0</span>
<span class="identifier">p</span><span class="special">&amp;</span><span class="identifier">q</span> <span class="special">=={[</span><span class="identifier">min</span> <span class="number">1</span><span class="special">)[</span><span class="number">1</span> <span class="number">2</span><span class="special">)[</span><span class="number">2</span> <span class="number">3</span><span class="special">)[</span><span class="number">3</span> <span class="number">4</span><span class="special">)[</span><span class="number">4</span> <span class="identifier">max</span><span class="special">]};</span>
<span class="special">-&gt;</span><span class="number">0</span> <span class="special">-&gt;</span><span class="number">1</span> <span class="special">-&gt;</span><span class="number">2</span> <span class="special">-&gt;</span><span class="number">1</span> <span class="special">-&gt;</span><span class="number">0</span>
</pre>
<p>
</p>
<h5>
<a name="boost_icl.semantics.quantifiers__maps_of_numbers.h3"></a>
<span class="phrase"><a name="boost_icl.semantics.quantifiers__maps_of_numbers.laws_for_quantifiers_of_unsigned_numbers"></a></span><a class="link" href="quantifiers__maps_of_numbers.html#boost_icl.semantics.quantifiers__maps_of_numbers.laws_for_quantifiers_of_unsigned_numbers">Laws
for Quantifiers of unsigned Numbers</a>
</h5>
<p>
The semantics of icl Maps of Numbers is different for unsigned or signed
numbers. So the sets of laws that are valid for Quantifiers will be different
depending on the instantiation of an unsigned or a signed number type as
<code class="computeroutput"><span class="identifier">CodomainT</span></code> parameter.
</p>
<p>
Again, we are presenting the investigated sets of laws, this time for <code class="computeroutput"><span class="identifier">Quantifier</span></code> types <code class="computeroutput"><span class="identifier">Q</span></code>
which are <code class="computeroutput"><a class="link" href="../../boost/icl/map.html" title="Class template map">icl::map</a></code><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">D</span><span class="special">,</span><span class="identifier">N</span><span class="special">,</span><span class="identifier">T</span><span class="special">&gt;</span></code>, <code class="computeroutput"><a class="link" href="../../boost/icl/interval_map.html" title="Class template interval_map">interval_map</a></code><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">D</span><span class="special">,</span><span class="identifier">N</span><span class="special">,</span><span class="identifier">T</span><span class="special">&gt;</span></code> and <code class="computeroutput"><a class="link" href="../../boost/icl/split_interval_map.html" title="Class template split_interval_map">split_interval_map</a></code><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">D</span><span class="special">,</span><span class="identifier">N</span><span class="special">,</span><span class="identifier">T</span><span class="special">&gt;</span></code> where <code class="computeroutput"><span class="identifier">CodomainT</span></code>
type <code class="computeroutput"><span class="identifier">N</span></code> is a <code class="computeroutput"><span class="identifier">Number</span></code> and <code class="computeroutput"><span class="identifier">Trait</span></code>
type <code class="computeroutput"><span class="identifier">T</span></code> is one of the icl's
map traits.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">Associativity</span><span class="special">&lt;</span><span class="identifier">Q</span><span class="special">,+,==</span> <span class="special">&gt;:</span> <span class="identifier">Q</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="identifier">a</span><span class="special">+(</span><span class="identifier">b</span><span class="special">+</span><span class="identifier">c</span><span class="special">)</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">a</span><span class="special">+</span><span class="identifier">b</span><span class="special">)+</span><span class="identifier">c</span>
<span class="identifier">Neutrality</span><span class="special">&lt;</span><span class="identifier">Q</span><span class="special">,+,==</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">Q</span> <span class="identifier">a</span><span class="special">;</span> <span class="identifier">a</span><span class="special">+</span><span class="identifier">Q</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">a</span>
<span class="identifier">Commutativity</span><span class="special">&lt;</span><span class="identifier">Q</span><span class="special">,+,==</span> <span class="special">&gt;:</span> <span class="identifier">Q</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">;</span> <span class="identifier">a</span><span class="special">+</span><span class="identifier">b</span> <span class="special">==</span> <span class="identifier">b</span><span class="special">+</span><span class="identifier">a</span>
<span class="identifier">Associativity</span><span class="special">&lt;</span><span class="identifier">Q</span><span class="special">,&amp;,==</span> <span class="special">&gt;:</span> <span class="identifier">Q</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="identifier">a</span><span class="special">&amp;(</span><span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">c</span><span class="special">)</span> <span class="special">==(</span><span class="identifier">a</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">)&amp;</span><span class="identifier">c</span>
<span class="identifier">Commutativity</span><span class="special">&lt;</span><span class="identifier">Q</span><span class="special">,&amp;,==</span> <span class="special">&gt;:</span> <span class="identifier">Q</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">;</span> <span class="identifier">a</span><span class="special">&amp;</span><span class="identifier">b</span> <span class="special">==</span> <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">a</span>
<span class="identifier">RightNeutrality</span><span class="special">&lt;</span><span class="identifier">Q</span><span class="special">,-,==</span> <span class="special">&gt;:</span> <span class="identifier">Q</span> <span class="identifier">a</span><span class="special">;</span> <span class="identifier">a</span><span class="special">-</span><span class="identifier">Q</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">a</span>
<span class="identifier">Inversion</span><span class="special">&lt;</span><span class="identifier">Q</span><span class="special">,-,=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">Q</span> <span class="identifier">a</span><span class="special">;</span> <span class="identifier">a</span> <span class="special">-</span> <span class="identifier">a</span> <span class="special">=</span><span class="identifier">v</span><span class="special">=</span> <span class="identifier">Q</span><span class="special">()</span>
</pre>
<p>
</p>
<p>
For an <code class="computeroutput"><span class="keyword">unsigned</span> <span class="identifier">Quantifier</span></code>,
an icl Map of <code class="computeroutput"><span class="keyword">unsigned</span> <span class="identifier">numbers</span></code>,
the same basic laws apply that are valid for <code class="computeroutput"><span class="identifier">Collectors</span></code>:
</p>
<p>
</p>
<pre class="programlisting"> <span class="special">+</span> <span class="special">&amp;</span> <span class="special">-</span>
<span class="identifier">Associativity</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">Neutrality</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">Commutativity</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">Inversion</span> <span class="identifier">absorbs_identities</span> <span class="special">==</span>
<span class="identifier">enriches_identities</span> <span class="special">=</span><span class="identifier">d</span><span class="special">=</span>
</pre>
<p>
</p>
<p>
The subset of laws, that relates to <code class="computeroutput"><span class="keyword">operator</span>
<span class="special">+</span></code> and the neutral element <code class="computeroutput"><span class="identifier">Q</span><span class="special">()</span></code> is
that of a commutative monoid. This is the same concept, that applies for
the <code class="computeroutput"><span class="identifier">CodomainT</span></code> type. This
gives rise to the assumption that an icl <code class="computeroutput"><span class="identifier">Map</span></code>
over a <code class="computeroutput"><span class="identifier">CommutativeModoid</span></code>
is again a <code class="computeroutput"><span class="identifier">CommutativeModoid</span></code>.
</p>
<p>
Other laws that were valid for <code class="computeroutput"><span class="identifier">Collectors</span></code>
are not valid for an <code class="computeroutput"><span class="keyword">unsigned</span> <span class="identifier">Quantifier</span></code>.
</p>
<h5>
<a name="boost_icl.semantics.quantifiers__maps_of_numbers.h4"></a>
<span class="phrase"><a name="boost_icl.semantics.quantifiers__maps_of_numbers.laws_for_quantifiers_of_signed_numbers"></a></span><a class="link" href="quantifiers__maps_of_numbers.html#boost_icl.semantics.quantifiers__maps_of_numbers.laws_for_quantifiers_of_signed_numbers">Laws
for Quantifiers of signed Numbers</a>
</h5>
<p>
For <code class="computeroutput"><span class="identifier">Quantifiers</span></code> of signed
numbers, or <code class="computeroutput"><span class="keyword">signed</span> <span class="identifier">Quantifiers</span></code>,
the pattern of valid laws is somewhat different:
</p>
<pre class="programlisting"> <span class="special">+</span> <span class="special">&amp;</span> <span class="special">-</span>
<span class="identifier">Associativity</span> <span class="special">=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">=</span><span class="identifier">v</span><span class="special">=</span>
<span class="identifier">Neutrality</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">Commutativity</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">Inversion</span> <span class="identifier">absorbs_identities</span> <span class="special">==</span>
<span class="identifier">enriches_identities</span> <span class="special">=</span><span class="identifier">d</span><span class="special">=</span>
</pre>
<p>
</p>
<p>
The differences are tagged as <code class="computeroutput"><span class="special">=</span><span class="identifier">v</span><span class="special">=</span></code> indicating,
that the associativity law is not uniquely valid for a single equality relation
<code class="computeroutput"><span class="special">==</span></code> as this was the case for
<code class="computeroutput"><span class="identifier">Collector</span></code> and <code class="computeroutput"><span class="keyword">unsigned</span> <span class="identifier">Quntifier</span></code>
maps.
</p>
<p>
The differences are these:
</p>
<pre class="programlisting"> <span class="special">+</span>
<span class="identifier">Associativity</span> <span class="identifier">icl</span><span class="special">::</span><span class="identifier">map</span> <span class="special">==</span>
<span class="identifier">interval_map</span> <span class="special">==</span>
<span class="identifier">split_interval_map</span> <span class="special">=</span><span class="identifier">e</span><span class="special">=</span>
</pre>
<p>
For <code class="computeroutput"><span class="keyword">operator</span> <span class="special">+</span></code>
the associativity on <code class="computeroutput"><a class="link" href="../../boost/icl/split_interval_map.html" title="Class template split_interval_map">split_interval_maps</a></code>
is only valid with element equality <code class="computeroutput"><span class="special">=</span><span class="identifier">e</span><span class="special">=</span></code>, which
is not a big constrained, because only element equality is required.
</p>
<p>
For <code class="computeroutput"><span class="keyword">operator</span> <span class="special">&amp;</span></code>
the associativity is broken for all maps that are partial absorbers. For
total absorbers associativity is valid for element equality. All maps having
the <span class="emphasis"><em>identity enricher</em></span> Trait are associative wrt. lexicographical
equality <code class="computeroutput"><span class="special">==</span></code>.
</p>
<pre class="programlisting"><span class="identifier">Associativity</span> <span class="special">&amp;</span>
<span class="identifier">absorbs_identities</span> <span class="special">&amp;&amp;</span> <span class="special">!</span><span class="identifier">is_total</span> <span class="keyword">false</span>
<span class="identifier">absorbs_identities</span> <span class="special">&amp;&amp;</span> <span class="identifier">is_total</span> <span class="special">=</span><span class="identifier">e</span><span class="special">=</span>
<span class="identifier">enriches_identities</span> <span class="special">==</span>
</pre>
<p>
</p>
<p>
Note, that all laws that establish a commutative monoid for <code class="computeroutput"><span class="keyword">operator</span> <span class="special">+</span></code>
and identity element <code class="computeroutput"><span class="identifier">Q</span><span class="special">()</span></code>
are valid for <code class="computeroutput"><span class="keyword">signed</span> <span class="identifier">Quantifiers</span></code>.
In addition symmetric difference that does not hold for <code class="computeroutput"><span class="keyword">unsigned</span>
<span class="identifier">Qunatifiers</span></code> is valid for <code class="computeroutput"><span class="keyword">signed</span> <span class="identifier">Qunatifiers</span></code>.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">SymmetricDifference</span><span class="special">&lt;</span><span class="identifier">Q</span><span class="special">,==</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">Q</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">+</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">-</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">-</span> <span class="identifier">a</span><span class="special">)</span>
</pre>
<p>
For a <code class="computeroutput"><span class="keyword">signed</span> <span class="identifier">TotalQuantifier</span></code>
<code class="computeroutput"><span class="identifier">Qt</span></code> symmetrical difference
degenerates to a trivial form since <code class="computeroutput"><span class="keyword">operator</span>
<span class="special">&amp;</span></code> and <code class="computeroutput"><span class="keyword">operator</span>
<span class="special">+</span></code> become identical
</p>
<pre class="programlisting"><span class="identifier">SymmetricDifference</span><span class="special">&lt;</span><span class="identifier">Qt</span><span class="special">,==</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">Qt</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">+</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">-</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">+</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">-</span> <span class="identifier">a</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">Qt</span><span class="special">()</span>
</pre>
<p>
</p>
<h6>
<a name="boost_icl.semantics.quantifiers__maps_of_numbers.h5"></a>
<span class="phrase"><a name="boost_icl.semantics.quantifiers__maps_of_numbers.existence_of_an_inverse"></a></span><a class="link" href="quantifiers__maps_of_numbers.html#boost_icl.semantics.quantifiers__maps_of_numbers.existence_of_an_inverse">Existence
of an Inverse</a>
</h6>
<p>
By now <code class="computeroutput"><span class="keyword">signed</span> <span class="identifier">Quantifiers</span></code>
<code class="computeroutput"><span class="identifier">Q</span></code> are commutative monoids
with respect to the <code class="computeroutput"><span class="keyword">operator</span> <span class="special">+</span></code> and the neutral element <code class="computeroutput"><span class="identifier">Q</span><span class="special">()</span></code>. If the Quantifier's <code class="computeroutput"><span class="identifier">CodomainT</span></code>
type has an <span class="emphasis"><em>inverse element</em></span> like e.g. <code class="computeroutput"><span class="keyword">signed</span> <span class="identifier">numbers</span></code>
do, the <code class="computeroutput"><span class="identifier">CodomainT</span></code> type is
a <span class="emphasis"><em><span class="bold"><strong>commutative</strong></span></em></span> or <span class="emphasis"><em><span class="bold"><strong>abelian group</strong></span></em></span>. In this case a <code class="computeroutput"><span class="keyword">signed</span> <span class="identifier">Quantifier</span></code>
that is also <span class="emphasis"><em><span class="bold"><strong>total</strong></span></em></span>
has an <span class="emphasis"><em><span class="bold"><strong>inverse</strong></span></em></span> and
the following law holds:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">InverseElement</span><span class="special">&lt;</span><span class="identifier">Qt</span><span class="special">,==</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">Qt</span> <span class="identifier">a</span><span class="special">;</span> <span class="special">(</span><span class="number">0</span> <span class="special">-</span> <span class="identifier">a</span><span class="special">)</span> <span class="special">+</span> <span class="identifier">a</span> <span class="special">==</span> <span class="number">0</span>
</pre>
<p>
</p>
<p>
Which means that each <code class="computeroutput"><span class="identifier">TotalQuantifier</span></code>
over an abelian group is an abelian group itself.
</p>
<p>
This also implies that a <code class="computeroutput"><span class="identifier">Quantifier</span></code>
of <code class="computeroutput"><span class="identifier">Quantifiers</span></code> is again a
<code class="computeroutput"><span class="identifier">Quantifiers</span></code> and a <code class="computeroutput"><span class="identifier">TotalQuantifier</span></code> of <code class="computeroutput"><span class="identifier">TotalQuantifiers</span></code>
is also a <code class="computeroutput"><span class="identifier">TotalQuantifier</span></code>.
</p>
<p>
<code class="computeroutput"><span class="identifier">TotalQuantifiers</span></code> resemble
the notion of a vector space partially. The concept could be completed to
a vector space, if a scalar multiplication was added.
</p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2007-2010 Joachim
Faulhaber<br>Copyright &#169; 1999-2006 Cortex Software
GmbH<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="collectors__maps_of_sets.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../semantics.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="concept_induction.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,243 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Sets</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Icl">
<link rel="up" href="../semantics.html" title="Semantics">
<link rel="prev" href="../semantics.html" title="Semantics">
<link rel="next" href="maps.html" title="Maps">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../semantics.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../semantics.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="maps.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_icl.semantics.sets"></a><a class="link" href="sets.html" title="Sets">Sets</a>
</h3></div></div></div>
<p>
For all set types <code class="computeroutput"><span class="identifier">S</span></code> that
are models concept <code class="computeroutput"><span class="identifier">Set</span></code> (<a href="http://www.cplusplus.com/reference/stl/set/" target="_top"><code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">set</span></code>
</a>, <code class="computeroutput"><a class="link" href="../../boost/icl/interval_set.html" title="Class template interval_set">interval_set</a></code>,
<code class="computeroutput"><a class="link" href="../../boost/icl/separate_interval_set.html" title="Class template separate_interval_set">separate_interval_set</a></code>
and <code class="computeroutput"><a class="link" href="../../boost/icl/split_interval_set.html" title="Class template split_interval_set">split_interval_set</a></code>)
most of the well known mathematical <a href="http://en.wikipedia.org/wiki/Algebra_of_sets" target="_top">laws
on sets</a> were successfully checked via LaBatea. The next tables are
giving an overview over the checked laws ordered by operations. If possible,
the laws are formulated with the stronger lexicographical equality (<code class="computeroutput"><span class="keyword">operator</span> <span class="special">==</span></code>)
which implies the law's validity for the weaker element equality <code class="computeroutput"><span class="identifier">is_element_equal</span></code>. Throughout this chapter
we will denote element equality as <code class="computeroutput"><span class="special">=</span><span class="identifier">e</span><span class="special">=</span></code> instead
of <code class="computeroutput"><span class="identifier">is_element_equal</span></code> where
a short notation is advantageous.
</p>
<h6>
<a name="boost_icl.semantics.sets.h0"></a>
<span class="phrase"><a name="boost_icl.semantics.sets.laws_on_set_union"></a></span><a class="link" href="sets.html#boost_icl.semantics.sets.laws_on_set_union">Laws
on set union</a>
</h6>
<p>
For the operation <span class="emphasis"><em><span class="bold"><strong>set union</strong></span></em></span>
available as <code class="computeroutput"><span class="keyword">operator</span> <span class="special">+,</span>
<span class="special">+=,</span> <span class="special">|,</span> <span class="special">|=</span></code> and the neutral element <code class="computeroutput"><span class="identifier">identity_element</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">()</span></code>
which is the empty set <code class="computeroutput"><span class="identifier">S</span><span class="special">()</span></code> these laws hold:
</p>
<pre class="programlisting"><span class="identifier">Associativity</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">,+,==</span> <span class="special">&gt;:</span> <span class="identifier">S</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="identifier">a</span><span class="special">+(</span><span class="identifier">b</span><span class="special">+</span><span class="identifier">c</span><span class="special">)</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">a</span><span class="special">+</span><span class="identifier">b</span><span class="special">)+</span><span class="identifier">c</span>
<span class="identifier">Neutrality</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">,+,==</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">S</span> <span class="identifier">a</span><span class="special">;</span> <span class="identifier">a</span><span class="special">+</span><span class="identifier">S</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">a</span>
<span class="identifier">Commutativity</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">,+,==</span> <span class="special">&gt;:</span> <span class="identifier">S</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">;</span> <span class="identifier">a</span><span class="special">+</span><span class="identifier">b</span> <span class="special">==</span> <span class="identifier">b</span><span class="special">+</span><span class="identifier">a</span>
</pre>
<p>
</p>
<h6>
<a name="boost_icl.semantics.sets.h1"></a>
<span class="phrase"><a name="boost_icl.semantics.sets.laws_on_set_intersection"></a></span><a class="link" href="sets.html#boost_icl.semantics.sets.laws_on_set_intersection">Laws
on set intersection</a>
</h6>
<p>
For the operation <span class="emphasis"><em><span class="bold"><strong>set intersection</strong></span></em></span>
available as <code class="computeroutput"><span class="keyword">operator</span> <span class="special">&amp;,</span>
<span class="special">&amp;=</span></code> these laws were validated:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">Associativity</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">,&amp;,==</span> <span class="special">&gt;:</span> <span class="identifier">S</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="identifier">a</span><span class="special">&amp;(</span><span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">c</span><span class="special">)</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">a</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">)&amp;</span><span class="identifier">c</span>
<span class="identifier">Commutativity</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">,&amp;,==</span> <span class="special">&gt;:</span> <span class="identifier">S</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">;</span> <span class="identifier">a</span><span class="special">&amp;</span><span class="identifier">b</span> <span class="special">==</span> <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">a</span>
</pre>
<p>
</p>
<h6>
<a name="boost_icl.semantics.sets.h2"></a>
<span class="phrase"><a name="boost_icl.semantics.sets.laws_on_set_difference"></a></span><a class="link" href="sets.html#boost_icl.semantics.sets.laws_on_set_difference">Laws
on set difference</a>
</h6>
<p>
For set difference there are only these laws. It is not associative and not
commutative. It's neutrality is non symmetrical.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">RightNeutrality</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">,-,==</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">S</span> <span class="identifier">a</span><span class="special">;</span> <span class="identifier">a</span><span class="special">-</span><span class="identifier">S</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">a</span>
<span class="identifier">Inversion</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">,-,==</span> <span class="special">&gt;:</span> <span class="identifier">S</span> <span class="identifier">a</span><span class="special">;</span> <span class="identifier">a</span> <span class="special">-</span> <span class="identifier">a</span> <span class="special">==</span> <span class="identifier">S</span><span class="special">()</span>
</pre>
<p>
</p>
<p>
Summarized in the next table are laws that use <code class="computeroutput"><span class="special">+</span></code>,
<code class="computeroutput"><span class="special">&amp;</span></code> and <code class="computeroutput"><span class="special">-</span></code>
as a single operation. For all validated laws, the left and right hand sides
of the equations are lexicographically equal, as denoted by <code class="computeroutput"><span class="special">==</span></code> in the cells of the table.
</p>
<p>
</p>
<pre class="programlisting"> <span class="special">+</span> <span class="special">&amp;</span> <span class="special">-</span>
<span class="identifier">Associativity</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">Neutrality</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">Commutativity</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">Inversion</span> <span class="special">==</span>
</pre>
<p>
</p>
<h6>
<a name="boost_icl.semantics.sets.h3"></a>
<span class="phrase"><a name="boost_icl.semantics.sets.distributivity_laws"></a></span><a class="link" href="sets.html#boost_icl.semantics.sets.distributivity_laws">Distributivity
Laws</a>
</h6>
<p>
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 <code class="computeroutput"><span class="special">+</span></code> and <code class="computeroutput"><span class="special">&amp;</span></code>
are swapped. So we can have small operator signatures like <code class="computeroutput"><span class="special">+,&amp;</span></code> and <code class="computeroutput"><span class="special">&amp;,+</span></code>
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 <span class="emphasis"><em>variable</em></span> equality <code class="computeroutput"><span class="special">=</span><span class="identifier">v</span><span class="special">=</span></code>
below.
</p>
<p>
</p>
<pre class="programlisting"> <span class="identifier">Distributivity</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">,+,&amp;,=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">S</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="identifier">a</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">&amp;</span> <span class="identifier">c</span><span class="special">)</span> <span class="special">=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">+</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">&amp;</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">+</span> <span class="identifier">c</span><span class="special">)</span>
<span class="identifier">Distributivity</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">,&amp;,+,=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">S</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="identifier">a</span> <span class="special">&amp;</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">+</span> <span class="identifier">c</span><span class="special">)</span> <span class="special">=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">&amp;</span> <span class="identifier">c</span><span class="special">)</span>
<span class="identifier">RightDistributivity</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">,+,-,=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">S</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">+</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">-</span> <span class="identifier">c</span> <span class="special">=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">c</span><span class="special">)</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">-</span> <span class="identifier">c</span><span class="special">)</span>
<span class="identifier">RightDistributivity</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">,&amp;,-,=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">S</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">-</span> <span class="identifier">c</span> <span class="special">=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">c</span><span class="special">)</span> <span class="special">&amp;</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">-</span> <span class="identifier">c</span><span class="special">)</span>
</pre>
<p>
</p>
<p>
The next table shows the relationship between law instances, <a class="link" href="../../index.html#boost_icl.introduction.interval_combining_styles" title="Interval Combining Styles">interval
combining style</a> and the used equality relation.
</p>
<p>
</p>
<pre class="programlisting"> <span class="special">+,&amp;</span> <span class="special">&amp;,+</span>
<span class="identifier">Distributivity</span> <span class="identifier">joining</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">separating</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">splitting</span> <span class="special">=</span><span class="identifier">e</span><span class="special">=</span> <span class="special">=</span><span class="identifier">e</span><span class="special">=</span>
<span class="special">+,-</span> <span class="special">&amp;,-</span>
<span class="identifier">RightDistributivity</span> <span class="identifier">joining</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">separating</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">splitting</span> <span class="special">=</span><span class="identifier">e</span><span class="special">=</span> <span class="special">==</span>
</pre>
<p>
</p>
<p>
The table gives an overview over 12 instantiations of the four distributivity
laws and shows the equalities which the instantiations holds for. For instance
<code class="computeroutput"><span class="identifier">RightDistributivity</span></code> with
operator signature <code class="computeroutput"><span class="special">+,-</span></code> instantiated
for <code class="computeroutput"><a class="link" href="../../boost/icl/split_interval_set.html" title="Class template split_interval_set">split_interval_sets</a></code>
holds only for element equality (denoted as <code class="computeroutput"><span class="special">=</span><span class="identifier">e</span><span class="special">=</span></code>):
</p>
<pre class="programlisting"><span class="identifier">RightDistributivity</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">,+,-,=</span><span class="identifier">e</span><span class="special">=</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">S</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">+</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">-</span> <span class="identifier">c</span> <span class="special">=</span><span class="identifier">e</span><span class="special">=</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">c</span><span class="special">)</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">-</span> <span class="identifier">c</span><span class="special">)</span>
</pre>
<p>
The remaining five instantiations of <code class="computeroutput"><span class="identifier">RightDistributivity</span></code>
are valid for lexicographical equality (demoted as <code class="computeroutput"><span class="special">==</span></code>)
as well.
</p>
<p>
<a class="link" href="../../index.html#boost_icl.introduction.interval_combining_styles" title="Interval Combining Styles">Interval
combining styles</a> correspond to containers according to
</p>
<pre class="programlisting"><span class="identifier">style</span> <span class="identifier">set</span>
<span class="identifier">joining</span> <span class="identifier">interval_set</span>
<span class="identifier">separating</span> <span class="identifier">separate_interval_set</span>
<span class="identifier">splitting</span> <span class="identifier">split_interval_set</span>
</pre>
<p>
</p>
<p>
Finally there are two laws that combine all three major set operations: De
Mogans Law and Symmetric Difference.
</p>
<h6>
<a name="boost_icl.semantics.sets.h4"></a>
<span class="phrase"><a name="boost_icl.semantics.sets.demorgan_s_law"></a></span><a class="link" href="sets.html#boost_icl.semantics.sets.demorgan_s_law">DeMorgan's
Law</a>
</h6>
<p>
De Morgans Law is better known in an incarnation where the unary complement
operation <code class="computeroutput"><span class="special">~</span></code> is used. <code class="computeroutput"><span class="special">~(</span><span class="identifier">a</span><span class="special">+</span><span class="identifier">b</span><span class="special">)</span> <span class="special">==</span>
<span class="special">~</span><span class="identifier">a</span> <span class="special">*</span> <span class="special">~</span><span class="identifier">b</span></code>.
The version below is an adaption for the binary set difference <code class="computeroutput"><span class="special">-</span></code>, which is also called <span class="emphasis"><em><span class="bold"><strong>relative complement</strong></span></em></span>.
</p>
<pre class="programlisting"><span class="identifier">DeMorgan</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">,+,&amp;,=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">S</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="identifier">a</span> <span class="special">-</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">+</span> <span class="identifier">c</span><span class="special">)</span> <span class="special">=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">&amp;</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">c</span><span class="special">)</span>
<span class="identifier">DeMorgan</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">,&amp;,+,=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">S</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="identifier">a</span> <span class="special">-</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">&amp;</span> <span class="identifier">c</span><span class="special">)</span> <span class="special">=</span><span class="identifier">v</span><span class="special">=</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">c</span><span class="special">)</span>
</pre>
<p>
</p>
<p>
</p>
<pre class="programlisting"> <span class="special">+,&amp;</span> <span class="special">&amp;,+</span>
<span class="identifier">DeMorgan</span> <span class="identifier">joining</span> <span class="special">==</span> <span class="special">==</span>
<span class="identifier">separating</span> <span class="special">==</span> <span class="special">=</span><span class="identifier">e</span><span class="special">=</span>
<span class="identifier">splitting</span> <span class="special">==</span> <span class="special">=</span><span class="identifier">e</span><span class="special">=</span>
</pre>
<p>
</p>
<p>
Again not all law instances are valid for lexicographical equality. The second
instantiations only holds for element equality, if the interval sets are
non joining.
</p>
<h6>
<a name="boost_icl.semantics.sets.h5"></a>
<span class="phrase"><a name="boost_icl.semantics.sets.symmetric_difference"></a></span><a class="link" href="sets.html#boost_icl.semantics.sets.symmetric_difference">Symmetric
Difference</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="identifier">SymmetricDifference</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">,==</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">S</span> <span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">;</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">+</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">-</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">a</span> <span class="special">-</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">b</span> <span class="special">-</span> <span class="identifier">a</span><span class="special">)</span>
</pre>
<p>
</p>
<p>
Finally Symmetric Difference holds for all of icl set types and lexicographical
equality.
</p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2007-2010 Joachim
Faulhaber<br>Copyright &#169; 1999-2006 Cortex Software
GmbH<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../semantics.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../semantics.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="maps.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>