blob: 4a4e48ddee6e761372d5f3b5e21f1b7cf4567628 [file] [log] [blame]
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Complexity</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.74.0">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Icl">
<link rel="up" href="../implementation.html" title="Implementation">
<link rel="prev" href="../implementation.html" title="Implementation">
<link rel="next" href="inplace_and_infix_operators.html" title="Inplace and infix operators">
</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="../implementation.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../implementation.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="inplace_and_infix_operators.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section boost_icl_implementation_complexity" lang="en">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_icl.implementation.complexity"></a><a class="link" href="complexity.html" title="Complexity">Complexity</a>
</h3></div></div></div>
<a name="boost_icl.implementation.complexity.complexity_of_element_containers"></a><h5>
<a name="id1132060"></a>
<a class="link" href="complexity.html#boost_icl.implementation.complexity.complexity_of_element_containers">Complexity
of element containers</a>
</h5>
<p>
Since <span class="emphasis"><em>element containers</em></span> <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> and <code class="computeroutput"><a class="link" href="../../boost/icl/map.html" title="Class template map">icl::map</a></code> are only
extensions of stl::set and stl::map, their complexity characteristics are
accordingly. So their major operations insertion (addition), deletion and
search are all using logarithmic time.
</p>
<a name="boost_icl.implementation.complexity.complexity_of_interval_containers"></a><h5>
<a name="id1132106"></a>
<a class="link" href="complexity.html#boost_icl.implementation.complexity.complexity_of_interval_containers">Complexity
of interval containers</a>
</h5>
<p>
The operations on <span class="emphasis"><em>interval containers</em></span> behave differently
due to the fact that intervals unlike elements can overlap any number of
other intervals in a container. As long as intervals are relatively small
or just singleton, interval containers behave like containers of elements.
For large intervals however time consumption of operations on interval containers
may be worse, because most or all intervals of a container may have to be
visited. As an example, time complexity of <a class="link" href="../function_reference/addition.html" title="Addition"><span class="emphasis"><em><span class="bold"><strong>Addition</strong></span></em></span></a> on interval containers
is briefly discussed.
</p>
<p>
More information on <span class="emphasis"><em><span class="bold"><strong>complexity characteristics</strong></span></em></span>
of <span class="bold"><strong>icl's</strong></span> functions is contained in section
<a class="link" href="../function_reference.html" title="Function Reference">Function Reference</a>
</p>
<a name="boost_icl.implementation.complexity.time_complexity_of_addition"></a><h6>
<a name="id1132157"></a>
<a class="link" href="complexity.html#boost_icl.implementation.complexity.time_complexity_of_addition">Time
Complexity of Addition</a>
</h6>
<p>
The next table gives the time complexities for the overloaded <code class="computeroutput"><span class="keyword">operator</span> <span class="special">+=</span></code>
on interval containers. The instance types of <code class="computeroutput"><span class="identifier">T</span></code>
are given as column headers. Instances of type parameter <code class="computeroutput"><span class="identifier">P</span></code>
are denoted in the second column. The third column contains the specific
kind of complexity statement. If column three is empty <span class="emphasis"><em><span class="bold"><strong>worst case</strong></span></em></span> complexity is given in the related
row.
</p>
<div class="table">
<a name="id1132205"></a><p class="title"><b>Table&#160;1.15.&#160;Time Complexity of Addition:</b></p>
<div class="table-contents"><table class="table" summary="Time Complexity of Addition:">
<colgroup>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
</p>
</th>
<th>
<p>
<code class="computeroutput"><span class="identifier">P</span></code>
</p>
</th>
<th>
<p>
</p>
</th>
<th>
<p>
interval<br> set
</p>
</th>
<th>
<p>
separate<br> interval<br> set
</p>
</th>
<th>
<p>
split<br> interval<br> set
</p>
</th>
<th>
<p>
interval<br> map
</p>
</th>
<th>
<p>
split<br> interval<br> map
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">T</span><span class="special">&amp;</span>
<span class="keyword">operator</span> <span class="special">+=(</span><span class="identifier">T</span><span class="special">&amp;</span>
<span class="identifier">object</span><span class="special">,</span>
<span class="keyword">const</span> <span class="identifier">P</span><span class="special">&amp;</span> <span class="identifier">addend</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">element_type</span></code>
</p>
</td>
<td>
<p>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(log n)</em></span>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(log n)</em></span>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(log n)</em></span>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(log n)</em></span>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(log n)</em></span>
</p>
</td>
</tr>
<tr>
<td>
<p>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">segment_type</span></code>
</p>
</td>
<td>
<p>
best case
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(log n)</em></span>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(log n)</em></span>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(log n)</em></span>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(log n)</em></span>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(log n)</em></span>
</p>
</td>
</tr>
<tr>
<td>
<p>
</p>
</td>
<td>
<p>
</p>
</td>
<td>
<p>
worst case
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(n)</em></span>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(n)</em></span>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(n)</em></span>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(n)</em></span>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(n)</em></span>
</p>
</td>
</tr>
<tr>
<td>
<p>
</p>
</td>
<td>
<p>
</p>
</td>
<td>
<p>
amortized
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(log n)</em></span>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(log n)</em></span>
</p>
</td>
<td>
<p>
</p>
</td>
<td>
<p>
</p>
</td>
<td>
<p>
</p>
</td>
</tr>
<tr>
<td>
<p>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">interval_sets</span></code>
</p>
</td>
<td>
<p>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(m log(n+m))</em></span>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(m log(n+m))</em></span>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(m log(n+m))</em></span>
</p>
</td>
<td>
<p>
</p>
</td>
<td>
<p>
</p>
</td>
</tr>
<tr>
<td>
<p>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">interval_maps</span></code>
</p>
</td>
<td>
<p>
</p>
</td>
<td>
<p>
</p>
</td>
<td>
<p>
</p>
</td>
<td>
<p>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(m log(n+m))</em></span>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>O(m log(n+m))</em></span>
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><p>
Adding an <span class="emphasis"><em>element</em></span> or <span class="emphasis"><em>element value pair</em></span>
is always done in <span class="emphasis"><em>logarithmic time</em></span>, where <span class="emphasis"><em>n</em></span>
is the number of intervals in the interval container. The same row of complexities
applies to the insertion of a <span class="emphasis"><em>segment</em></span> (an interval or
an interval value pair) in the <span class="emphasis"><em><span class="bold"><strong>best case</strong></span></em></span>,
where the inserted segment does overlap with only a <span class="emphasis"><em><span class="bold"><strong>small</strong></span></em></span>
number of intervals in the container.
</p>
<p>
In the <span class="emphasis"><em><span class="bold"><strong>worst case</strong></span></em></span>,
where the inserted segment overlaps with all intervals in the container,
the algorithms iterate over all the overlapped segments. Using inplace manipulations
of segments and hinted inserts, it is possible to perform all necessary operations
on each iteration step in <span class="emphasis"><em>constant time</em></span>. This results
in <span class="emphasis"><em><span class="bold"><strong>linear worst case time</strong></span></em></span>
complexity for segment addition for all interval containers.
</p>
<p>
After performing a worst case addition for an <code class="computeroutput"><a class="link" href="../../boost/icl/interval_set.html" title="Class template interval_set">interval_set</a></code>
or a <code class="computeroutput"><a class="link" href="../../boost/icl/separate_interval_set.html" title="Class template separate_interval_set">separate_interval_sets</a></code>
adding an interval that overlaps <span class="emphasis"><em>n</em></span> intervals, we need
<span class="emphasis"><em>n</em></span> non overlapping additions of <span class="emphasis"><em>logarithmic
time</em></span> before we can launch another <span class="emphasis"><em>O(n)</em></span> worst
case addition. So we have only a <span class="emphasis"><em><span class="bold"><strong>logarithmic
amortized time</strong></span></em></span> for the addition of an interval or interval
value pair.
</p>
<p>
For the addition of <span class="emphasis"><em><span class="bold"><strong>interval containers</strong></span></em></span>
complexity is <span class="emphasis"><em>O(m log(n+m))</em></span>. So for the <span class="emphasis"><em><span class="bold"><strong>worst case</strong></span></em></span>, where the container sizes
<span class="emphasis"><em>n</em></span> and <span class="emphasis"><em>m</em></span> are equal and both containers
cover the same ranges, the complexity of container addition is <span class="emphasis"><em><span class="bold"><strong>loglinear</strong></span></em></span>. For other cases, that occur
frequently in real world applications performance can be much better. If
the added container <code class="computeroutput"><span class="identifier">operand</span></code>
is much smaller than <code class="computeroutput"><span class="identifier">object</span></code>
and the intervals in <code class="computeroutput"><span class="identifier">operand</span></code>
are relatively small, performance can be <span class="emphasis"><em>logarithmic</em></span>.
If <span class="emphasis"><em>m</em></span> is small compared with <span class="emphasis"><em>n</em></span> and
intervals in <code class="computeroutput"><span class="identifier">operand</span></code> are
large, performance tends to be <span class="emphasis"><em>linear</em></span>.
</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="../implementation.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../implementation.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="inplace_and_infix_operators.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>