summaryrefslogtreecommitdiff
path: root/doc/html/algorithm
diff options
context:
space:
mode:
Diffstat (limited to 'doc/html/algorithm')
-rw-r--r--doc/html/algorithm/CXX11.html1183
-rw-r--r--doc/html/algorithm/CXX14.html321
-rw-r--r--doc/html/algorithm/Misc.html556
-rw-r--r--doc/html/algorithm/Searching.html544
-rw-r--r--doc/html/algorithm/reference.html745
5 files changed, 0 insertions, 3349 deletions
diff --git a/doc/html/algorithm/CXX11.html b/doc/html/algorithm/CXX11.html
deleted file mode 100644
index 7122cc4a15..0000000000
--- a/doc/html/algorithm/CXX11.html
+++ /dev/null
@@ -1,1183 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>C++11 Algorithms</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="The Boost C++ Libraries BoostBook Documentation Subset">
-<link rel="up" href="../algorithm.html" title="Chapter&#160;3.&#160;The Boost Algorithm Library">
-<link rel="prev" href="Searching.html" title="Searching Algorithms">
-<link rel="next" href="CXX14.html" title="C++14 Algorithms">
-</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="../../../libs/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="Searching.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../algorithm.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="CXX14.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="algorithm.CXX11"></a><a class="link" href="CXX11.html" title="C++11 Algorithms">C++11 Algorithms</a>
-</h2></div></div></div>
-<div class="toc"><dl class="toc">
-<dt><span class="section"><a href="CXX11.html#the_boost_algorithm_library.CXX11.all_of">all_of</a></span></dt>
-<dt><span class="section"><a href="CXX11.html#the_boost_algorithm_library.CXX11.any_of">any_of</a></span></dt>
-<dt><span class="section"><a href="CXX11.html#the_boost_algorithm_library.CXX11.none_of">none_of</a></span></dt>
-<dt><span class="section"><a href="CXX11.html#the_boost_algorithm_library.CXX11.one_of">one_of</a></span></dt>
-<dt><span class="section"><a href="CXX11.html#the_boost_algorithm_library.CXX11.is_sorted">is_sorted
- </a></span></dt>
-<dt><span class="section"><a href="CXX11.html#the_boost_algorithm_library.CXX11.is_partitioned">is_partitioned
- </a></span></dt>
-<dt><span class="section"><a href="CXX11.html#the_boost_algorithm_library.CXX11.is_permutation">is_permutation
- </a></span></dt>
-<dt><span class="section"><a href="CXX11.html#the_boost_algorithm_library.CXX11.partition_point">partition_point
- </a></span></dt>
-</dl></div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="the_boost_algorithm_library.CXX11.all_of"></a><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.all_of" title="all_of">all_of</a>
-</h3></div></div></div>
-<p>
- The header file 'boost/algorithm/cxx11/all_of.hpp' contains four variants
- of a single algorithm, <code class="computeroutput"><span class="identifier">all_of</span></code>.
- The algorithm tests all the elements of a sequence and returns true if they
- all share a property.
- </p>
-<p>
- The routine <code class="computeroutput"><span class="identifier">all_of</span></code> takes
- a sequence and a predicate. It will return true if the predicate returns
- true when applied to every element in the sequence.
- </p>
-<p>
- The routine <code class="computeroutput"><span class="identifier">all_of_equal</span></code>
- takes a sequence and a value. It will return true if every element in the
- sequence compares equal to the passed in value.
- </p>
-<p>
- Both routines come in two forms; the first one takes two iterators to define
- the range. The second form takes a single range parameter, and uses Boost.Range
- to traverse it.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.all_of.h0"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.all_of.interface"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.all_of.interface">interface</a>
- </h5>
-<p>
- The function <code class="computeroutput"><span class="identifier">all_of</span></code> returns
- true if the predicate returns true for every item in the sequence. There
- are two versions; one takes two iterators, and the other takes a range.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">all_of</span> <span class="special">(</span> <span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">Predicate</span> <span class="identifier">p</span> <span class="special">);</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">all_of</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">Predicate</span> <span class="identifier">p</span> <span class="special">);</span>
-<span class="special">}}</span>
-</pre>
-<p>
- </p>
-<p>
- The function <code class="computeroutput"><span class="identifier">all_of_equal</span></code>
- is similar to <code class="computeroutput"><span class="identifier">all_of</span></code>, but
- instead of taking a predicate to test the elements of the sequence, it takes
- a value to compare against.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">V</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">all_of_equal</span> <span class="special">(</span> <span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">V</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">val</span> <span class="special">);</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">V</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">all_of_equal</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">V</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">val</span> <span class="special">);</span>
-<span class="special">}}</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.all_of.h1"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.all_of.examples"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.all_of.examples">Examples</a>
- </h5>
-<p>
- Given the container <code class="computeroutput"><span class="identifier">c</span></code> containing
- <code class="computeroutput"><span class="special">{</span> <span class="number">0</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">3</span><span class="special">,</span> <span class="number">14</span><span class="special">,</span> <span class="number">15</span> <span class="special">}</span></code>,
- then
-</p>
-<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">isOdd</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">i</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="keyword">bool</span> <span class="identifier">lessThan10</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">}</span>
-
-<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">;</span>
-<span class="identifier">all_of</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">isOdd</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">false</span>
-<span class="identifier">all_of</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">lessThan10</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">false</span>
-<span class="identifier">all_of</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">()</span> <span class="special">+</span> <span class="number">3</span><span class="special">,</span> <span class="identifier">lessThan10</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">all_of</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">isOdd</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span> <span class="comment">// empty range</span>
-<span class="identifier">all_of_equal</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">,</span> <span class="number">3</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">false</span>
-<span class="identifier">all_of_equal</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">()</span> <span class="special">+</span> <span class="number">3</span><span class="special">,</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">()</span> <span class="special">+</span> <span class="number">4</span><span class="special">,</span> <span class="number">3</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">all_of_equal</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="number">99</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span> <span class="comment">// empty range</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.all_of.h2"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.all_of.iterator_requirements"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.all_of.iterator_requirements">Iterator
- Requirements</a>
- </h5>
-<p>
- <code class="computeroutput"><span class="identifier">all_of</span></code> and <code class="computeroutput"><span class="identifier">all_of_equal</span></code> work on all iterators except
- output iterators.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.all_of.h3"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.all_of.complexity"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.all_of.complexity">Complexity</a>
- </h5>
-<p>
- All of the variants of <code class="computeroutput"><span class="identifier">all_of</span></code>
- and <code class="computeroutput"><span class="identifier">all_of_equal</span></code> run in
- <span class="emphasis"><em>O(N)</em></span> (linear) time; that is, they compare against each
- element in the list once. If any of the comparisons fail, the algorithm will
- terminate immediately, without examining the remaining members of the sequence.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.all_of.h4"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.all_of.exception_safety"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.all_of.exception_safety">Exception
- Safety</a>
- </h5>
-<p>
- All of the variants of <code class="computeroutput"><span class="identifier">all_of</span></code>
- and <code class="computeroutput"><span class="identifier">all_of_equal</span></code> take their
- parameters by value or const reference, and do not depend upon any global
- state. Therefore, all the routines in this file provide the strong exception
- guarantee.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.all_of.h5"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.all_of.notes"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.all_of.notes">Notes</a>
- </h5>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
- The routine <code class="computeroutput"><span class="identifier">all_of</span></code> is
- also available as part of the C++11 standard.
- </li>
-<li class="listitem">
- <code class="computeroutput"><span class="identifier">all_of</span></code> and <code class="computeroutput"><span class="identifier">all_of_equal</span></code> both return true for empty
- ranges, no matter what is passed to test against. When there are no items
- in the sequence to test, they all satisfy the condition to be tested
- against.
- </li>
-<li class="listitem">
- The second parameter to <code class="computeroutput"><span class="identifier">all_of_value</span></code>
- is a template parameter, rather than deduced from the first parameter
- (<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">InputIterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code>) because that allows more
- flexibility for callers, and takes advantage of built-in comparisons
- for the type that is pointed to by the iterator. The function is defined
- to return true if, for all elements in the sequence, the expression
- <code class="computeroutput"><span class="special">*</span><span class="identifier">iter</span>
- <span class="special">==</span> <span class="identifier">val</span></code>
- evaluates to true (where <code class="computeroutput"><span class="identifier">iter</span></code>
- is an iterator to each element in the sequence)
- </li>
-</ul></div>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="the_boost_algorithm_library.CXX11.any_of"></a><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.any_of" title="any_of">any_of</a>
-</h3></div></div></div>
-<p>
- The header file 'boost/algorithm/cxx11/any_of.hpp' contains four variants
- of a single algorithm, <code class="computeroutput"><span class="identifier">any_of</span></code>.
- The algorithm tests the elements of a sequence and returns true if any of
- the elements has a particular property.
- </p>
-<p>
- The routine <code class="computeroutput"><span class="identifier">any_of</span></code> takes
- a sequence and a predicate. It will return true if the predicate returns
- true for any element in the sequence.
- </p>
-<p>
- The routine <code class="computeroutput"><span class="identifier">any_of_equal</span></code>
- takes a sequence and a value. It will return true if any element in the sequence
- compares equal to the passed in value.
- </p>
-<p>
- Both routines come in two forms; the first one takes two iterators to define
- the range. The second form takes a single range parameter, and uses Boost.Range
- to traverse it.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.any_of.h0"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.any_of.interface"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.any_of.interface">interface</a>
- </h5>
-<p>
- The function <code class="computeroutput"><span class="identifier">any_of</span></code> returns
- true if the predicate returns true any item in the sequence. There are two
- versions; one takes two iterators, and the other takes a range.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">any_of</span> <span class="special">(</span> <span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">Predicate</span> <span class="identifier">p</span> <span class="special">);</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">any_of</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">Predicate</span> <span class="identifier">p</span> <span class="special">);</span>
-<span class="special">}}</span>
-</pre>
-<p>
- </p>
-<p>
- The function <code class="computeroutput"><span class="identifier">any_of_equal</span></code>
- is similar to <code class="computeroutput"><span class="identifier">any_of</span></code>, but
- instead of taking a predicate to test the elements of the sequence, it takes
- a value to compare against.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">V</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">any_of_equal</span> <span class="special">(</span> <span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">V</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">val</span> <span class="special">);</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">V</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">any_of_equal</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">V</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">val</span> <span class="special">);</span>
-<span class="special">}}</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.any_of.h1"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.any_of.examples"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.any_of.examples">Examples</a>
- </h5>
-<p>
- Given the container <code class="computeroutput"><span class="identifier">c</span></code> containing
- <code class="computeroutput"><span class="special">{</span> <span class="number">0</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">3</span><span class="special">,</span> <span class="number">14</span><span class="special">,</span> <span class="number">15</span> <span class="special">}</span></code>,
- then
-</p>
-<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">isOdd</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">i</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="keyword">bool</span> <span class="identifier">lessThan10</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">}</span>
-
-<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">;</span>
-<span class="identifier">any_of</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">isOdd</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">any_of</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">lessThan10</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">any_of</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">()</span> <span class="special">+</span> <span class="number">4</span><span class="special">,</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">lessThan10</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">false</span>
-<span class="identifier">any_of</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">isOdd</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">false</span> <span class="comment">// empty range</span>
-<span class="identifier">any_of_equal</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">,</span> <span class="number">3</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">any_of_equal</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">()</span> <span class="special">+</span> <span class="number">3</span><span class="special">,</span> <span class="number">3</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">false</span>
-<span class="identifier">any_of_equal</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="number">99</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">false</span> <span class="comment">// empty range</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.any_of.h2"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.any_of.iterator_requirements"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.any_of.iterator_requirements">Iterator
- Requirements</a>
- </h5>
-<p>
- <code class="computeroutput"><span class="identifier">any_of</span></code> and <code class="computeroutput"><span class="identifier">any_of_equal</span></code> work on all iterators except
- output iterators.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.any_of.h3"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.any_of.complexity"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.any_of.complexity">Complexity</a>
- </h5>
-<p>
- All of the variants of <code class="computeroutput"><span class="identifier">any_of</span></code>
- and <code class="computeroutput"><span class="identifier">any_of_equal</span></code> run in
- <span class="emphasis"><em>O(N)</em></span> (linear) time; that is, they compare against each
- element in the list once. If any of the comparisons succeed, the algorithm
- will terminate immediately, without examining the remaining members of the
- sequence.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.any_of.h4"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.any_of.exception_safety"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.any_of.exception_safety">Exception
- Safety</a>
- </h5>
-<p>
- All of the variants of <code class="computeroutput"><span class="identifier">any_of</span></code>
- and <code class="computeroutput"><span class="identifier">any_of_equal</span></code> take their
- parameters by value or const reference, and do not depend upon any global
- state. Therefore, all the routines in this file provide the strong exception
- guarantee.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.any_of.h5"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.any_of.notes"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.any_of.notes">Notes</a>
- </h5>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
- The routine <code class="computeroutput"><span class="identifier">any_of</span></code> is
- also available as part of the C++11 standard.
- </li>
-<li class="listitem">
- <code class="computeroutput"><span class="identifier">any_of</span></code> and <code class="computeroutput"><span class="identifier">any_of_equal</span></code> both return false for
- empty ranges, no matter what is passed to test against.
- </li>
-<li class="listitem">
- The second parameter to <code class="computeroutput"><span class="identifier">any_of_value</span></code>
- is a template parameter, rather than deduced from the first parameter
- (<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">InputIterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code>) because that allows more
- flexibility for callers, and takes advantage of built-in comparisons
- for the type that is pointed to by the iterator. The function is defined
- to return true if, for any element in the sequence, the expression <code class="computeroutput"><span class="special">*</span><span class="identifier">iter</span> <span class="special">==</span> <span class="identifier">val</span></code>
- evaluates to true (where <code class="computeroutput"><span class="identifier">iter</span></code>
- is an iterator to each element in the sequence)
- </li>
-</ul></div>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="the_boost_algorithm_library.CXX11.none_of"></a><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.none_of" title="none_of">none_of</a>
-</h3></div></div></div>
-<p>
- The header file 'boost/algorithm/cxx11/none_of.hpp' contains four variants
- of a single algorithm, <code class="computeroutput"><span class="identifier">none_of</span></code>.
- The algorithm tests all the elements of a sequence and returns true if they
- none of them share a property.
- </p>
-<p>
- The routine <code class="computeroutput"><span class="identifier">none_of</span></code> takes
- a sequence and a predicate. It will return true if the predicate returns
- false when applied to every element in the sequence.
- </p>
-<p>
- The routine <code class="computeroutput"><span class="identifier">none_of_equal</span></code>
- takes a sequence and a value. It will return true if none of the elements
- in the sequence compare equal to the passed in value.
- </p>
-<p>
- Both routines come in two forms; the first one takes two iterators to define
- the range. The second form takes a single range parameter, and uses Boost.Range
- to traverse it.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.none_of.h0"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.none_of.interface"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.none_of.interface">interface</a>
- </h5>
-<p>
- The function <code class="computeroutput"><span class="identifier">none_of</span></code> returns
- true if the predicate returns false for every item in the sequence. There
- are two versions; one takes two iterators, and the other takes a range.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">none_of</span> <span class="special">(</span> <span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">Predicate</span> <span class="identifier">p</span> <span class="special">);</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">none_of</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">Predicate</span> <span class="identifier">p</span> <span class="special">);</span>
-<span class="special">}}</span>
-</pre>
-<p>
- </p>
-<p>
- The function <code class="computeroutput"><span class="identifier">none_of_equal</span></code>
- is similar to <code class="computeroutput"><span class="identifier">none_of</span></code>, but
- instead of taking a predicate to test the elements of the sequence, it takes
- a value to compare against.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">V</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">none_of_equal</span> <span class="special">(</span> <span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">V</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">val</span> <span class="special">);</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">V</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">none_of_equal</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">V</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">val</span> <span class="special">);</span>
-<span class="special">}}</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.none_of.h1"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.none_of.examples"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.none_of.examples">Examples</a>
- </h5>
-<p>
- Given the container <code class="computeroutput"><span class="identifier">c</span></code> containing
- <code class="computeroutput"><span class="special">{</span> <span class="number">0</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">3</span><span class="special">,</span> <span class="number">14</span><span class="special">,</span> <span class="number">15</span> <span class="special">}</span></code>,
- then
-</p>
-<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">isOdd</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">i</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="keyword">bool</span> <span class="identifier">lessThan10</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">}</span>
-
-<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">;</span>
-
-<span class="identifier">none_of</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">isOdd</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">false</span>
-<span class="identifier">none_of</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">lessThan10</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">false</span>
-<span class="identifier">none_of</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">()</span> <span class="special">+</span> <span class="number">4</span><span class="special">,</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">lessThan10</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">none_of</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">isOdd</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span> <span class="comment">// empty range</span>
-<span class="identifier">none_of_equal</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">,</span> <span class="number">3</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">false</span>
-<span class="identifier">none_of_equal</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">()</span> <span class="special">+</span> <span class="number">3</span><span class="special">,</span> <span class="number">3</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">none_of_equal</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="number">99</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span> <span class="comment">// empty range</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.none_of.h2"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.none_of.iterator_requirements"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.none_of.iterator_requirements">Iterator
- Requirements</a>
- </h5>
-<p>
- <code class="computeroutput"><span class="identifier">none_of</span></code> and <code class="computeroutput"><span class="identifier">none_of_equal</span></code> work on all iterators except
- output iterators.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.none_of.h3"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.none_of.complexity"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.none_of.complexity">Complexity</a>
- </h5>
-<p>
- All of the variants of <code class="computeroutput"><span class="identifier">none_of</span></code>
- and <code class="computeroutput"><span class="identifier">none_of_equal</span></code> run in
- <span class="emphasis"><em>O(N)</em></span> (linear) time; that is, they compare against each
- element in the list once. If any of the comparisons succeed, the algorithm
- will terminate immediately, without examining the remaining members of the
- sequence.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.none_of.h4"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.none_of.exception_safety"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.none_of.exception_safety">Exception
- Safety</a>
- </h5>
-<p>
- All of the variants of <code class="computeroutput"><span class="identifier">none_of</span></code>
- and <code class="computeroutput"><span class="identifier">none_of_equal</span></code> take their
- parameters by value or const reference, and do not depend upon any global
- state. Therefore, all the routines in this file provide the strong exception
- guarantee.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.none_of.h5"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.none_of.notes"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.none_of.notes">Notes</a>
- </h5>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
- The routine <code class="computeroutput"><span class="identifier">none_of</span></code> is
- also available as part of the C++11 standard.
- </li>
-<li class="listitem">
- <code class="computeroutput"><span class="identifier">none_of</span></code> and <code class="computeroutput"><span class="identifier">none_of_equal</span></code> both return true for
- empty ranges, no matter what is passed to test against.
- </li>
-<li class="listitem">
- The second parameter to <code class="computeroutput"><span class="identifier">none_of_value</span></code>
- is a template parameter, rather than deduced from the first parameter
- (<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">InputIterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code>) because that allows more
- flexibility for callers, and takes advantage of built-in comparisons
- for the type that is pointed to by the iterator. The function is defined
- to return true if, for all elements in the sequence, the expression
- <code class="computeroutput"><span class="special">*</span><span class="identifier">iter</span>
- <span class="special">==</span> <span class="identifier">val</span></code>
- evaluates to false (where <code class="computeroutput"><span class="identifier">iter</span></code>
- is an iterator to each element in the sequence)
- </li>
-</ul></div>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="the_boost_algorithm_library.CXX11.one_of"></a><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.one_of" title="one_of">one_of</a>
-</h3></div></div></div>
-<p>
- The header file 'boost/algorithm/cxx11/one_of.hpp' contains four variants
- of a single algorithm, <code class="computeroutput"><span class="identifier">one_of</span></code>.
- The algorithm tests the elements of a sequence and returns true if exactly
- one of the elements in the sequence has a particular property.
- </p>
-<p>
- The routine <code class="computeroutput"><span class="identifier">one_of</span></code> takes
- a sequence and a predicate. It will return true if the predicate returns
- true for one element in the sequence.
- </p>
-<p>
- The routine <code class="computeroutput"><span class="identifier">one_of_equal</span></code>
- takes a sequence and a value. It will return true if one element in the sequence
- compares equal to the passed in value.
- </p>
-<p>
- Both routines come in two forms; the first one takes two iterators to define
- the range. The second form takes a single range parameter, and uses Boost.Range
- to traverse it.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.one_of.h0"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.one_of.interface"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.one_of.interface">interface</a>
- </h5>
-<p>
- The function <code class="computeroutput"><span class="identifier">one_of</span></code> returns
- true if the predicate returns true for one item in the sequence. There are
- two versions; one takes two iterators, and the other takes a range.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">one_of</span> <span class="special">(</span> <span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">Predicate</span> <span class="identifier">p</span> <span class="special">);</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">one_of</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">Predicate</span> <span class="identifier">p</span> <span class="special">);</span>
-<span class="special">}}</span>
-</pre>
-<p>
- </p>
-<p>
- The function <code class="computeroutput"><span class="identifier">one_of_equal</span></code>
- is similar to <code class="computeroutput"><span class="identifier">one_of</span></code>, but
- instead of taking a predicate to test the elements of the sequence, it takes
- a value to compare against.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">V</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">one_of_equal</span> <span class="special">(</span> <span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">V</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">val</span> <span class="special">);</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">V</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">one_of_equal</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">V</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">val</span> <span class="special">);</span>
-<span class="special">}}</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.one_of.h1"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.one_of.examples"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.one_of.examples">Examples</a>
- </h5>
-<p>
- Given the container <code class="computeroutput"><span class="identifier">c</span></code> containing
- <code class="computeroutput"><span class="special">{</span> <span class="number">0</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">3</span><span class="special">,</span> <span class="number">14</span><span class="special">,</span> <span class="number">15</span> <span class="special">}</span></code>,
- then
-</p>
-<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">isOdd</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">i</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="keyword">bool</span> <span class="identifier">lessThan10</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">}</span>
-
-<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">;</span>
-<span class="identifier">one_of</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">isOdd</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">false</span>
-<span class="identifier">one_of</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">lessThan10</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">false</span>
-<span class="identifier">one_of</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">()</span> <span class="special">+</span> <span class="number">3</span><span class="special">,</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">lessThan10</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">one_of</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">isOdd</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">false</span> <span class="comment">// empty range</span>
-<span class="identifier">one_of_equal</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">,</span> <span class="number">3</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">one_of_equal</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">()</span> <span class="special">+</span> <span class="number">3</span><span class="special">,</span> <span class="number">3</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">false</span>
-<span class="identifier">one_of_equal</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="number">99</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">false</span> <span class="comment">// empty range</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.one_of.h2"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.one_of.iterator_requirements"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.one_of.iterator_requirements">Iterator
- Requirements</a>
- </h5>
-<p>
- <code class="computeroutput"><span class="identifier">one_of</span></code> and <code class="computeroutput"><span class="identifier">one_of_equal</span></code> work on all iterators except
- output iterators.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.one_of.h3"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.one_of.complexity"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.one_of.complexity">Complexity</a>
- </h5>
-<p>
- All of the variants of <code class="computeroutput"><span class="identifier">one_of</span></code>
- and <code class="computeroutput"><span class="identifier">one_of_equal</span></code> run in
- <span class="emphasis"><em>O(N)</em></span> (linear) time; that is, they compare against each
- element in the list once. If more than one of the elements in the sequence
- satisfy the condition, then algorithm will return false immediately, without
- examining the remaining members of the sequence.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.one_of.h4"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.one_of.exception_safety"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.one_of.exception_safety">Exception
- Safety</a>
- </h5>
-<p>
- All of the variants of <code class="computeroutput"><span class="identifier">one_of</span></code>
- and <code class="computeroutput"><span class="identifier">one_of_equal</span></code> take their
- parameters by value or const reference, and do not depend upon any global
- state. Therefore, all the routines in this file provide the strong exception
- guarantee.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.one_of.h5"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.one_of.notes"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.one_of.notes">Notes</a>
- </h5>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
- <code class="computeroutput"><span class="identifier">one_of</span></code> and <code class="computeroutput"><span class="identifier">one_of_equal</span></code> both return false for
- empty ranges, no matter what is passed to test against.
- </li>
-<li class="listitem">
- The second parameter to <code class="computeroutput"><span class="identifier">one_of_equal</span></code>
- is a template parameter, rather than deduced from the first parameter
- (<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">InputIterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code>) because that allows more
- flexibility for callers, and takes advantage of built-in comparisons
- for the type that is pointed to by the iterator. The function is defined
- to return true if, for one element in the sequence, the expression <code class="computeroutput"><span class="special">*</span><span class="identifier">iter</span> <span class="special">==</span> <span class="identifier">val</span></code>
- evaluates to true (where <code class="computeroutput"><span class="identifier">iter</span></code>
- is an iterator to each element in the sequence)
- </li>
-</ul></div>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="the_boost_algorithm_library.CXX11.is_sorted"></a><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_sorted" title="is_sorted">is_sorted
- </a>
-</h3></div></div></div>
-<p>
- The header file <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">cxx11</span><span class="special">/</span><span class="identifier">is_sorted</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
- contains functions for determining if a sequence is ordered.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.is_sorted.h0"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.is_sorted.is_sorted"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_sorted.is_sorted">is_sorted</a>
- </h5>
-<p>
- The function <code class="computeroutput"><span class="identifier">is_sorted</span><span class="special">(</span><span class="identifier">sequence</span><span class="special">)</span></code>
- determines whether or not a sequence is completely sorted according so some
- criteria. If no comparison predicate is specified, then std::less_equal is
- used (i.e, the test is to see if the sequence is non-decreasing)
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Pred</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_sorted</span> <span class="special">(</span> <span class="identifier">ForwardIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">ForwardIterator</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">Pred</span> <span class="identifier">p</span> <span class="special">);</span>
-
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">ForwardIterator</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_sorted</span> <span class="special">(</span> <span class="identifier">ForwardIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">ForwardIterator</span> <span class="identifier">last</span> <span class="special">);</span>
-
-
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Pred</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_sorted</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">Pred</span> <span class="identifier">p</span> <span class="special">);</span>
-
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_sorted</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span> <span class="special">);</span>
-<span class="special">}}</span>
-</pre>
-<p>
- </p>
-<p>
- Iterator requirements: The <code class="computeroutput"><span class="identifier">is_sorted</span></code>
- functions will work forward iterators or better.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.is_sorted.h1"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.is_sorted.is_sorted_until"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_sorted.is_sorted_until">is_sorted_until</a>
- </h5>
-<p>
- If <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">&lt;</span> <span class="number">2</span></code>, then
- <code class="computeroutput"><span class="identifier">is_sorted</span> <span class="special">(</span>
- <span class="identifier">first</span><span class="special">,</span>
- <span class="identifier">last</span> <span class="special">)</span></code>
- returns <code class="computeroutput"><span class="identifier">last</span></code>. Otherwise,
- it returns the last iterator i in [first,last] for which the range [first,i)
- is sorted.
- </p>
-<p>
- In short, it returns the element in the sequence that is "out of order".
- If the entire sequence is sorted (according to the predicate), then it will
- return <code class="computeroutput"><span class="identifier">last</span></code>.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Pred</span><span class="special">&gt;</span>
- <span class="identifier">FI</span> <span class="identifier">is_sorted_until</span> <span class="special">(</span> <span class="identifier">ForwardIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">ForwardIterator</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">Pred</span> <span class="identifier">p</span> <span class="special">);</span>
-
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">ForwardIterator</span><span class="special">&gt;</span>
- <span class="identifier">ForwardIterator</span> <span class="identifier">is_sorted_until</span> <span class="special">(</span> <span class="identifier">ForwardIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">ForwardIterator</span> <span class="identifier">last</span> <span class="special">);</span>
-
-
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Pred</span><span class="special">&gt;</span>
- <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">R</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">is_sorted_until</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">Pred</span> <span class="identifier">p</span> <span class="special">);</span>
-
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">&gt;</span>
- <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">R</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">is_sorted_until</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span> <span class="special">);</span>
-<span class="special">}}</span>
-</pre>
-<p>
- </p>
-<p>
- Iterator requirements: The <code class="computeroutput"><span class="identifier">is_sorted_until</span></code>
- functions will work on forward iterators or better. Since they have to return
- a place in the input sequence, input iterators will not suffice.
- </p>
-<p>
- Complexity: <code class="computeroutput"><span class="identifier">is_sorted_until</span></code>
- will make at most <span class="emphasis"><em>N-1</em></span> calls to the predicate (given
- a sequence of length <span class="emphasis"><em>N</em></span>).
- </p>
-<p>
- Examples:
- </p>
-<p>
- Given the sequence <code class="computeroutput"><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">3</span><span class="special">,</span> <span class="number">4</span><span class="special">,</span> <span class="number">5</span><span class="special">,</span> <span class="number">3</span> <span class="special">}</span></code>,
- <code class="computeroutput"><span class="identifier">is_sorted_until</span> <span class="special">(</span>
- <span class="identifier">beg</span><span class="special">,</span>
- <span class="identifier">end</span><span class="special">,</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;())</span></code>
- would return an iterator pointing at the second <code class="computeroutput"><span class="number">3</span></code>.
- </p>
-<p>
- Given the sequence <code class="computeroutput"><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">3</span><span class="special">,</span> <span class="number">4</span><span class="special">,</span> <span class="number">5</span><span class="special">,</span> <span class="number">9</span> <span class="special">}</span></code>,
- <code class="computeroutput"><span class="identifier">is_sorted_until</span> <span class="special">(</span>
- <span class="identifier">beg</span><span class="special">,</span>
- <span class="identifier">end</span><span class="special">,</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;())</span></code>
- would return <code class="computeroutput"><span class="identifier">end</span></code>.
- </p>
-<p>
- There are also a set of "wrapper functions" for is_ordered which
- make it easy to see if an entire sequence is ordered. These functions return
- a boolean indicating success or failure rather than an iterator to where
- the out of order items were found.
- </p>
-<p>
- To test if a sequence is increasing (each element at least as large as the
- preceding one):
-</p>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Iterator</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_increasing</span> <span class="special">(</span> <span class="identifier">Iterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">Iterator</span> <span class="identifier">last</span> <span class="special">);</span>
-
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_increasing</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">R</span> <span class="special">&amp;</span><span class="identifier">range</span> <span class="special">);</span>
-<span class="special">}}</span>
-</pre>
-<p>
- </p>
-<p>
- To test if a sequence is decreasing (each element no larger than the preceding
- one):
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">ForwardIterator</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_decreasing</span> <span class="special">(</span> <span class="identifier">ForwardIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">ForwardIterator</span> <span class="identifier">last</span> <span class="special">);</span>
-
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_decreasing</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">R</span> <span class="special">&amp;</span><span class="identifier">range</span> <span class="special">);</span>
-<span class="special">}}</span>
-</pre>
-<p>
- </p>
-<p>
- To test if a sequence is strictly increasing (each element larger than the
- preceding one):
-</p>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">ForwardIterator</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_strictly_increasing</span> <span class="special">(</span> <span class="identifier">ForwardIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">ForwardIterator</span> <span class="identifier">last</span> <span class="special">);</span>
-
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_strictly_increasing</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">R</span> <span class="special">&amp;</span><span class="identifier">range</span> <span class="special">);</span>
-<span class="special">}}</span>
-</pre>
-<p>
- </p>
-<p>
- To test if a sequence is strictly decreasing (each element smaller than the
- preceding one):
-</p>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">ForwardIterator</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_strictly_decreasing</span> <span class="special">(</span> <span class="identifier">ForwardIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">ForwardIterator</span> <span class="identifier">last</span> <span class="special">);</span>
-
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">R</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_strictly_decreasing</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">R</span> <span class="special">&amp;</span><span class="identifier">range</span> <span class="special">);</span>
-<span class="special">}}</span>
-</pre>
-<p>
- </p>
-<p>
- Complexity: Each of these calls is just a thin wrapper over <code class="computeroutput"><span class="identifier">is_sorted</span></code>, so they have the same complexity
- as <code class="computeroutput"><span class="identifier">is_sorted</span></code>.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.is_sorted.h2"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.is_sorted.notes"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_sorted.notes">Notes</a>
- </h5>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
- The routines <code class="computeroutput"><span class="identifier">is_sorted</span></code>
- and <code class="computeroutput"><span class="identifier">is_sorted_until</span></code> are
- part of the C++11 standard. When compiled using a C++11 implementation,
- the implementation from the standard library will be used.
- </li>
-<li class="listitem">
- <code class="computeroutput"><span class="identifier">is_sorted</span></code> and <code class="computeroutput"><span class="identifier">is_sorted_until</span></code> both return true for
- empty ranges and ranges of length one.
- </li>
-</ul></div>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="the_boost_algorithm_library.CXX11.is_partitioned"></a><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_partitioned" title="is_partitioned">is_partitioned
- </a>
-</h3></div></div></div>
-<p>
- The header file 'is_partitioned.hpp' contains two variants of a single algorithm,
- <code class="computeroutput"><span class="identifier">is_partitioned</span></code>. The algorithm
- tests to see if a sequence is partitioned according to a predicate; in other
- words, all the items in the sequence that satisfy the predicate are at the
- beginning of the sequence.
- </p>
-<p>
- The routine <code class="computeroutput"><span class="identifier">is_partitioned</span></code>
- takes a sequence and a predicate. It returns true if the sequence is partitioned
- according to the predicate.
- </p>
-<p>
- <code class="computeroutput"><span class="identifier">is_partitioned</span></code> come in two
- forms; the first one takes two iterators to define the range. The second
- form takes a single range parameter, and uses Boost.Range to traverse it.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.is_partitioned.h0"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.is_partitioned.interface"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_partitioned.interface">interface</a>
- </h5>
-<p>
- The function <code class="computeroutput"><span class="identifier">is_partitioned</span></code>
- returns true if the items in the sequence are separated according to their
- ability to satisfy the predicate. There are two versions; one takes two iterators,
- and the other takes a range.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_partitioned</span> <span class="special">(</span> <span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">Predicate</span> <span class="identifier">p</span> <span class="special">);</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_partitioned</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">Predicate</span> <span class="identifier">p</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.is_partitioned.h1"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.is_partitioned.examples"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_partitioned.examples">Examples</a>
- </h5>
-<p>
- Given the container <code class="computeroutput"><span class="identifier">c</span></code> containing
- <code class="computeroutput"><span class="special">{</span> <span class="number">0</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">3</span><span class="special">,</span> <span class="number">14</span><span class="special">,</span> <span class="number">15</span> <span class="special">}</span></code>,
- then
-</p>
-<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">isOdd</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">i</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="keyword">bool</span> <span class="identifier">lessThan10</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">}</span>
-
-<span class="identifier">is_partitioned</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">isOdd</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">false</span>
-<span class="identifier">is_partitioned</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">lessThan10</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">is_partitioned</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">lessThan10</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">is_partitioned</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">()</span> <span class="special">+</span> <span class="number">3</span><span class="special">,</span> <span class="identifier">lessThan10</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">is_partitioned</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">isOdd</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span> <span class="comment">// empty range</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.is_partitioned.h2"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.is_partitioned.iterator_requirements"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_partitioned.iterator_requirements">Iterator
- Requirements</a>
- </h5>
-<p>
- <code class="computeroutput"><span class="identifier">is_partitioned</span></code> works on all
- iterators except output iterators.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.is_partitioned.h3"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.is_partitioned.complexity"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_partitioned.complexity">Complexity</a>
- </h5>
-<p>
- Both of the variants of <code class="computeroutput"><span class="identifier">is_partitioned</span></code>
- run in <span class="emphasis"><em>O(N)</em></span> (linear) time; that is, they compare against
- each element in the list once. If the sequence is found to be not partitioned
- at any point, the routine will terminate immediately, without examining the
- rest of the elements.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.is_partitioned.h4"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.is_partitioned.exception_safety"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_partitioned.exception_safety">Exception
- Safety</a>
- </h5>
-<p>
- Both of the variants of <code class="computeroutput"><span class="identifier">is_partitioned</span></code>
- take their parameters by value or const reference, and do not depend upon
- any global state. Therefore, all the routines in this file provide the strong
- exception guarantee.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.is_partitioned.h5"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.is_partitioned.notes"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_partitioned.notes">Notes</a>
- </h5>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
- The iterator-based version of the routine <code class="computeroutput"><span class="identifier">is_partitioned</span></code>
- is also available as part of the C++11 standard.
- </li>
-<li class="listitem">
- <code class="computeroutput"><span class="identifier">is_partitioned</span></code> returns
- true for empty ranges, no matter what predicate is passed to test against.
- </li>
-</ul></div>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="the_boost_algorithm_library.CXX11.is_permutation"></a><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_permutation" title="is_permutation">is_permutation
- </a>
-</h3></div></div></div>
-<p>
- The header file 'is_permutation.hpp' contains six variants of a single algorithm,
- <code class="computeroutput"><span class="identifier">is_permutation</span></code>. The algorithm
- tests to see if one sequence is a permutation of a second one; in other words,
- it contains all the same members, possibly in a different order.
- </p>
-<p>
- The routine <code class="computeroutput"><span class="identifier">is_permutation</span></code>
- takes two sequences and an (optional) predicate. It returns true if the two
- sequences contain the same members. If it is passed a predicate, it uses
- the predicate to compare the elements of the sequence to see if they are
- the same.
- </p>
-<p>
- <code class="computeroutput"><span class="identifier">is_permutation</span></code> come in three
- forms. The first one takes two iterators to define the first range, and the
- starting iterator of the second range. The second form takes a two iterators
- to define the first range and two more to define the second range. The third
- form takes a single range parameter, and uses Boost.Range to traverse it.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.is_permutation.h0"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.is_permutation.interface"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_permutation.interface">Interface</a>
- </h5>
-<p>
- The function <code class="computeroutput"><span class="identifier">is_permutation</span></code>
- returns true if the two input sequences contain the same elements. There
- are six versions; two take three iterators, two take four iterators, and
- the other two take two ranges.
- </p>
-<p>
- In general, you should prefer the four iterator versions over the three iterator
- ones. The three iterator version has to "create" the fourth iterator
- internally by calling <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">advance</span><span class="special">(</span><span class="identifier">first2</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first1</span><span class="special">,</span><span class="identifier">last1</span><span class="special">))</span></code>,
- and if the second sequence is shorter than the first, that's undefined behavior.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">ForwardIterator1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ForwardIterator2</span> <span class="special">&gt;</span>
-<span class="keyword">bool</span> <span class="identifier">is_permutation</span> <span class="special">(</span> <span class="identifier">ForwardIterator1</span> <span class="identifier">first1</span><span class="special">,</span> <span class="identifier">ForwardIterator1</span> <span class="identifier">last1</span><span class="special">,</span> <span class="identifier">ForwardIterator2</span> <span class="identifier">first2</span> <span class="special">);</span>
-
-<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">ForwardIterator1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ForwardIterator2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BinaryPredicate</span> <span class="special">&gt;</span>
-<span class="keyword">bool</span> <span class="identifier">is_permutation</span> <span class="special">(</span> <span class="identifier">ForwardIterator1</span> <span class="identifier">first1</span><span class="special">,</span> <span class="identifier">ForwardIterator1</span> <span class="identifier">last1</span><span class="special">,</span>
- <span class="identifier">ForwardIterator2</span> <span class="identifier">first2</span><span class="special">,</span> <span class="identifier">BinaryPredicate</span> <span class="identifier">p</span> <span class="special">);</span>
-
-
-<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">ForwardIterator1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ForwardIterator2</span> <span class="special">&gt;</span>
-<span class="keyword">bool</span> <span class="identifier">is_permutation</span> <span class="special">(</span> <span class="identifier">ForwardIterator1</span> <span class="identifier">first1</span><span class="special">,</span> <span class="identifier">ForwardIterator1</span> <span class="identifier">last1</span><span class="special">,</span> <span class="identifier">ForwardIterator2</span> <span class="identifier">first2</span><span class="special">,</span> <span class="identifier">ForwardIterator2</span> <span class="identifier">last2</span> <span class="special">);</span>
-
-<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">ForwardIterator1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ForwardIterator2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BinaryPredicate</span> <span class="special">&gt;</span>
-<span class="keyword">bool</span> <span class="identifier">is_permutation</span> <span class="special">(</span> <span class="identifier">ForwardIterator1</span> <span class="identifier">first1</span><span class="special">,</span> <span class="identifier">ForwardIterator1</span> <span class="identifier">last1</span><span class="special">,</span>
- <span class="identifier">ForwardIterator2</span> <span class="identifier">first2</span><span class="special">,</span> <span class="identifier">ForwardIterator2</span> <span class="identifier">last2</span><span class="special">,</span>
- <span class="identifier">BinaryPredicate</span> <span class="identifier">p</span> <span class="special">);</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">ForwardIterator</span><span class="special">&gt;</span>
-<span class="keyword">bool</span> <span class="identifier">is_permutation</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">ForwardIterator</span> <span class="identifier">first2</span> <span class="special">);</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">BinaryPredicate</span><span class="special">&gt;</span>
-<span class="keyword">bool</span> <span class="identifier">is_permutation</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">ForwardIterator</span> <span class="identifier">first2</span><span class="special">,</span> <span class="identifier">BinaryPredicate</span> <span class="identifier">pred</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.is_permutation.h1"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.is_permutation.examples"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_permutation.examples">Examples</a>
- </h5>
-<p>
- Given the container <code class="computeroutput"><span class="identifier">c1</span></code> containing
- <code class="computeroutput"><span class="special">{</span> <span class="number">0</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">3</span><span class="special">,</span> <span class="number">14</span><span class="special">,</span> <span class="number">15</span> <span class="special">}</span></code>,
- and <code class="computeroutput"><span class="identifier">c2</span></code> containing <code class="computeroutput"><span class="special">{</span> <span class="number">15</span><span class="special">,</span>
- <span class="number">14</span><span class="special">,</span> <span class="number">3</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">2</span> <span class="special">}</span></code>,
- then
-</p>
-<pre class="programlisting"><span class="identifier">is_permutation</span> <span class="special">(</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">end</span> <span class="special">())</span> <span class="special">--&gt;</span> <span class="keyword">false</span>
-<span class="identifier">is_permutation</span> <span class="special">(</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">end</span> <span class="special">())</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-
-<span class="identifier">is_permutation</span> <span class="special">(</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">end</span> <span class="special">())</span> <span class="special">--&gt;</span> <span class="keyword">true</span> <span class="comment">// all empty ranges are permutations of each other</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.is_permutation.h2"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.is_permutation.iterator_requirements"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_permutation.iterator_requirements">Iterator
- Requirements</a>
- </h5>
-<p>
- <code class="computeroutput"><span class="identifier">is_permutation</span></code> works on forward
- iterators or better.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.is_permutation.h3"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.is_permutation.complexity"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_permutation.complexity">Complexity</a>
- </h5>
-<p>
- All of the variants of <code class="computeroutput"><span class="identifier">is_permutation</span></code>
- run in <span class="emphasis"><em>O(N^2)</em></span> (quadratic) time; that is, they compare
- against each element in the list (potentially) N times. If passed random-access
- iterators, <code class="computeroutput"><span class="identifier">is_permutation</span></code>
- can return quickly if the sequences are different sizes.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.is_permutation.h4"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.is_permutation.exception_safety"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_permutation.exception_safety">Exception
- Safety</a>
- </h5>
-<p>
- All of the variants of <code class="computeroutput"><span class="identifier">is_permutation</span></code>
- take their parameters by value, and do not depend upon any global state.
- Therefore, all the routines in this file provide the strong exception guarantee.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.is_permutation.h5"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.is_permutation.notes"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.is_permutation.notes">Notes</a>
- </h5>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
- The three iterator versions of the routine <code class="computeroutput"><span class="identifier">is_permutation</span></code>
- are also available as part of the C++11 standard.
- </li>
-<li class="listitem">
- The four iterator versions of the routine <code class="computeroutput"><span class="identifier">is_permutation</span></code>
- are part of the proposed C++14 standard. When C++14 standard libraries
- become available, the implementation should be changed to use the implementation
- from the standard library (if available).
- </li>
-<li class="listitem">
- <code class="computeroutput"><span class="identifier">is_permutation</span></code> returns
- true when passed a pair of empty ranges, no matter what predicate is
- passed to test with.
- </li>
-</ul></div>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="the_boost_algorithm_library.CXX11.partition_point"></a><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.partition_point" title="partition_point">partition_point
- </a>
-</h3></div></div></div>
-<p>
- The header file 'partition_point.hpp' contains two variants of a single algorithm,
- <code class="computeroutput"><span class="identifier">partition_point</span></code>. Given a
- partitioned sequence and a predicate, the algorithm finds the partition point;
- i.e, the first element in the sequence that does not satisfy the predicate.
- </p>
-<p>
- The routine <code class="computeroutput"><span class="identifier">partition_point</span></code>
- takes a partitioned sequence and a predicate. It returns an iterator which
- 'points to' the first element in the sequence that does not satisfy the predicate.
- If all the items in the sequence satisfy the predicate, then it returns one
- past the final element in the sequence.
- </p>
-<p>
- <code class="computeroutput"><span class="identifier">partition_point</span></code> come in two
- forms; the first one takes two iterators to define the range. The second
- form takes a single range parameter, and uses Boost.Range to traverse it.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.partition_point.h0"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.partition_point.interface"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.partition_point.interface">interface</a>
- </h5>
-<p>
- There are two versions; one takes two iterators, and the other takes a range.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span>
- <span class="identifier">ForwardIterator</span> <span class="identifier">partition_point</span> <span class="special">(</span> <span class="identifier">ForwardIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">ForwardIterator</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">Predicate</span> <span class="identifier">p</span> <span class="special">);</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">Range</span><span class="special">&gt;</span> <span class="identifier">partition_point</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">Predicate</span> <span class="identifier">p</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.partition_point.h1"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.partition_point.examples"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.partition_point.examples">Examples</a>
- </h5>
-<p>
- Given the container <code class="computeroutput"><span class="identifier">c</span></code> containing
- <code class="computeroutput"><span class="special">{</span> <span class="number">0</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">3</span><span class="special">,</span> <span class="number">14</span><span class="special">,</span> <span class="number">15</span> <span class="special">}</span></code>,
- then
-</p>
-<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">lessThan10</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">}</span>
-<span class="keyword">bool</span> <span class="identifier">isOdd</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">i</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="identifier">partition_point</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">lessThan10</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">()</span> <span class="special">+</span> <span class="number">4</span> <span class="special">(</span><span class="identifier">pointing</span> <span class="identifier">at</span> <span class="number">14</span><span class="special">)</span>
-<span class="identifier">partition_point</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">lessThan10</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">()</span> <span class="special">+</span> <span class="number">4</span> <span class="special">(</span><span class="identifier">pointing</span> <span class="identifier">at</span> <span class="number">14</span><span class="special">)</span>
-<span class="identifier">partition_point</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">()</span> <span class="special">+</span> <span class="number">3</span><span class="special">,</span> <span class="identifier">lessThan10</span> <span class="special">)</span> <span class="special">-&gt;</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">()</span> <span class="special">+</span> <span class="number">3</span> <span class="special">(</span><span class="identifier">end</span><span class="special">)</span>
-<span class="identifier">partition_point</span> <span class="special">(</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">isOdd</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span> <span class="special">()</span> <span class="comment">// empty range</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.partition_point.h2"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.partition_point.iterator_requirements"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.partition_point.iterator_requirements">Iterator
- Requirements</a>
- </h5>
-<p>
- <code class="computeroutput"><span class="identifier">partition_point</span></code> requires
- forward iterators or better; it will not work on input iterators or output
- iterators.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.partition_point.h3"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.partition_point.complexity"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.partition_point.complexity">Complexity</a>
- </h5>
-<p>
- Both of the variants of <code class="computeroutput"><span class="identifier">partition_point</span></code>
- run in <span class="emphasis"><em>O( log (N))</em></span> (logarithmic) time; that is, the
- predicate will be will be applied approximately <span class="emphasis"><em>log(N)</em></span>
- times. To do this, however, the algorithm needs to know the size of the sequence.
- For forward and bidirectional iterators, calculating the size of the sequence
- is an <span class="emphasis"><em>O(N)</em></span> operation.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.partition_point.h4"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.partition_point.exception_safety"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.partition_point.exception_safety">Exception
- Safety</a>
- </h5>
-<p>
- Both of the variants of <code class="computeroutput"><span class="identifier">partition_point</span></code>
- take their parameters by value or const reference, and do not depend upon
- any global state. Therefore, all the routines in this file provide the strong
- exception guarantee.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX11.partition_point.h5"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX11.partition_point.notes"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.partition_point.notes">Notes</a>
- </h5>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
- The iterator-based version of the routine <code class="computeroutput"><span class="identifier">partition_point</span></code>
- is also available as part of the C++11 standard.
- </li>
-<li class="listitem">
- For empty ranges, the partition point is the end of the range.
- </li>
-</ul></div>
-</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; 2010-2012 Marshall Clow<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="Searching.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../algorithm.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="CXX14.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>
diff --git a/doc/html/algorithm/CXX14.html b/doc/html/algorithm/CXX14.html
deleted file mode 100644
index 8d97909002..0000000000
--- a/doc/html/algorithm/CXX14.html
+++ /dev/null
@@ -1,321 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>C++14 Algorithms</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="The Boost C++ Libraries BoostBook Documentation Subset">
-<link rel="up" href="../algorithm.html" title="Chapter&#160;3.&#160;The Boost Algorithm Library">
-<link rel="prev" href="CXX11.html" title="C++11 Algorithms">
-<link rel="next" href="Misc.html" title="Other Algorithms">
-</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="../../../libs/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="CXX11.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../algorithm.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="Misc.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="algorithm.CXX14"></a><a class="link" href="CXX14.html" title="C++14 Algorithms">C++14 Algorithms</a>
-</h2></div></div></div>
-<div class="toc"><dl class="toc">
-<dt><span class="section"><a href="CXX14.html#the_boost_algorithm_library.CXX14.equal">equal </a></span></dt>
-<dt><span class="section"><a href="CXX14.html#the_boost_algorithm_library.CXX14.mismatch">mismatch
- </a></span></dt>
-</dl></div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="the_boost_algorithm_library.CXX14.equal"></a><a class="link" href="CXX14.html#the_boost_algorithm_library.CXX14.equal" title="equal">equal </a>
-</h3></div></div></div>
-<p>
- The header file 'equal.hpp' contains two variants of a the stl algorithm
- <code class="computeroutput"><span class="identifier">equal</span></code>. The algorithm tests
- to see if two sequences contain equal values;
- </p>
-<p>
- Before (the proposed) C++14 the algorithm <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">equal</span></code>
- took three iterators and an optional comparison predicate. The first two
- iterators <code class="computeroutput"><span class="special">[</span><span class="identifier">first1</span><span class="special">,</span> <span class="identifier">last1</span><span class="special">)</span></code> defined a sequence, and the second one
- <code class="computeroutput"><span class="identifier">first2</span></code> defined the start
- of the second sequence. The second sequence was assumed to be the same length
- as the first.
- </p>
-<p>
- In C++14, two new variants were introduced, taking four iterators and an
- optional comparison predicate. The four iterators define two sequences <code class="computeroutput"><span class="special">[</span><span class="identifier">first1</span><span class="special">,</span> <span class="identifier">last1</span><span class="special">)</span></code> and <code class="computeroutput"><span class="special">[</span><span class="identifier">first2</span><span class="special">,</span> <span class="identifier">last2</span><span class="special">)</span></code>
- explicitly, rather than defining the second one implicitly. This leads to
- correct answers in more cases (and avoid undefined behavior in others).
- </p>
-<p>
- Consider the two sequences:
-</p>
-<pre class="programlisting"><span class="keyword">auto</span> <span class="identifier">seq1</span> <span class="special">=</span> <span class="special">{</span> <span class="number">0</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="keyword">auto</span> <span class="identifier">seq2</span> <span class="special">=</span> <span class="special">{</span> <span class="number">0</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">3</span><span class="special">,</span> <span class="number">4</span> <span class="special">};</span>
-
-<span class="identifier">std</span><span class="special">::</span><span class="identifier">equal</span> <span class="special">(</span> <span class="identifier">seq1</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">seq1</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">seq2</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">());</span> <span class="comment">// true</span>
-<span class="identifier">std</span><span class="special">::</span><span class="identifier">equal</span> <span class="special">(</span> <span class="identifier">seq2</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">seq2</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">seq1</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">());</span> <span class="comment">// Undefined behavior</span>
-<span class="identifier">std</span><span class="special">::</span><span class="identifier">equal</span> <span class="special">(</span> <span class="identifier">seq1</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">seq1</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">seq2</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">seq2</span><span class="special">.</span><span class="identifier">end</span> <span class="special">());</span> <span class="comment">// false</span>
-</pre>
-<p>
- </p>
-<p>
- You can argue that <code class="computeroutput"><span class="keyword">true</span></code> is the
- correct answer in the first case, even though the sequences are not the same.
- The first N entries in <code class="computeroutput"><span class="identifier">seq2</span></code>
- are the same as the entries in <code class="computeroutput"><span class="identifier">seq1</span></code>
- - but that's not all that's in <code class="computeroutput"><span class="identifier">seq2</span></code>.
- But in the second case, the algorithm will read past the end of <code class="computeroutput"><span class="identifier">seq1</span></code>, resulting in undefined behavior (large
- earthquake, incorrect results, pregnant cat, etc).
- </p>
-<p>
- However, if the two sequences are specified completely, it's clear that they
- are not equal.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX14.equal.h0"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX14.equal.interface"></a></span><a class="link" href="CXX14.html#the_boost_algorithm_library.CXX14.equal.interface">interface</a>
- </h5>
-<p>
- The function <code class="computeroutput"><span class="identifier">equal</span></code> returns
- true if the two sequences compare equal; i.e, if each element in the sequence
- compares equal to the corresponding element in the other sequence. One version
- uses <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span></code> to do the comparison; the other
- lets the caller pass predicate to do the comparisons.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputIterator1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">InputIterator2</span><span class="special">&gt;</span>
-<span class="keyword">bool</span> <span class="identifier">equal</span> <span class="special">(</span> <span class="identifier">InputIterator1</span> <span class="identifier">first1</span><span class="special">,</span> <span class="identifier">InputIterator1</span> <span class="identifier">last1</span><span class="special">,</span>
- <span class="identifier">InputIterator2</span> <span class="identifier">first2</span><span class="special">,</span> <span class="identifier">InputIterator2</span> <span class="identifier">last2</span> <span class="special">);</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputIterator1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">InputIterator2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BinaryPredicate</span><span class="special">&gt;</span>
-<span class="keyword">bool</span> <span class="identifier">equal</span> <span class="special">(</span> <span class="identifier">InputIterator1</span> <span class="identifier">first1</span><span class="special">,</span> <span class="identifier">InputIterator1</span> <span class="identifier">last1</span><span class="special">,</span>
- <span class="identifier">InputIterator2</span> <span class="identifier">first2</span><span class="special">,</span> <span class="identifier">InputIterator2</span> <span class="identifier">last2</span><span class="special">,</span> <span class="identifier">BinaryPredicate</span> <span class="identifier">pred</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX14.equal.h1"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX14.equal.examples"></a></span><a class="link" href="CXX14.html#the_boost_algorithm_library.CXX14.equal.examples">Examples</a>
- </h5>
-<p>
- Given the container <code class="computeroutput"><span class="identifier">c1</span></code> containing
- <code class="computeroutput"><span class="special">{</span> <span class="number">0</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">3</span><span class="special">,</span> <span class="number">14</span><span class="special">,</span> <span class="number">15</span> <span class="special">}</span></code>,
- and <code class="computeroutput"><span class="identifier">c2</span></code> containing <code class="computeroutput"><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">3</span> <span class="special">}</span></code>, then
-</p>
-<pre class="programlisting"><span class="identifier">equal</span> <span class="special">(</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">end</span> <span class="special">())</span> <span class="special">--&gt;</span> <span class="keyword">false</span>
-<span class="identifier">equal</span> <span class="special">(</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">()</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">()</span> <span class="special">+</span> <span class="number">3</span><span class="special">,</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">end</span> <span class="special">())</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">equal</span> <span class="special">(</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">end</span> <span class="special">())</span> <span class="special">--&gt;</span> <span class="keyword">true</span> <span class="comment">// empty sequences are alway equal to each other</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX14.equal.h2"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX14.equal.iterator_requirements"></a></span><a class="link" href="CXX14.html#the_boost_algorithm_library.CXX14.equal.iterator_requirements">Iterator
- Requirements</a>
- </h5>
-<p>
- <code class="computeroutput"><span class="identifier">equal</span></code> works on all iterators
- except output iterators.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX14.equal.h3"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX14.equal.complexity"></a></span><a class="link" href="CXX14.html#the_boost_algorithm_library.CXX14.equal.complexity">Complexity</a>
- </h5>
-<p>
- Both of the variants of <code class="computeroutput"><span class="identifier">equal</span></code>
- run in <span class="emphasis"><em>O(N)</em></span> (linear) time; that is, they compare against
- each element in the list once. If the sequence is found to be not equal at
- any point, the routine will terminate immediately, without examining the
- rest of the elements.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX14.equal.h4"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX14.equal.exception_safety"></a></span><a class="link" href="CXX14.html#the_boost_algorithm_library.CXX14.equal.exception_safety">Exception
- Safety</a>
- </h5>
-<p>
- Both of the variants of <code class="computeroutput"><span class="identifier">equal</span></code>
- take their parameters by value and do not depend upon any global state. Therefore,
- all the routines in this file provide the strong exception guarantee.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX14.equal.h5"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX14.equal.notes"></a></span><a class="link" href="CXX14.html#the_boost_algorithm_library.CXX14.equal.notes">Notes</a>
- </h5>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
- The four iterator version of the routine <code class="computeroutput"><span class="identifier">equal</span></code>
- is part of the C++14 standard. When C++14 standard library implementations
- become available, the implementation from the standard library should
- be used.
- </li>
-<li class="listitem">
- <code class="computeroutput"><span class="identifier">equal</span></code> returns true for
- two empty ranges, no matter what predicate is passed to test against.
- </li>
-</ul></div>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="the_boost_algorithm_library.CXX14.mismatch"></a><a class="link" href="CXX14.html#the_boost_algorithm_library.CXX14.mismatch" title="mismatch">mismatch
- </a>
-</h3></div></div></div>
-<p>
- The header file 'mismatch.hpp' contains two variants of a the stl algorithm
- <code class="computeroutput"><span class="identifier">mismatch</span></code>. The algorithm finds
- the first point in two sequences where they do not match.
- </p>
-<p>
- Before (the proposed) C++14 the algorithm <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">mismatch</span></code>
- took three iterators and an optional comparison predicate. The first two
- iterators <code class="computeroutput"><span class="special">[</span><span class="identifier">first1</span><span class="special">,</span> <span class="identifier">last1</span><span class="special">)</span></code> defined a sequence, and the second one
- <code class="computeroutput"><span class="identifier">first2</span></code> defined the start
- of the second sequence. The second sequence was assumed to be the same length
- as the first.
- </p>
-<p>
- In C++14, two new variants were introduced, taking four iterators and an
- optional comparison predicate. The four iterators define two sequences <code class="computeroutput"><span class="special">[</span><span class="identifier">first1</span><span class="special">,</span> <span class="identifier">last1</span><span class="special">)</span></code> and <code class="computeroutput"><span class="special">[</span><span class="identifier">first2</span><span class="special">,</span> <span class="identifier">last2</span><span class="special">)</span></code>
- explicitly, rather than defining the second one implicitly. This leads to
- correct answers in more cases (and avoid undefined behavior in others).
- </p>
-<p>
- Consider the two sequences:
-</p>
-<pre class="programlisting"><span class="keyword">auto</span> <span class="identifier">seq1</span> <span class="special">=</span> <span class="special">{</span> <span class="number">0</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="keyword">auto</span> <span class="identifier">seq2</span> <span class="special">=</span> <span class="special">{</span> <span class="number">0</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">3</span><span class="special">,</span> <span class="number">4</span> <span class="special">};</span>
-
-<span class="identifier">std</span><span class="special">::</span><span class="identifier">mismatch</span> <span class="special">(</span> <span class="identifier">seq1</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">seq1</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">seq2</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">());</span> <span class="comment">// &lt;3, 3&gt;</span>
-<span class="identifier">std</span><span class="special">::</span><span class="identifier">mismatch</span> <span class="special">(</span> <span class="identifier">seq2</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">seq2</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">seq1</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">());</span> <span class="comment">// Undefined behavior</span>
-<span class="identifier">std</span><span class="special">::</span><span class="identifier">mismatch</span> <span class="special">(</span> <span class="identifier">seq1</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">seq1</span><span class="special">.</span><span class="identifier">end</span> <span class="special">(),</span> <span class="identifier">seq2</span><span class="special">.</span><span class="identifier">begin</span> <span class="special">(),</span> <span class="identifier">seq2</span><span class="special">.</span><span class="identifier">end</span> <span class="special">());</span> <span class="comment">// &lt;3, 3&gt;</span>
-</pre>
-<p>
- </p>
-<p>
- The first N entries in <code class="computeroutput"><span class="identifier">seq2</span></code>
- are the same as the entries in <code class="computeroutput"><span class="identifier">seq1</span></code>
- - but that's not all that's in <code class="computeroutput"><span class="identifier">seq2</span></code>.
- In the second case, the algorithm will read past the end of <code class="computeroutput"><span class="identifier">seq1</span></code>, resulting in undefined behavior (large
- earthquake, incorrect results, pregnant cat, etc).
- </p>
-<p>
- However, if the two sequences are specified completely, it's clear that where
- the mismatch occurs.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX14.mismatch.h0"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX14.mismatch.interface"></a></span><a class="link" href="CXX14.html#the_boost_algorithm_library.CXX14.mismatch.interface">interface</a>
- </h5>
-<p>
- The function <code class="computeroutput"><span class="identifier">mismatch</span></code> returns
- a pair of iterators which denote the first mismatching elements in each sequence.
- If the sequences match completely, <code class="computeroutput"><span class="identifier">mismatch</span></code>
- returns their end iterators. One version uses <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span></code>
- to do the comparison; the other lets the caller pass predicate to do the
- comparisons.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputIterator1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">InputIterator2</span><span class="special">&gt;</span>
-<span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">InputIterator1</span><span class="special">,</span> <span class="identifier">InputIterator2</span><span class="special">&gt;</span>
-<span class="identifier">mismatch</span> <span class="special">(</span> <span class="identifier">InputIterator1</span> <span class="identifier">first1</span><span class="special">,</span> <span class="identifier">InputIterator1</span> <span class="identifier">last1</span><span class="special">,</span>
- <span class="identifier">InputIterator2</span> <span class="identifier">first2</span><span class="special">,</span> <span class="identifier">InputIterator2</span> <span class="identifier">last2</span> <span class="special">);</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputIterator1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">InputIterator2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BinaryPredicate</span><span class="special">&gt;</span>
-<span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">InputIterator1</span><span class="special">,</span> <span class="identifier">InputIterator2</span><span class="special">&gt;</span>
-<span class="identifier">mismatch</span> <span class="special">(</span> <span class="identifier">InputIterator1</span> <span class="identifier">first1</span><span class="special">,</span> <span class="identifier">InputIterator1</span> <span class="identifier">last1</span><span class="special">,</span>
- <span class="identifier">InputIterator2</span> <span class="identifier">first2</span><span class="special">,</span> <span class="identifier">InputIterator2</span> <span class="identifier">last2</span><span class="special">,</span> <span class="identifier">BinaryPredicate</span> <span class="identifier">pred</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX14.mismatch.h1"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX14.mismatch.examples"></a></span><a class="link" href="CXX14.html#the_boost_algorithm_library.CXX14.mismatch.examples">Examples</a>
- </h5>
-<p>
- Given the container <code class="computeroutput"><span class="identifier">c1</span></code> containing
- <code class="computeroutput"><span class="special">{</span> <span class="number">0</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">3</span><span class="special">,</span> <span class="number">14</span><span class="special">,</span> <span class="number">15</span> <span class="special">}</span></code>,
- and <code class="computeroutput"><span class="identifier">c2</span></code> containing <code class="computeroutput"><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">3</span> <span class="special">}</span></code>, then
-</p>
-<pre class="programlisting"><span class="identifier">mismatch</span> <span class="special">(</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">end</span><span class="special">())</span> <span class="special">--&gt;</span> <span class="special">&lt;</span><span class="identifier">c1</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()&gt;</span> <span class="comment">// first elements do not match</span>
-<span class="identifier">mismatch</span> <span class="special">(</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="number">4</span><span class="special">,</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">end</span><span class="special">())</span> <span class="special">--&gt;</span> <span class="special">&lt;</span><span class="identifier">c1</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="number">4</span><span class="special">,</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">end</span> <span class="special">()&gt;</span> <span class="comment">// all elements of `c2` match</span>
-<span class="identifier">mismatch</span> <span class="special">(</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">c1</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">end</span><span class="special">())</span> <span class="special">--&gt;</span> <span class="special">&lt;</span><span class="identifier">c1</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">c2</span><span class="special">.</span><span class="identifier">end</span><span class="special">()&gt;</span> <span class="comment">// empty sequences don't match at the end.</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX14.mismatch.h2"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX14.mismatch.iterator_requirements"></a></span><a class="link" href="CXX14.html#the_boost_algorithm_library.CXX14.mismatch.iterator_requirements">Iterator
- Requirements</a>
- </h5>
-<p>
- <code class="computeroutput"><span class="identifier">mismatch</span></code> works on all iterators
- except output iterators.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX14.mismatch.h3"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX14.mismatch.complexity"></a></span><a class="link" href="CXX14.html#the_boost_algorithm_library.CXX14.mismatch.complexity">Complexity</a>
- </h5>
-<p>
- Both of the variants of <code class="computeroutput"><span class="identifier">mismatch</span></code>
- run in <span class="emphasis"><em>O(N)</em></span> (linear) time; that is, they compare against
- each element in the list once. If the sequence is found to be not equal at
- any point, the routine will terminate immediately, without examining the
- rest of the elements.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX14.mismatch.h4"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX14.mismatch.exception_safety"></a></span><a class="link" href="CXX14.html#the_boost_algorithm_library.CXX14.mismatch.exception_safety">Exception
- Safety</a>
- </h5>
-<p>
- Both of the variants of <code class="computeroutput"><span class="identifier">mismatch</span></code>
- take their parameters by value and do not depend upon any global state. Therefore,
- all the routines in this file provide the strong exception guarantee.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.CXX14.mismatch.h5"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.CXX14.mismatch.notes"></a></span><a class="link" href="CXX14.html#the_boost_algorithm_library.CXX14.mismatch.notes">Notes</a>
- </h5>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
- If the sequences are equal (or both are empty), then mismatch returns
- the end iterators of both sequences.
- </li>
-<li class="listitem">
- The four iterator version of the routine <code class="computeroutput"><span class="identifier">mismatch</span></code>
- is part of the C++14 standard. When C++14 standard library implementations
- become available, the implementation from the standard library should
- be used.
- </li>
-</ul></div>
-</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; 2010-2012 Marshall Clow<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="CXX11.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../algorithm.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="Misc.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>
diff --git a/doc/html/algorithm/Misc.html b/doc/html/algorithm/Misc.html
deleted file mode 100644
index 49075d7b05..0000000000
--- a/doc/html/algorithm/Misc.html
+++ /dev/null
@@ -1,556 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Other Algorithms</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="The Boost C++ Libraries BoostBook Documentation Subset">
-<link rel="up" href="../algorithm.html" title="Chapter&#160;3.&#160;The Boost Algorithm Library">
-<link rel="prev" href="CXX14.html" title="C++14 Algorithms">
-<link rel="next" href="reference.html" title="Reference">
-</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="../../../libs/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="CXX14.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../algorithm.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="reference.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="algorithm.Misc"></a><a class="link" href="Misc.html" title="Other Algorithms">Other Algorithms</a>
-</h2></div></div></div>
-<div class="toc"><dl class="toc">
-<dt><span class="section"><a href="Misc.html#the_boost_algorithm_library.Misc.clamp">clamp</a></span></dt>
-<dt><span class="section"><a href="Misc.html#the_boost_algorithm_library.Misc.gather">gather</a></span></dt>
-<dt><span class="section"><a href="Misc.html#the_boost_algorithm_library.Misc.hex">hex</a></span></dt>
-<dt><span class="section"><a href="Misc.html#the_boost_algorithm_library.Misc.is_palindrome">is_palindrome</a></span></dt>
-</dl></div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="the_boost_algorithm_library.Misc.clamp"></a><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.clamp" title="clamp">clamp</a>
-</h3></div></div></div>
-<p>
- The header file clamp.hpp contains two functions for "clamping"
- a value between a pair of boundary values.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.clamp.h0"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.clamp.clamp"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.clamp.clamp">clamp</a>
- </h5>
-<p>
- The function <code class="computeroutput"><span class="identifier">clamp</span> <span class="special">(</span><span class="identifier">v</span><span class="special">,</span> <span class="identifier">lo</span><span class="special">,</span> <span class="identifier">hi</span><span class="special">)</span></code>
- returns:
- </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
- lo if v &lt; lo
- </li>
-<li class="listitem">
- hi if hi &lt; v
- </li>
-<li class="listitem">
- otherwise, v
- </li>
-</ul></div>
-<p>
- Note: using <code class="computeroutput"><span class="identifier">clamp</span></code> with floating
- point numbers may give unexpected results if one of the values is <code class="computeroutput"><span class="identifier">NaN</span></code>.
- </p>
-<p>
- There is also a version that allows the caller to specify a comparison predicate
- to use instead of <code class="computeroutput"><span class="keyword">operator</span> <span class="special">&lt;</span></code>.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">clamp</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">lo</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">hi</span> <span class="special">);</span>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Pred</span><span class="special">&gt;</span>
-<span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">clamp</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">lo</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">hi</span><span class="special">,</span> <span class="identifier">Pred</span> <span class="identifier">p</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<p>
- The following code:
-</p>
-<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">foo</span> <span class="special">=</span> <span class="number">23</span><span class="special">;</span>
-<span class="identifier">foo</span> <span class="special">=</span> <span class="identifier">clamp</span> <span class="special">(</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">10</span> <span class="special">);</span>
-</pre>
-<p>
- will leave <code class="computeroutput"><span class="identifier">foo</span></code> with a value
- of 10
- </p>
-<p>
- Complexity: <code class="computeroutput"><span class="identifier">clamp</span></code> will make
- either one or two calls to the comparison predicate before returning one
- of the three parameters.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.clamp.h1"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.clamp.clamp_range"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.clamp.clamp_range">clamp_range</a>
- </h5>
-<p>
- There are also four range-based versions of clamp, that apply clamping to
- a series of values. You could write them yourself with std::transform and
- bind, like this: <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">transform</span> <span class="special">(</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">out</span><span class="special">,</span> <span class="identifier">bind</span>
- <span class="special">(</span> <span class="identifier">clamp</span>
- <span class="special">(</span> <span class="identifier">_1</span><span class="special">,</span> <span class="identifier">lo</span><span class="special">,</span>
- <span class="identifier">hi</span> <span class="special">)))</span></code>,
- but they are provided here for your convenience.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
-<span class="identifier">OutputIterator</span> <span class="identifier">clamp_range</span> <span class="special">(</span> <span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">InputIterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="identifier">lo</span><span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">InputIterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="identifier">hi</span> <span class="special">);</span>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
-<span class="identifier">OutputIterator</span> <span class="identifier">clamp_range</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="identifier">lo</span><span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="identifier">hi</span> <span class="special">);</span>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">OutputIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Pred</span><span class="special">&gt;</span>
-<span class="identifier">OutputIterator</span> <span class="identifier">clamp_range</span> <span class="special">(</span> <span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">InputIterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="identifier">lo</span><span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">InputIterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="identifier">hi</span><span class="special">,</span> <span class="identifier">Pred</span> <span class="identifier">p</span> <span class="special">);</span>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">OutputIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Pred</span><span class="special">&gt;</span>
-<span class="identifier">OutputIterator</span> <span class="identifier">clamp_range</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="identifier">lo</span><span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="identifier">hi</span><span class="special">,</span>
- <span class="identifier">Pred</span> <span class="identifier">p</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="the_boost_algorithm_library.Misc.gather"></a><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.gather" title="gather">gather</a>
-</h3></div></div></div>
-<p>
- The header file 'boost/algorithm/gather.hpp' contains two variants of a single
- algorithm, <code class="computeroutput"><span class="identifier">gather</span></code>.
- </p>
-<p>
- <code class="computeroutput"><span class="identifier">gather</span><span class="special">()</span></code>
- takes a collection of elements defined by a pair of iterators and moves the
- ones satisfying a predicate to them to a position (called the pivot) within
- the sequence. The algorithm is stable. The result is a pair of iterators
- that contains the items that satisfy the predicate.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.gather.h0"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.gather.interface"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.gather.interface">Interface</a>
- </h5>
-<p>
- The function <code class="computeroutput"><span class="identifier">gather</span></code> returns
- a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></code> of iterators that denote the elements
- that satisfy the predicate.
- </p>
-<p>
- There are two versions; one takes two iterators, and the other takes a range.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Pred</span><span class="special">&gt;</span>
-<span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">BidirectionalIterator</span><span class="special">,</span><span class="identifier">BidirectionalIterator</span><span class="special">&gt;</span>
-<span class="identifier">gather</span> <span class="special">(</span> <span class="identifier">BidirectionalIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">BidirectionalIterator</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">BidirectionalIterator</span> <span class="identifier">pivot</span><span class="special">,</span> <span class="identifier">Pred</span> <span class="identifier">pred</span> <span class="special">);</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">BidirectionalRange</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Pred</span><span class="special">&gt;</span>
-<span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">BidirectionalRange</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">BidirectionalRange</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;</span>
-<span class="identifier">gather</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">BidirectionalRange</span> <span class="special">&amp;</span><span class="identifier">range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">BidirectionalRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">pivot</span><span class="special">,</span> <span class="identifier">Pred</span> <span class="identifier">pred</span> <span class="special">);</span>
-
-<span class="special">}}</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.gather.h1"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.gather.examples"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.gather.examples">Examples</a>
- </h5>
-<p>
- Given an sequence containing:
-</p>
-<pre class="programlisting"><span class="number">0</span> <span class="number">1</span> <span class="number">2</span> <span class="number">3</span> <span class="number">4</span> <span class="number">5</span> <span class="number">6</span> <span class="number">7</span> <span class="number">8</span> <span class="number">9</span>
-</pre>
-<p>
- </p>
-<p>
- a call to gather ( arr, arr + 10, arr + 4, IsEven ) will result in:
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="number">1</span> <span class="number">3</span> <span class="number">0</span> <span class="number">2</span> <span class="number">4</span> <span class="number">6</span> <span class="number">8</span> <span class="number">5</span> <span class="number">7</span> <span class="number">9</span>
- <span class="special">|---|-----|</span>
- <span class="identifier">first</span> <span class="special">|</span> <span class="identifier">second</span>
- <span class="identifier">pivot</span>
-</pre>
-<p>
- where <code class="computeroutput"><span class="identifier">first</span></code> and <code class="computeroutput"><span class="identifier">second</span></code> are the fields of the pair that
- is returned by the call.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.gather.h2"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.gather.iterator_requirements"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.gather.iterator_requirements">Iterator
- Requirements</a>
- </h5>
-<p>
- <code class="computeroutput"><span class="identifier">gather</span></code> work on bidirectional
- iterators or better. This requirement comes from the usage of <code class="computeroutput"><span class="identifier">stable_partition</span></code>, which requires bidirectional
- iterators. Some standard libraries (libstdc++ and libc++, for example) have
- implementations of <code class="computeroutput"><span class="identifier">stable_partition</span></code>
- that work with forward iterators. If that is the case, then <code class="computeroutput"><span class="identifier">gather</span></code> will work with forward iterators
- as well.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.gather.h3"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.gather.storage_requirements"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.gather.storage_requirements">Storage
- Requirements</a>
- </h5>
-<p>
- <code class="computeroutput"><span class="identifier">gather</span></code> uses <code class="computeroutput"><span class="identifier">stable_partition</span></code>, which will attempt to
- allocate temporary memory, but will work in-situ if there is none available.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.gather.h4"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.gather.complexity"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.gather.complexity">Complexity</a>
- </h5>
-<p>
- If there is sufficient memory available, the run time is linear: <code class="computeroutput"><span class="identifier">O</span><span class="special">(</span><span class="identifier">N</span><span class="special">)</span></code>
- </p>
-<p>
- If there is not any memory available, then the run time is <code class="computeroutput"><span class="identifier">O</span><span class="special">(</span><span class="identifier">N</span>
- <span class="identifier">log</span> <span class="identifier">N</span><span class="special">)</span></code>.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.gather.h5"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.gather.exception_safety"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.gather.exception_safety">Exception
- Safety</a>
- </h5>
-<h5>
-<a name="the_boost_algorithm_library.Misc.gather.h6"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.gather.notes"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.gather.notes">Notes</a>
- </h5>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="the_boost_algorithm_library.Misc.hex"></a><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.hex" title="hex">hex</a>
-</h3></div></div></div>
-<p>
- The header file <code class="computeroutput"><span class="char">'boost/algorithm/hex.hpp'</span></code>
- contains three variants each of two algorithms, <code class="computeroutput"><span class="identifier">hex</span></code>
- and <code class="computeroutput"><span class="identifier">unhex</span></code>. They are inverse
- algorithms; that is, one undoes the effort of the other. <code class="computeroutput"><span class="identifier">hex</span></code>
- takes a sequence of values, and turns them into hexadecimal characters.
- <code class="computeroutput"><span class="identifier">unhex</span></code> takes a sequence of
- hexadecimal characters, and outputs a sequence of values.
- </p>
-<p>
- <code class="computeroutput"><span class="identifier">hex</span></code> and <code class="computeroutput"><span class="identifier">unhex</span></code>
- come from MySQL, where they are used in database queries and stored procedures.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.hex.h0"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.hex.interface"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.hex.interface">interface</a>
- </h5>
-<p>
- The function <code class="computeroutput"><span class="identifier">hex</span></code> takes a
- sequence of values and writes hexadecimal characters. There are three different
- interfaces, differing only in how the input sequence is specified.
- </p>
-<p>
- The first one takes an iterator pair. The second one takes a pointer to the
- start of a zero-terminated sequence, such as a c string, and the third takes
- a range as defined by the Boost.Range library.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
-<span class="identifier">OutputIterator</span> <span class="identifier">hex</span> <span class="special">(</span> <span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out</span> <span class="special">);</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
-<span class="identifier">OutputIterator</span> <span class="identifier">hex</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">T</span> <span class="special">*</span><span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out</span> <span class="special">);</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
-<span class="identifier">OutputIterator</span> <span class="identifier">hex</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<p>
- <code class="computeroutput"><span class="identifier">hex</span></code> writes only values in
- the range '0'..'9' and 'A'..'F', but is not limited to character output.
- The output iterator could refer to a wstring, or a vector of integers, or
- any other integral type.
- </p>
-<p>
- The function <code class="computeroutput"><span class="identifier">unhex</span></code> takes
- the output of <code class="computeroutput"><span class="identifier">hex</span></code> and turns
- it back into a sequence of values.
- </p>
-<p>
- The input parameters for the different variations of <code class="computeroutput"><span class="identifier">unhex</span></code>
- are the same as <code class="computeroutput"><span class="identifier">hex</span></code>.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
-<span class="identifier">OutputIterator</span> <span class="identifier">unhex</span> <span class="special">(</span> <span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out</span> <span class="special">);</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
-<span class="identifier">OutputIterator</span> <span class="identifier">unhex</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">T</span> <span class="special">*</span><span class="identifier">ptr</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out</span> <span class="special">);</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
-<span class="identifier">OutputIterator</span> <span class="identifier">unhex</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.hex.h1"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.hex.error_handling"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.hex.error_handling">Error
- Handling</a>
- </h5>
-<p>
- The header 'hex.hpp' defines three exception classes:
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">hex_decode_error</span><span class="special">:</span> <span class="keyword">virtual</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">exception</span><span class="special">,</span> <span class="keyword">virtual</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">exception</span> <span class="special">{};</span>
-<span class="keyword">struct</span> <span class="identifier">not_enough_input</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">hex_decode_error</span><span class="special">;</span>
-<span class="keyword">struct</span> <span class="identifier">non_hex_input</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">hex_decode_error</span><span class="special">;</span>
-</pre>
-<p>
- </p>
-<p>
- If the input to <code class="computeroutput"><span class="identifier">unhex</span></code> does
- not contain an "even number" of hex digits, then an exception of
- type <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">not_enough_input</span></code> is thrown.
- </p>
-<p>
- If the input to <code class="computeroutput"><span class="identifier">unhex</span></code> contains
- any non-hexadecimal characters, then an exception of type <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">non_hex_input</span></code>
- is thrown.
- </p>
-<p>
- If you want to catch all the decoding errors, you can catch exceptions of
- type <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">hex_decode_error</span></code>.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.hex.h2"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.hex.examples"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.hex.examples">Examples</a>
- </h5>
-<p>
- Assuming that <code class="computeroutput"><span class="identifier">out</span></code> is an iterator
- that accepts <code class="computeroutput"><span class="keyword">char</span></code> values, and
- <code class="computeroutput"><span class="identifier">wout</span></code> accepts <code class="computeroutput"><span class="keyword">wchar_t</span></code> values (and that sizeof ( wchar_t
- ) == 2)
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="identifier">hex</span> <span class="special">(</span> <span class="string">"abcdef"</span><span class="special">,</span> <span class="identifier">out</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="string">"616263646566"</span>
-<span class="identifier">hex</span> <span class="special">(</span> <span class="string">"32"</span><span class="special">,</span> <span class="identifier">out</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="string">"3332"</span>
-<span class="identifier">hex</span> <span class="special">(</span> <span class="string">"abcdef"</span><span class="special">,</span> <span class="identifier">wout</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="string">"006100620063006400650066"</span>
-<span class="identifier">hex</span> <span class="special">(</span> <span class="string">"32"</span><span class="special">,</span> <span class="identifier">wout</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="string">"00330032"</span>
-
-<span class="identifier">unhex</span> <span class="special">(</span> <span class="string">"616263646566"</span><span class="special">,</span> <span class="identifier">out</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="string">"abcdef"</span>
-<span class="identifier">unhex</span> <span class="special">(</span> <span class="string">"3332"</span><span class="special">,</span> <span class="identifier">out</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="string">"32"</span>
-<span class="identifier">unhex</span> <span class="special">(</span> <span class="string">"616263646566"</span><span class="special">,</span> <span class="identifier">wout</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="string">"\6162\6364\6566"</span> <span class="special">(</span> <span class="identifier">i</span><span class="special">.</span><span class="identifier">e</span><span class="special">,</span> <span class="identifier">a</span> <span class="number">3</span> <span class="identifier">character</span> <span class="identifier">string</span> <span class="special">)</span>
-<span class="identifier">unhex</span> <span class="special">(</span> <span class="string">"3332"</span><span class="special">,</span> <span class="identifier">wout</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="string">"\3233"</span> <span class="special">(</span> <span class="identifier">U</span><span class="special">+</span><span class="number">3332</span><span class="special">,</span> <span class="identifier">SQUARE</span> <span class="identifier">HUARADDO</span> <span class="special">)</span>
-
-<span class="identifier">unhex</span> <span class="special">(</span> <span class="string">"3"</span><span class="special">,</span> <span class="identifier">out</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="identifier">Error</span> <span class="special">-</span> <span class="keyword">not</span> <span class="identifier">enough</span> <span class="identifier">input</span>
-<span class="identifier">unhex</span> <span class="special">(</span> <span class="string">"32"</span><span class="special">,</span> <span class="identifier">wout</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="identifier">Error</span> <span class="special">-</span> <span class="keyword">not</span> <span class="identifier">enough</span> <span class="identifier">input</span>
-
-<span class="identifier">unhex</span> <span class="special">(</span> <span class="string">"ACEG"</span><span class="special">,</span> <span class="identifier">out</span> <span class="special">)</span> <span class="special">--&gt;</span> <span class="identifier">Error</span> <span class="special">-</span> <span class="identifier">non</span><span class="special">-</span><span class="identifier">hex</span> <span class="identifier">input</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.hex.h3"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.hex.iterator_requirements"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.hex.iterator_requirements">Iterator
- Requirements</a>
- </h5>
-<p>
- <code class="computeroutput"><span class="identifier">hex</span></code> and <code class="computeroutput"><span class="identifier">unhex</span></code>
- work on all iterator types.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.hex.h4"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.hex.complexity"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.hex.complexity">Complexity</a>
- </h5>
-<p>
- All of the variants of <code class="computeroutput"><span class="identifier">hex</span></code>
- and <code class="computeroutput"><span class="identifier">unhex</span></code> run in <span class="emphasis"><em>O(N)</em></span>
- (linear) time; that is, that is, they process each element in the input sequence
- once.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.hex.h5"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.hex.exception_safety"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.hex.exception_safety">Exception
- Safety</a>
- </h5>
-<p>
- All of the variants of <code class="computeroutput"><span class="identifier">hex</span></code>
- and <code class="computeroutput"><span class="identifier">unhex</span></code> take their parameters
- by value or const reference, and do not depend upon any global state. Therefore,
- all the routines in this file provide the strong exception guarantee. However,
- when working on input iterators, if an exception is thrown, the input iterators
- will not be reset to their original values (i.e, the characters read from
- the iterator cannot be un-read)
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.hex.h6"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.hex.notes"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.hex.notes">Notes</a>
- </h5>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
- <code class="computeroutput"><span class="identifier">hex</span></code> and <code class="computeroutput"><span class="identifier">unhex</span></code> both do nothing when passed empty
- ranges.
- </li></ul></div>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="the_boost_algorithm_library.Misc.is_palindrome"></a><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.is_palindrome" title="is_palindrome">is_palindrome</a>
-</h3></div></div></div>
-<p>
- The header file 'is_palindrome.hpp' contains six variants of a single algorithm,
- is_palindrome. The algorithm tests the sequence and returns true if the sequence
- is a palindrome; i.e, it is identical when traversed either backwards or
- frontwards.
- </p>
-<p>
- The routine <code class="computeroutput"><span class="identifier">is_palindrome</span></code>
- takes a sequence and, optionally, a predicate. It will return true if the
- predicate returns true for tested elements by algorithm in the sequence.
- </p>
-<p>
- The routine come in 6 forms; the first one takes two iterators to define
- the range. The second form takes two iterators to define the range and a
- predicate. The third form takes a single range parameter, and uses Boost.Range
- to traverse it. The fourth form takes a single range parameter ( uses Boost.Range
- to traverse it) and a predicate. The fifth form takes a single C-string and
- a predicate. The sixth form takes a single C-string.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.is_palindrome.h0"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.is_palindrome.interface"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.is_palindrome.interface">interface</a>
- </h5>
-<p>
- The function <code class="computeroutput"><span class="identifier">is_palindrome</span></code>
- returns true if the predicate returns true any tested by algorithm items
- in the sequence. There are six versions: 1) takes two iterators. 2) takes
- two iterators and a predicate. 3) takes a range. 4) takes a range and a predicate.
- 5) takes a C-string and a predicate. 6) takes a C-string.
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">BidirectionalIterator</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_palindrome</span> <span class="special">(</span> <span class="identifier">BidirectionalIterator</span> <span class="identifier">begin</span><span class="special">,</span> <span class="identifier">BidirectionalIterator</span> <span class="identifier">end</span> <span class="special">);</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_palindrome</span> <span class="special">(</span> <span class="identifier">BidirectionalIterator</span> <span class="identifier">begin</span><span class="special">,</span> <span class="identifier">BidirectionalIterator</span> <span class="identifier">end</span><span class="special">,</span> <span class="identifier">Predicate</span> <span class="identifier">p</span> <span class="special">);</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_palindrome</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span> <span class="special">);</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Range</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_palindrome</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="identifier">r</span><span class="special">,</span> <span class="identifier">Predicate</span> <span class="identifier">p</span> <span class="special">);</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span>
- <span class="keyword">bool</span> <span class="identifier">is_palindrome</span> <span class="special">(</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">str</span><span class="special">,</span> <span class="identifier">Predicate</span> <span class="identifier">p</span> <span class="special">);</span>
-<span class="keyword">bool</span> <span class="identifier">is_palindrome</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">str</span><span class="special">);</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.is_palindrome.h1"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.is_palindrome.examples"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.is_palindrome.examples">Examples</a>
- </h5>
-<p>
- Given the containers: const std::list&lt;int&gt; empty, const std::vector&lt;char&gt;
- singleElement{'z'}, int oddNonPalindrome[] = {3,2,2}, const int oddPalindrome[]
- = {1,2,3,2,1}, const int evenPalindrome[] = {1,2,2,1}, int evenNonPalindrome[]
- = {1,4,8,8}, then
-</p>
-<pre class="programlisting"><span class="identifier">is_palindrome</span><span class="special">(</span><span class="identifier">empty</span><span class="special">))</span> <span class="special">--&gt;</span> <span class="keyword">true</span> <span class="comment">//empty range </span>
-<span class="identifier">is_palindrome</span><span class="special">(</span><span class="identifier">singleElement</span><span class="special">))</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">is_palindrome</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">oddNonPalindrome</span><span class="special">),</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">oddNonPalindrome</span><span class="special">)))</span> <span class="special">--&gt;</span> <span class="keyword">false</span>
-<span class="identifier">is_palindrome</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">evenPalindrome</span><span class="special">),</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">evenPalindrome</span><span class="special">)))</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">is_palindrome</span><span class="special">(</span><span class="identifier">empty</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">empty</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">functorComparator</span><span class="special">()))</span> <span class="special">--&gt;</span> <span class="keyword">true</span> <span class="comment">//empty range </span>
-<span class="identifier">is_palindrome</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">oddNonPalindrome</span><span class="special">),</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">oddNonPalindrome</span><span class="special">),</span> <span class="identifier">funcComparator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;))</span> <span class="special">--&gt;</span> <span class="keyword">false</span>
-<span class="identifier">is_palindrome</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">oddPalindrome</span><span class="special">),</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">oddPalindrome</span><span class="special">))</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">is_palindrome</span><span class="special">(</span><span class="identifier">evenPalindrome</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;()))</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">is_palindrome</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">evenNonPalindrome</span><span class="special">),</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">evenNonPalindrome</span><span class="special">))</span> <span class="special">--&gt;</span> <span class="keyword">false</span>
-<span class="identifier">is_palindrome</span><span class="special">(</span><span class="string">"a"</span><span class="special">)</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-<span class="identifier">is_palindrome</span><span class="special">(</span><span class="string">"aba"</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;())</span> <span class="special">--&gt;</span> <span class="keyword">true</span>
-</pre>
-<p>
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.is_palindrome.h2"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.is_palindrome.iterator_requirements"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.is_palindrome.iterator_requirements">Iterator
- Requirements</a>
- </h5>
-<p>
- <code class="computeroutput"><span class="identifier">is_palindrome</span></code> work on Bidirectional
- and RandomAccess iterators.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.is_palindrome.h3"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.is_palindrome.complexity"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.is_palindrome.complexity">Complexity</a>
- </h5>
-<p>
- All of the variants of <code class="computeroutput"><span class="identifier">is_palindrome</span></code>
- run in <span class="emphasis"><em>O(N)</em></span> (linear) time; that is, they compare against
- each element in the list once. If any of the comparisons not succeed, the
- algorithm will terminate immediately, without examining the remaining members
- of the sequence.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.is_palindrome.h4"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.is_palindrome.exception_safety"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.is_palindrome.exception_safety">Exception
- Safety</a>
- </h5>
-<p>
- All of the variants of <code class="computeroutput"><span class="identifier">is_palindrome</span></code>
- take their parameters by value, const pointer or const reference, and do
- not depend upon any global state. Therefore, all the routines in this file
- provide the strong exception guarantee.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Misc.is_palindrome.h5"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Misc.is_palindrome.notes"></a></span><a class="link" href="Misc.html#the_boost_algorithm_library.Misc.is_palindrome.notes">Notes</a>
- </h5>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
- <code class="computeroutput"><span class="identifier">is_palindrome</span></code> returns
- true for empty ranges, const char* null pointers and for single element
- ranges.
- </li>
-<li class="listitem">
- If you use version of 'is_palindrome' without custom predicate, 'is_palindrome'
- uses default 'operator==()' for elements.
- </li>
-<li class="listitem">
- Be careful with using not null pointer 'const char*' without '\0' - if
- you use it with 'is_palindrome', it's a undefined behaviour.
- </li>
-</ul></div>
-</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; 2010-2012 Marshall Clow<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="CXX14.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../algorithm.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="reference.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>
diff --git a/doc/html/algorithm/Searching.html b/doc/html/algorithm/Searching.html
deleted file mode 100644
index a9e743a139..0000000000
--- a/doc/html/algorithm/Searching.html
+++ /dev/null
@@ -1,544 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Searching Algorithms</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="The Boost C++ Libraries BoostBook Documentation Subset">
-<link rel="up" href="../algorithm.html" title="Chapter&#160;3.&#160;The Boost Algorithm Library">
-<link rel="prev" href="../algorithm.html" title="Chapter&#160;3.&#160;The Boost Algorithm Library">
-<link rel="next" href="CXX11.html" title="C++11 Algorithms">
-</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="../../../libs/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="../algorithm.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../algorithm.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="CXX11.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="algorithm.Searching"></a><a class="link" href="Searching.html" title="Searching Algorithms">Searching Algorithms</a>
-</h2></div></div></div>
-<div class="toc"><dl class="toc">
-<dt><span class="section"><a href="Searching.html#the_boost_algorithm_library.Searching.BoyerMoore">Boyer-Moore
- Search</a></span></dt>
-<dt><span class="section"><a href="Searching.html#the_boost_algorithm_library.Searching.BoyerMooreHorspool">Boyer-Moore-Horspool
- Search</a></span></dt>
-<dt><span class="section"><a href="Searching.html#the_boost_algorithm_library.Searching.KnuthMorrisPratt">Knuth-Morris-Pratt
- Search</a></span></dt>
-</dl></div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="the_boost_algorithm_library.Searching.BoyerMoore"></a><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMoore" title="Boyer-Moore Search">Boyer-Moore
- Search</a>
-</h3></div></div></div>
-<h5>
-<a name="the_boost_algorithm_library.Searching.BoyerMoore.h0"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.BoyerMoore.overview"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMoore.overview">Overview</a>
- </h5>
-<p>
- The header file 'boyer_moore.hpp' contains an implementation of the Boyer-Moore
- algorithm for searching sequences of values.
- </p>
-<p>
- The Boyer&#8211;Moore string search algorithm is a particularly efficient string
- searching algorithm, and it has been the standard benchmark for the practical
- string search literature. The Boyer-Moore algorithm was invented by Bob Boyer
- and J. Strother Moore, and published in the October 1977 issue of the Communications
- of the ACM , and a copy of that article is available at <a href="http://www.cs.utexas.edu/~moore/publications/fstrpos.pdf" target="_top">http://www.cs.utexas.edu/~moore/publications/fstrpos.pdf</a>.
- </p>
-<p>
- The Boyer-Moore algorithm uses two precomputed tables to give better performance
- than a naive search. These tables depend on the pattern being searched for,
- and give the Boyer-Moore algorithm larger a memory footprint and startup
- costs than a simpler algorithm, but these costs are recovered quickly during
- the searching process, especially if the pattern is longer than a few elements.
- </p>
-<p>
- However, the Boyer-Moore algorithm cannot be used with comparison predicates
- like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">search</span></code>.
- </p>
-<p>
- Nomenclature: I refer to the sequence being searched for as the "pattern",
- and the sequence being searched in as the "corpus".
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.BoyerMoore.h1"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.BoyerMoore.interface"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMoore.interface">Interface</a>
- </h5>
-<p>
- For flexibility, the Boyer-Moore algorithm has two interfaces; an object-based
- interface and a procedural one. The object-based interface builds the tables
- in the constructor, and uses operator () to perform the search. The procedural
- interface builds the table and does the search all in one step. If you are
- going to be searching for the same pattern in multiple corpora, then you
- should use the object interface, and only build the tables once.
- </p>
-<p>
- Here is the object interface:
-</p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">patIter</span><span class="special">&gt;</span>
-<span class="keyword">class</span> <span class="identifier">boyer_moore</span> <span class="special">{</span>
-<span class="keyword">public</span><span class="special">:</span>
- <span class="identifier">boyer_moore</span> <span class="special">(</span> <span class="identifier">patIter</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">patIter</span> <span class="identifier">last</span> <span class="special">);</span>
- <span class="special">~</span><span class="identifier">boyer_moore</span> <span class="special">();</span>
-
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">corpusIter</span><span class="special">&gt;</span>
- <span class="identifier">corpusIter</span> <span class="keyword">operator</span> <span class="special">()</span> <span class="special">(</span> <span class="identifier">corpusIter</span> <span class="identifier">corpus_first</span><span class="special">,</span> <span class="identifier">corpusIter</span> <span class="identifier">corpus_last</span> <span class="special">);</span>
- <span class="special">};</span>
-</pre>
-<p>
- </p>
-<p>
- and here is the corresponding procedural interface:
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">patIter</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">corpusIter</span><span class="special">&gt;</span>
-<span class="identifier">corpusIter</span> <span class="identifier">boyer_moore_search</span> <span class="special">(</span>
- <span class="identifier">corpusIter</span> <span class="identifier">corpus_first</span><span class="special">,</span> <span class="identifier">corpusIter</span> <span class="identifier">corpus_last</span><span class="special">,</span>
- <span class="identifier">patIter</span> <span class="identifier">pat_first</span><span class="special">,</span> <span class="identifier">patIter</span> <span class="identifier">pat_last</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<p>
- Each of the functions is passed two pairs of iterators. The first two define
- the corpus and the second two define the pattern. Note that the two pairs
- need not be of the same type, but they do need to "point" at the
- same type. In other words, <code class="computeroutput"><span class="identifier">patIter</span><span class="special">::</span><span class="identifier">value_type</span></code>
- and <code class="computeroutput"><span class="identifier">curpusIter</span><span class="special">::</span><span class="identifier">value_type</span></code> need to be the same type.
- </p>
-<p>
- The return value of the function is an iterator pointing to the start of
- the pattern in the corpus. If the pattern is not found, it returns the end
- of the corpus (<code class="computeroutput"><span class="identifier">corpus_last</span></code>).
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.BoyerMoore.h2"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.BoyerMoore.performance"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMoore.performance">Performance</a>
- </h5>
-<p>
- The execution time of the Boyer-Moore algorithm, while still linear in the
- size of the string being searched, can have a significantly lower constant
- factor than many other search algorithms: it doesn't need to check every
- character of the string to be searched, but rather skips over some of them.
- Generally the algorithm gets faster as the pattern being searched for becomes
- longer. Its efficiency derives from the fact that with each unsuccessful
- attempt to find a match between the search string and the text it is searching,
- it uses the information gained from that attempt to rule out as many positions
- of the text as possible where the string cannot match.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.BoyerMoore.h3"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.BoyerMoore.memory_use"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMoore.memory_use">Memory
- Use</a>
- </h5>
-<p>
- The algorithm allocates two internal tables. The first one is proportional
- to the length of the pattern; the second one has one entry for each member
- of the "alphabet" in the pattern. For (8-bit) character types,
- this table contains 256 entries.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.BoyerMoore.h4"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.BoyerMoore.complexity"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMoore.complexity">Complexity</a>
- </h5>
-<p>
- The worst-case performance to find a pattern in the corpus is <span class="emphasis"><em>O(N)</em></span>
- (linear) time; that is, proportional to the length of the corpus being searched.
- In general, the search is sub-linear; not every entry in the corpus need
- be checked.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.BoyerMoore.h5"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.BoyerMoore.exception_safety"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMoore.exception_safety">Exception
- Safety</a>
- </h5>
-<p>
- Both the object-oriented and procedural versions of the Boyer-Moore algorithm
- take their parameters by value and do not use any information other than
- what is passed in. Therefore, both interfaces provide the strong exception
- guarantee.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.BoyerMoore.h6"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.BoyerMoore.notes"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMoore.notes">Notes</a>
- </h5>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
- When using the object-based interface, the pattern must remain unchanged
- for during the searches; i.e, from the time the object is constructed
- until the final call to operator () returns.
- </li>
-<li class="listitem">
- The Boyer-Moore algorithm requires random-access iterators for both the
- pattern and the corpus.
- </li>
-</ul></div>
-<h5>
-<a name="the_boost_algorithm_library.Searching.BoyerMoore.h7"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.BoyerMoore.customization_points"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMoore.customization_points">Customization
- points</a>
- </h5>
-<p>
- The Boyer-Moore object takes a traits template parameter which enables the
- caller to customize how one of the precomputed tables is stored. This table,
- called the skip table, contains (logically) one entry for every possible
- value that the pattern can contain. When searching 8-bit character data,
- this table contains 256 elements. The traits class defines the table to be
- used.
- </p>
-<p>
- The default traits class uses a <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span></code>
- for small 'alphabets' and a <code class="computeroutput"><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">unordered_map</span></code>
- for larger ones. The array-based skip table gives excellent performance,
- but could be prohibitively large when the 'alphabet' of elements to be searched
- grows. The unordered_map based version only grows as the number of unique
- elements in the pattern, but makes many more heap allocations, and gives
- slower lookup performance.
- </p>
-<p>
- To use a different skip table, you should define your own skip table object
- and your own traits class, and use them to instantiate the Boyer-Moore object.
- The interface to these objects is described TBD.
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="the_boost_algorithm_library.Searching.BoyerMooreHorspool"></a><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMooreHorspool" title="Boyer-Moore-Horspool Search">Boyer-Moore-Horspool
- Search</a>
-</h3></div></div></div>
-<h5>
-<a name="the_boost_algorithm_library.Searching.BoyerMooreHorspool.h0"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.BoyerMooreHorspool.overview"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMooreHorspool.overview">Overview</a>
- </h5>
-<p>
- The header file 'boyer_moore_horspool.hpp' contains an implementation of
- the Boyer-Moore-Horspool algorithm for searching sequences of values.
- </p>
-<p>
- The Boyer-Moore-Horspool search algorithm was published by Nigel Horspool
- in 1980. It is a refinement of the Boyer-Moore algorithm that trades space
- for time. It uses less space for internal tables than Boyer-Moore, and has
- poorer worst-case performance.
- </p>
-<p>
- The Boyer-Moore-Horspool algorithm cannot be used with comparison predicates
- like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">search</span></code>.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.BoyerMooreHorspool.h1"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.BoyerMooreHorspool.interface"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMooreHorspool.interface">Interface</a>
- </h5>
-<p>
- Nomenclature: I refer to the sequence being searched for as the "pattern",
- and the sequence being searched in as the "corpus".
- </p>
-<p>
- For flexibility, the Boyer-Moore-Horspool algorithm has two interfaces; an
- object-based interface and a procedural one. The object-based interface builds
- the tables in the constructor, and uses operator () to perform the search.
- The procedural interface builds the table and does the search all in one
- step. If you are going to be searching for the same pattern in multiple corpora,
- then you should use the object interface, and only build the tables once.
- </p>
-<p>
- Here is the object interface:
-</p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">patIter</span><span class="special">&gt;</span>
-<span class="keyword">class</span> <span class="identifier">boyer_moore_horspool</span> <span class="special">{</span>
-<span class="keyword">public</span><span class="special">:</span>
- <span class="identifier">boyer_moore_horspool</span> <span class="special">(</span> <span class="identifier">patIter</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">patIter</span> <span class="identifier">last</span> <span class="special">);</span>
- <span class="special">~</span><span class="identifier">boyer_moore_horspool</span> <span class="special">();</span>
-
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">corpusIter</span><span class="special">&gt;</span>
- <span class="identifier">corpusIter</span> <span class="keyword">operator</span> <span class="special">()</span> <span class="special">(</span> <span class="identifier">corpusIter</span> <span class="identifier">corpus_first</span><span class="special">,</span> <span class="identifier">corpusIter</span> <span class="identifier">corpus_last</span> <span class="special">);</span>
- <span class="special">};</span>
-</pre>
-<p>
- </p>
-<p>
- and here is the corresponding procedural interface:
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">patIter</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">corpusIter</span><span class="special">&gt;</span>
-<span class="identifier">corpusIter</span> <span class="identifier">boyer_moore_horspool_search</span> <span class="special">(</span>
- <span class="identifier">corpusIter</span> <span class="identifier">corpus_first</span><span class="special">,</span> <span class="identifier">corpusIter</span> <span class="identifier">corpus_last</span><span class="special">,</span>
- <span class="identifier">patIter</span> <span class="identifier">pat_first</span><span class="special">,</span> <span class="identifier">patIter</span> <span class="identifier">pat_last</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<p>
- Each of the functions is passed two pairs of iterators. The first two define
- the corpus and the second two define the pattern. Note that the two pairs
- need not be of the same type, but they do need to "point" at the
- same type. In other words, <code class="computeroutput"><span class="identifier">patIter</span><span class="special">::</span><span class="identifier">value_type</span></code>
- and <code class="computeroutput"><span class="identifier">curpusIter</span><span class="special">::</span><span class="identifier">value_type</span></code> need to be the same type.
- </p>
-<p>
- The return value of the function is an iterator pointing to the start of
- the pattern in the corpus. If the pattern is not found, it returns the end
- of the corpus (<code class="computeroutput"><span class="identifier">corpus_last</span></code>).
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.BoyerMooreHorspool.h2"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.BoyerMooreHorspool.performance"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMooreHorspool.performance">Performance</a>
- </h5>
-<p>
- The execution time of the Boyer-Moore-Horspool algorithm is linear in the
- size of the string being searched; it can have a significantly lower constant
- factor than many other search algorithms: it doesn't need to check every
- character of the string to be searched, but rather skips over some of them.
- Generally the algorithm gets faster as the pattern being searched for becomes
- longer. Its efficiency derives from the fact that with each unsuccessful
- attempt to find a match between the search string and the text it is searching,
- it uses the information gained from that attempt to rule out as many positions
- of the text as possible where the string cannot match.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.BoyerMooreHorspool.h3"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.BoyerMooreHorspool.memory_use"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMooreHorspool.memory_use">Memory
- Use</a>
- </h5>
-<p>
- The algorithm an internal table that has one entry for each member of the
- "alphabet" in the pattern. For (8-bit) character types, this table
- contains 256 entries.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.BoyerMooreHorspool.h4"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.BoyerMooreHorspool.complexity"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMooreHorspool.complexity">Complexity</a>
- </h5>
-<p>
- The worst-case performance is <span class="emphasis"><em>O(m x n)</em></span>, where <span class="emphasis"><em>m</em></span>
- is the length of the pattern and <span class="emphasis"><em>n</em></span> is the length of
- the corpus. The average time is <span class="emphasis"><em>O(n)</em></span>. The best case
- performance is sub-linear, and is, in fact, identical to Boyer-Moore, but
- the initialization is quicker and the internal loop is simpler than Boyer-Moore.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.BoyerMooreHorspool.h5"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.BoyerMooreHorspool.exception_safety"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMooreHorspool.exception_safety">Exception
- Safety</a>
- </h5>
-<p>
- Both the object-oriented and procedural versions of the Boyer-Moore-Horspool
- algorithm take their parameters by value and do not use any information other
- than what is passed in. Therefore, both interfaces provide the strong exception
- guarantee.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.BoyerMooreHorspool.h6"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.BoyerMooreHorspool.notes"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMooreHorspool.notes">Notes</a>
- </h5>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
- When using the object-based interface, the pattern must remain unchanged
- for during the searches; i.e, from the time the object is constructed
- until the final call to operator () returns.
- </li>
-<li class="listitem">
- The Boyer-Moore-Horspool algorithm requires random-access iterators for
- both the pattern and the corpus.
- </li>
-</ul></div>
-<h5>
-<a name="the_boost_algorithm_library.Searching.BoyerMooreHorspool.h7"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.BoyerMooreHorspool.customization_points"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.BoyerMooreHorspool.customization_points">Customization
- points</a>
- </h5>
-<p>
- The Boyer-Moore-Horspool object takes a traits template parameter which enables
- the caller to customize how the precomputed table is stored. This table,
- called the skip table, contains (logically) one entry for every possible
- value that the pattern can contain. When searching 8-bit character data,
- this table contains 256 elements. The traits class defines the table to be
- used.
- </p>
-<p>
- The default traits class uses a <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span></code>
- for small 'alphabets' and a <code class="computeroutput"><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">unordered_map</span></code>
- for larger ones. The array-based skip table gives excellent performance,
- but could be prohibitively large when the 'alphabet' of elements to be searched
- grows. The unordered_map based version only grows as the number of unique
- elements in the pattern, but makes many more heap allocations, and gives
- slower lookup performance.
- </p>
-<p>
- To use a different skip table, you should define your own skip table object
- and your own traits class, and use them to instantiate the Boyer-Moore-Horspool
- object. The interface to these objects is described TBD.
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="the_boost_algorithm_library.Searching.KnuthMorrisPratt"></a><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.KnuthMorrisPratt" title="Knuth-Morris-Pratt Search">Knuth-Morris-Pratt
- Search</a>
-</h3></div></div></div>
-<h5>
-<a name="the_boost_algorithm_library.Searching.KnuthMorrisPratt.h0"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.KnuthMorrisPratt.overview"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.KnuthMorrisPratt.overview">Overview</a>
- </h5>
-<p>
- The header file 'knuth_morris_pratt.hpp' contains an implementation of the
- Knuth-Morris-Pratt algorithm for searching sequences of values.
- </p>
-<p>
- The basic premise of the Knuth-Morris-Pratt algorithm is that when a mismatch
- occurs, there is information in the pattern being searched for that can be
- used to determine where the next match could begin, enabling the skipping
- of some elements of the corpus that have already been examined.
- </p>
-<p>
- It does this by building a table from the pattern being searched for, with
- one entry for each element in the pattern.
- </p>
-<p>
- The algorithm was conceived in 1974 by Donald Knuth and Vaughan Pratt, and
- independently by James H. Morris. The three published it jointly in 1977
- in the SIAM Journal on Computing <a href="http://citeseer.ist.psu.edu/context/23820/0" target="_top">http://citeseer.ist.psu.edu/context/23820/0</a>
- </p>
-<p>
- However, the Knuth-Morris-Pratt algorithm cannot be used with comparison
- predicates like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">search</span></code>.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.KnuthMorrisPratt.h1"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.KnuthMorrisPratt.interface"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.KnuthMorrisPratt.interface">Interface</a>
- </h5>
-<p>
- Nomenclature: I refer to the sequence being searched for as the "pattern",
- and the sequence being searched in as the "corpus".
- </p>
-<p>
- For flexibility, the Knuth-Morris-Pratt algorithm has two interfaces; an
- object-based interface and a procedural one. The object-based interface builds
- the table in the constructor, and uses operator () to perform the search.
- The procedural interface builds the table and does the search all in one
- step. If you are going to be searching for the same pattern in multiple corpora,
- then you should use the object interface, and only build the tables once.
- </p>
-<p>
- Here is the object interface:
-</p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">patIter</span><span class="special">&gt;</span>
-<span class="keyword">class</span> <span class="identifier">knuth_morris_pratt</span> <span class="special">{</span>
-<span class="keyword">public</span><span class="special">:</span>
- <span class="identifier">knuth_morris_pratt</span> <span class="special">(</span> <span class="identifier">patIter</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">patIter</span> <span class="identifier">last</span> <span class="special">);</span>
- <span class="special">~</span><span class="identifier">knuth_morris_pratt</span> <span class="special">();</span>
-
- <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">corpusIter</span><span class="special">&gt;</span>
- <span class="identifier">corpusIter</span> <span class="keyword">operator</span> <span class="special">()</span> <span class="special">(</span> <span class="identifier">corpusIter</span> <span class="identifier">corpus_first</span><span class="special">,</span> <span class="identifier">corpusIter</span> <span class="identifier">corpus_last</span> <span class="special">);</span>
- <span class="special">};</span>
-</pre>
-<p>
- </p>
-<p>
- and here is the corresponding procedural interface:
- </p>
-<p>
-</p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">patIter</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">corpusIter</span><span class="special">&gt;</span>
-<span class="identifier">corpusIter</span> <span class="identifier">knuth_morris_pratt_search</span> <span class="special">(</span>
- <span class="identifier">corpusIter</span> <span class="identifier">corpus_first</span><span class="special">,</span> <span class="identifier">corpusIter</span> <span class="identifier">corpus_last</span><span class="special">,</span>
- <span class="identifier">patIter</span> <span class="identifier">pat_first</span><span class="special">,</span> <span class="identifier">patIter</span> <span class="identifier">pat_last</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<p>
- Each of the functions is passed two pairs of iterators. The first two define
- the corpus and the second two define the pattern. Note that the two pairs
- need not be of the same type, but they do need to "point" at the
- same type. In other words, <code class="computeroutput"><span class="identifier">patIter</span><span class="special">::</span><span class="identifier">value_type</span></code>
- and <code class="computeroutput"><span class="identifier">curpusIter</span><span class="special">::</span><span class="identifier">value_type</span></code> need to be the same type.
- </p>
-<p>
- The return value of the function is an iterator pointing to the start of
- the pattern in the corpus. If the pattern is not found, it returns the end
- of the corpus (<code class="computeroutput"><span class="identifier">corpus_last</span></code>).
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.KnuthMorrisPratt.h2"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.KnuthMorrisPratt.performance"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.KnuthMorrisPratt.performance">Performance</a>
- </h5>
-<p>
- The execution time of the Knuth-Morris-Pratt algorithm is linear in the size
- of the string being searched. Generally the algorithm gets faster as the
- pattern being searched for becomes longer. Its efficiency derives from the
- fact that with each unsuccessful attempt to find a match between the search
- string and the text it is searching, it uses the information gained from
- that attempt to rule out as many positions of the text as possible where
- the string cannot match.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.KnuthMorrisPratt.h3"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.KnuthMorrisPratt.memory_use"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.KnuthMorrisPratt.memory_use">Memory
- Use</a>
- </h5>
-<p>
- The algorithm an that contains one entry for each element the pattern, plus
- one extra. So, when searching for a 1026 byte string, the table will have
- 1027 entries.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.KnuthMorrisPratt.h4"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.KnuthMorrisPratt.complexity"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.KnuthMorrisPratt.complexity">Complexity</a>
- </h5>
-<p>
- The worst-case performance is <span class="emphasis"><em>O(2n)</em></span>, where <span class="emphasis"><em>n</em></span>
- is the length of the corpus. The average time is <span class="emphasis"><em>O(n)</em></span>.
- The best case performance is sub-linear.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.KnuthMorrisPratt.h5"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.KnuthMorrisPratt.exception_safety"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.KnuthMorrisPratt.exception_safety">Exception
- Safety</a>
- </h5>
-<p>
- Both the object-oriented and procedural versions of the Knuth-Morris-Pratt
- algorithm take their parameters by value and do not use any information other
- than what is passed in. Therefore, both interfaces provide the strong exception
- guarantee.
- </p>
-<h5>
-<a name="the_boost_algorithm_library.Searching.KnuthMorrisPratt.h6"></a>
- <span class="phrase"><a name="the_boost_algorithm_library.Searching.KnuthMorrisPratt.notes"></a></span><a class="link" href="Searching.html#the_boost_algorithm_library.Searching.KnuthMorrisPratt.notes">Notes</a>
- </h5>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
- When using the object-based interface, the pattern must remain unchanged
- for during the searches; i.e, from the time the object is constructed
- until the final call to operator () returns.
- </li>
-<li class="listitem">
- The Knuth-Morris-Pratt algorithm requires random-access iterators for
- both the pattern and the corpus. It should be possible to write this
- to use bidirectional iterators (or possibly even forward ones), but this
- implementation does not do that.
- </li>
-</ul></div>
-</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; 2010-2012 Marshall Clow<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="../algorithm.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../algorithm.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="CXX11.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>
diff --git a/doc/html/algorithm/reference.html b/doc/html/algorithm/reference.html
deleted file mode 100644
index 0f284be407..0000000000
--- a/doc/html/algorithm/reference.html
+++ /dev/null
@@ -1,745 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Reference</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="The Boost C++ Libraries BoostBook Documentation Subset">
-<link rel="up" href="../algorithm.html" title="Chapter&#160;3.&#160;The Boost Algorithm Library">
-<link rel="prev" href="Misc.html" title="Other Algorithms">
-<link rel="next" href="../boost/algorithm/power_idp422669008.html" title="Function template power">
-</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="../../../libs/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="Misc.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../algorithm.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="../boost/algorithm/power_idp422669008.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="algorithm.reference"></a>Reference</h2></div></div></div>
-<div class="toc"><dl class="toc">
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.algorithm_hpp">Header &lt;boost/algorithm/algorithm.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.clamp_hpp">Header &lt;boost/algorithm/clamp.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.cxx11.all_of_hpp">Header &lt;boost/algorithm/cxx11/all_of.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.cxx11.any_of_hpp">Header &lt;boost/algorithm/cxx11/any_of.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.cxx11.copy_if_hpp">Header &lt;boost/algorithm/cxx11/copy_if.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.cxx11.copy_n_hpp">Header &lt;boost/algorithm/cxx11/copy_n.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.cxx11.find_if_not_hpp">Header &lt;boost/algorithm/cxx11/find_if_not.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.cxx11.iota_hpp">Header &lt;boost/algorithm/cxx11/iota.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.cxx11.is_partitioned_hpp">Header &lt;boost/algorithm/cxx11/is_partitioned.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.cxx11.is_permutation_hpp">Header &lt;boost/algorithm/cxx11/is_permutation.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.cxx14.is_permutation_hpp">Header &lt;boost/algorithm/cxx14/is_permutation.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.cxx11.is_sorted_hpp">Header &lt;boost/algorithm/cxx11/is_sorted.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.cxx11.none_of_hpp">Header &lt;boost/algorithm/cxx11/none_of.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.cxx11.one_of_hpp">Header &lt;boost/algorithm/cxx11/one_of.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.cxx11.partition_copy_hpp">Header &lt;boost/algorithm/cxx11/partition_copy.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.cxx11.partition_point_hpp">Header &lt;boost/algorithm/cxx11/partition_point.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.cxx14.equal_hpp">Header &lt;boost/algorithm/cxx14/equal.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.cxx14.mismatch_hpp">Header &lt;boost/algorithm/cxx14/mismatch.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.gather_hpp">Header &lt;boost/algorithm/gather.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.hex_hpp">Header &lt;boost/algorithm/hex.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.is_palindrome_hpp">Header &lt;boost/algorithm/is_palindrome.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.minmax_hpp">Header &lt;boost/algorithm/minmax.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.minmax_element_hpp">Header &lt;boost/algorithm/minmax_element.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.searching.boyer_moore_hpp">Header &lt;boost/algorithm/searching/boyer_moore.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.searching.boyer_moore_horspool_hpp">Header &lt;boost/algorithm/searching/boyer_moore_horspool.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.searching.knuth_morris_pratt_hpp">Header &lt;boost/algorithm/searching/knuth_morris_pratt.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.sort_subrange_hpp">Header &lt;boost/algorithm/sort_subrange.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.string_hpp">Header &lt;boost/algorithm/string.hpp&gt;</a></span></dt>
-<dt><span class="section"><a href="reference.html#header.boost.algorithm.string_regex_hpp">Header &lt;boost/algorithm/string_regex.hpp&gt;</a></span></dt>
-</dl></div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.algorithm_hpp"></a>Header &lt;<a href="../../../boost/algorithm/algorithm.hpp" target="_top">boost/algorithm/algorithm.hpp</a>&gt;</h3></div></div></div>
-<p>Misc Algorithms. </p>
-<p>Marshall Clow </p>
-<p>
-</p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <span class="identifier">T</span> <a name="boost.algorithm.identity_oper_idp422664752"></a><span class="identifier">identity_operation</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">multiplies</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <span class="identifier">T</span> <a name="boost.algorithm.identity_oper_idp422666880"></a><span class="identifier">identity_operation</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">plus</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> Integer<span class="special">&gt;</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">enable_if</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_integral</span><span class="special">&lt;</span> <span class="identifier">Integer</span> <span class="special">&gt;</span><span class="special">,</span> <span class="identifier">T</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a class="link" href="../boost/algorithm/power_idp422669008.html" title="Function template power"><span class="identifier">power</span></a><span class="special">(</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Integer</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> Integer<span class="special">,</span> <span class="keyword">typename</span> Operation<span class="special">&gt;</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">enable_if</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_integral</span><span class="special">&lt;</span> <span class="identifier">Integer</span> <span class="special">&gt;</span><span class="special">,</span> <span class="identifier">T</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a class="link" href="../boost/algorithm/power_idp422673792.html" title="Function template power"><span class="identifier">power</span></a><span class="special">(</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Integer</span><span class="special">,</span> <span class="identifier">Operation</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.clamp_hpp"></a>Header &lt;<a href="../../../boost/algorithm/clamp.hpp" target="_top">boost/algorithm/clamp.hpp</a>&gt;</h3></div></div></div>
-<p>Clamp algorithm. </p>
-<p>Marshall Clow</p>
-<p>
-Suggested by olafvdspek in <a href="https://svn.boost.org/trac/boost/ticket/3215" target="_top">https://svn.boost.org/trac/boost/ticket/3215</a> </p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">&gt;</span>
- <span class="identifier">T</span> <span class="keyword">const</span> <span class="special">&amp;</span> <a class="link" href="../boost/algorithm/clamp_idp422683472.html" title="Function template clamp"><span class="identifier">clamp</span></a><span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">identity</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">identity</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span>
- <span class="identifier">T</span> <span class="keyword">const</span> <span class="special">&amp;</span> <a class="link" href="../boost/algorithm/clamp_idp422690464.html" title="Function template clamp"><span class="identifier">clamp</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">identity</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">identity</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">&gt;</span>
- <span class="identifier">OutputIterator</span>
- <a name="boost.algorithm.clamp_range_idp422695952"></a><span class="identifier">clamp_range</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> <span class="identifier">OutputIterator</span> out<span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span> <span class="identifier">InputIterator</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span> lo<span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span> <span class="identifier">InputIterator</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span> hi<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">&gt;</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">disable_if_c</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span> <span class="identifier">Range</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a class="link" href="../boost/algorithm/clamp_range_idp422701072.html" title="Function template clamp_range"><span class="identifier">clamp_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">&gt;</span>
- <span class="identifier">OutputIterator</span>
- <a name="boost.algorithm.clamp_range_idp422708240"></a><span class="identifier">clamp_range</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> <span class="identifier">OutputIterator</span> out<span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span> <span class="identifier">InputIterator</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span> lo<span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span> <span class="identifier">InputIterator</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span> hi<span class="special">,</span>
- <span class="identifier">Pred</span> p<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">&gt;</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">disable_if_c</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span> <span class="identifier">Range</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a class="link" href="../boost/algorithm/clamp_range_idp422714480.html" title="Function template clamp_range"><span class="identifier">clamp_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value_type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="identifier">Pred</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.cxx11.all_of_hpp"></a>Header &lt;<a href="../../../boost/algorithm/cxx11/all_of.hpp" target="_top">boost/algorithm/cxx11/all_of.hpp</a>&gt;</h3></div></div></div>
-<p>Test ranges to see if all elements match a value or predicate. </p>
-<p>Marshall Clow </p>
-<p>
-</p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/all_of_idp422726016.html" title="Function template all_of"><span class="identifier">all_of</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/all_of_idp422732832.html" title="Function template all_of"><span class="identifier">all_of</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> T<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/all_of_equal_idp422738128.html" title="Function template all_of_equal"><span class="identifier">all_of_equal</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> T<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/all_of_equal_idp422744432.html" title="Function template all_of_equal"><span class="identifier">all_of_equal</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.cxx11.any_of_hpp"></a>Header &lt;<a href="../../../boost/algorithm/cxx11/any_of.hpp" target="_top">boost/algorithm/cxx11/any_of.hpp</a>&gt;</h3></div></div></div>
-<p>Test ranges to see if any elements match a value or predicate. </p>
-<p>Marshall Clow </p>
-<p>
-</p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/any_of_idp422752368.html" title="Function template any_of"><span class="identifier">any_of</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/any_of_idp422758672.html" title="Function template any_of"><span class="identifier">any_of</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> V<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/any_of_equal_idp422763968.html" title="Function template any_of_equal"><span class="identifier">any_of_equal</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">V</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> V<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/any_of_equal_idp422770272.html" title="Function template any_of_equal"><span class="identifier">any_of_equal</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">V</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.cxx11.copy_if_hpp"></a>Header &lt;<a href="../../../boost/algorithm/cxx11/copy_if.hpp" target="_top">boost/algorithm/cxx11/copy_if.hpp</a>&gt;</h3></div></div></div>
-<p>Copy a subset of a sequence to a new sequence. </p>
-<p>Marshall Clow </p>
-<p>
-</p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">,</span>
- <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="identifier">OutputIterator</span>
- <a class="link" href="../boost/algorithm/copy_if_idp422778208.html" title="Function template copy_if"><span class="identifier">copy_if</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">,</span> <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="identifier">OutputIterator</span> <a class="link" href="../boost/algorithm/copy_if_idp422786384.html" title="Function template copy_if"><span class="identifier">copy_if</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">,</span>
- <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="special">&gt;</span>
- <a class="link" href="../boost/algorithm/copy_while_idp422793040.html" title="Function template copy_while"><span class="identifier">copy_while</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">,</span> <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="special">&gt;</span>
- <a class="link" href="../boost/algorithm/copy_while_idp422800720.html" title="Function template copy_while"><span class="identifier">copy_while</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">,</span>
- <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="special">&gt;</span>
- <a class="link" href="../boost/algorithm/copy_until_idp422807392.html" title="Function template copy_until"><span class="identifier">copy_until</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">,</span> <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="special">&gt;</span>
- <a class="link" href="../boost/algorithm/copy_until_idp422815072.html" title="Function template copy_until"><span class="identifier">copy_until</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.cxx11.copy_n_hpp"></a>Header &lt;<a href="../../../boost/algorithm/cxx11/copy_n.hpp" target="_top">boost/algorithm/cxx11/copy_n.hpp</a>&gt;</h3></div></div></div>
-<p>Copy n items from one sequence to another. </p>
-<p>Marshall Clow </p>
-<p>
-</p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> Size<span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">&gt;</span>
- <span class="identifier">OutputIterator</span> <a class="link" href="../boost/algorithm/copy_n.html" title="Function template copy_n"><span class="identifier">copy_n</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">Size</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.cxx11.find_if_not_hpp"></a>Header &lt;<a href="../../../boost/algorithm/cxx11/find_if_not.hpp" target="_top">boost/algorithm/cxx11/find_if_not.hpp</a>&gt;</h3></div></div></div>
-<p>Find the first element in a sequence that does not satisfy a predicate. </p>
-<p>Marshall Clow </p>
-<p>
-</p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="identifier">InputIterator</span> <a class="link" href="../boost/algorithm/find_if_not_idp422834192.html" title="Function template find_if_not"><span class="identifier">find_if_not</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a class="link" href="../boost/algorithm/find_if_not_idp422840752.html" title="Function template find_if_not"><span class="identifier">find_if_not</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.cxx11.iota_hpp"></a>Header &lt;<a href="../../../boost/algorithm/cxx11/iota.hpp" target="_top">boost/algorithm/cxx11/iota.hpp</a>&gt;</h3></div></div></div>
-<p>Generate an increasing series. </p>
-<p>Marshall Clow </p>
-<p>
-</p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator</a><span class="special">,</span> <span class="keyword">typename</span> T<span class="special">&gt;</span>
- <span class="keyword">void</span> <a class="link" href="../boost/algorithm/iota_idp422848432.html" title="Function template iota"><span class="identifier">iota</span></a><span class="special">(</span><span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">T</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> T<span class="special">&gt;</span> <span class="keyword">void</span> <a class="link" href="../boost/algorithm/iota_idp422854608.html" title="Function template iota"><span class="identifier">iota</span></a><span class="special">(</span><span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">,</span> <span class="keyword">typename</span> T<span class="special">&gt;</span>
- <span class="identifier">OutputIterator</span> <a class="link" href="../boost/algorithm/iota_n.html" title="Function template iota_n"><span class="identifier">iota_n</span></a><span class="special">(</span><span class="identifier">OutputIterator</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.cxx11.is_partitioned_hpp"></a>Header &lt;<a href="../../../boost/algorithm/cxx11/is_partitioned.hpp" target="_top">boost/algorithm/cxx11/is_partitioned.hpp</a>&gt;</h3></div></div></div>
-<p>Tell if a sequence is partitioned. </p>
-<p>Marshall Clow </p>
-<p>
-</p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> UnaryPredicate<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_partitione_idp422867568.html" title="Function template is_partitioned"><span class="identifier">is_partitioned</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">UnaryPredicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> UnaryPredicate<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_partitione_idp422873744.html" title="Function template is_partitioned"><span class="identifier">is_partitioned</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">UnaryPredicate</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.cxx11.is_permutation_hpp"></a>Header &lt;<a href="../../../boost/algorithm/cxx11/is_permutation.hpp" target="_top">boost/algorithm/cxx11/is_permutation.hpp</a>&gt;</h3></div></div></div>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator1</a><span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator2</a><span class="special">,</span>
- <span class="keyword">typename</span> BinaryPredicate<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_permutatio_idp422880272.html" title="Function template is_permutation"><span class="identifier">is_permutation</span></a><span class="special">(</span><span class="identifier">ForwardIterator1</span><span class="special">,</span> <span class="identifier">ForwardIterator1</span><span class="special">,</span>
- <span class="identifier">ForwardIterator2</span><span class="special">,</span> <span class="identifier">BinaryPredicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator1</a><span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator2</a><span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_permutatio_idp422888064.html" title="Function template is_permutation"><span class="identifier">is_permutation</span></a><span class="special">(</span><span class="identifier">ForwardIterator1</span><span class="special">,</span> <span class="identifier">ForwardIterator1</span><span class="special">,</span>
- <span class="identifier">ForwardIterator2</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator</a><span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_permutatio_idp422893968.html" title="Function template is_permutation"><span class="identifier">is_permutation</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">ForwardIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator</a><span class="special">,</span>
- <span class="keyword">typename</span> BinaryPredicate<span class="special">&gt;</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">disable_if_c</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span> <span class="identifier">Range</span><span class="special">,</span> <span class="identifier">ForwardIterator</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">,</span> <span class="keyword">bool</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a class="link" href="../boost/algorithm/is_permutatio_idp422898736.html" title="Function template is_permutation"><span class="identifier">is_permutation</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">BinaryPredicate</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.cxx14.is_permutation_hpp"></a>Header &lt;<a href="../../../boost/algorithm/cxx14/is_permutation.hpp" target="_top">boost/algorithm/cxx14/is_permutation.hpp</a>&gt;</h3></div></div></div>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator1</a><span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator2</a><span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_permutatio_idp422907008.html" title="Function template is_permutation"><span class="identifier">is_permutation</span></a><span class="special">(</span><span class="identifier">ForwardIterator1</span><span class="special">,</span> <span class="identifier">ForwardIterator1</span><span class="special">,</span>
- <span class="identifier">ForwardIterator2</span><span class="special">,</span> <span class="identifier">ForwardIterator2</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator1</a><span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator2</a><span class="special">,</span>
- <span class="keyword">typename</span> BinaryPredicate<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_permutatio_idp422914304.html" title="Function template is_permutation"><span class="identifier">is_permutation</span></a><span class="special">(</span><span class="identifier">ForwardIterator1</span><span class="special">,</span> <span class="identifier">ForwardIterator1</span><span class="special">,</span>
- <span class="identifier">ForwardIterator2</span><span class="special">,</span> <span class="identifier">ForwardIterator2</span><span class="special">,</span>
- <span class="identifier">BinaryPredicate</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.cxx11.is_sorted_hpp"></a>Header &lt;<a href="../../../boost/algorithm/cxx11/is_sorted.hpp" target="_top">boost/algorithm/cxx11/is_sorted.hpp</a>&gt;</h3></div></div></div>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator</a><span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">&gt;</span>
- <span class="identifier">ForwardIterator</span> <a class="link" href="../boost/algorithm/is_sorted_unt_idp422924976.html" title="Function template is_sorted_until"><span class="identifier">is_sorted_until</span></a><span class="special">(</span><span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator</a><span class="special">&gt;</span>
- <span class="identifier">ForwardIterator</span> <a class="link" href="../boost/algorithm/is_sorted_unt_idp422930896.html" title="Function template is_sorted_until"><span class="identifier">is_sorted_until</span></a><span class="special">(</span><span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">ForwardIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator</a><span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_sorted_idp422935184.html" title="Function template is_sorted"><span class="identifier">is_sorted</span></a><span class="special">(</span><span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator</a><span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_sorted_idp422940976.html" title="Function template is_sorted"><span class="identifier">is_sorted</span></a><span class="special">(</span><span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">ForwardIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> R<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">&gt;</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">lazy_disable_if_c</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span> <span class="identifier">R</span><span class="special">,</span> <span class="identifier">Pred</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">R</span> <span class="special">&gt;</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a class="link" href="../boost/algorithm/is_sorted_unt_idp422945264.html" title="Function template is_sorted_until"><span class="identifier">is_sorted_until</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">R</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> R<span class="special">&gt;</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">R</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <a class="link" href="../boost/algorithm/is_sorted_unt_idp422950288.html" title="Function template is_sorted_until"><span class="identifier">is_sorted_until</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">R</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> R<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">&gt;</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">lazy_disable_if_c</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span> <span class="identifier">R</span><span class="special">,</span> <span class="identifier">Pred</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">identity</span><span class="special">&lt;</span> <span class="keyword">bool</span> <span class="special">&gt;</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a class="link" href="../boost/algorithm/is_sorted_idp422953568.html" title="Function template is_sorted"><span class="identifier">is_sorted</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">R</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> R<span class="special">&gt;</span> <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_sorted_idp422958576.html" title="Function template is_sorted"><span class="identifier">is_sorted</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">R</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator</a><span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_increasing_idp422961856.html" title="Function template is_increasing"><span class="identifier">is_increasing</span></a><span class="special">(</span><span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">ForwardIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> R<span class="special">&gt;</span> <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_increasing_idp422966944.html" title="Function template is_increasing"><span class="identifier">is_increasing</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">R</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator</a><span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_decreasing_idp422971024.html" title="Function template is_decreasing"><span class="identifier">is_decreasing</span></a><span class="special">(</span><span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">ForwardIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> R<span class="special">&gt;</span> <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_decreasing_idp422976112.html" title="Function template is_decreasing"><span class="identifier">is_decreasing</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">R</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator</a><span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_strictly_i_idp422980192.html" title="Function template is_strictly_increasing"><span class="identifier">is_strictly_increasing</span></a><span class="special">(</span><span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">ForwardIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> R<span class="special">&gt;</span> <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_strictly_i_idp422985280.html" title="Function template is_strictly_increasing"><span class="identifier">is_strictly_increasing</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">R</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator</a><span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_strictly_d_idp422989360.html" title="Function template is_strictly_decreasing"><span class="identifier">is_strictly_decreasing</span></a><span class="special">(</span><span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">ForwardIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> R<span class="special">&gt;</span> <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_strictly_d_idp422994448.html" title="Function template is_strictly_decreasing"><span class="identifier">is_strictly_decreasing</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">R</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.cxx11.none_of_hpp"></a>Header &lt;<a href="../../../boost/algorithm/cxx11/none_of.hpp" target="_top">boost/algorithm/cxx11/none_of.hpp</a>&gt;</h3></div></div></div>
-<p>Test ranges to see if no elements match a value or predicate. </p>
-<p>Marshall Clow </p>
-<p>
-</p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/none_of_idp423001280.html" title="Function template none_of"><span class="identifier">none_of</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/none_of_idp423007584.html" title="Function template none_of"><span class="identifier">none_of</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> V<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/none_of_equal_idp423012880.html" title="Function template none_of_equal"><span class="identifier">none_of_equal</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">V</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> V<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/none_of_equal_idp423019184.html" title="Function template none_of_equal"><span class="identifier">none_of_equal</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">V</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.cxx11.one_of_hpp"></a>Header &lt;<a href="../../../boost/algorithm/cxx11/one_of.hpp" target="_top">boost/algorithm/cxx11/one_of.hpp</a>&gt;</h3></div></div></div>
-<p>Test ranges to see if only one element matches a value or predicate. </p>
-<p>Marshall Clow </p>
-<p>
-</p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/one_of_idp423027232.html" title="Function template one_of"><span class="identifier">one_of</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/one_of_idp423033024.html" title="Function template one_of"><span class="identifier">one_of</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> V<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/one_of_equal_idp423037808.html" title="Function template one_of_equal"><span class="identifier">one_of_equal</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">V</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> V<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/one_of_equal_idp423043600.html" title="Function template one_of_equal"><span class="identifier">one_of_equal</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">V</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.cxx11.partition_copy_hpp"></a>Header &lt;<a href="../../../boost/algorithm/cxx11/partition_copy.hpp" target="_top">boost/algorithm/cxx11/partition_copy.hpp</a>&gt;</h3></div></div></div>
-<p>Copy a subset of a sequence to a new sequence. </p>
-<p>Marshall Clow </p>
-<p>
-</p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator1</a><span class="special">,</span>
- <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator2</a><span class="special">,</span> <span class="keyword">typename</span> UnaryPredicate<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">OutputIterator1</span><span class="special">,</span> <span class="identifier">OutputIterator2</span> <span class="special">&gt;</span>
- <a class="link" href="../boost/algorithm/partition_cop_idp423051136.html" title="Function template partition_copy"><span class="identifier">partition_copy</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">OutputIterator1</span><span class="special">,</span>
- <span class="identifier">OutputIterator2</span><span class="special">,</span> <span class="identifier">UnaryPredicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator1</a><span class="special">,</span>
- <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator2</a><span class="special">,</span> <span class="keyword">typename</span> UnaryPredicate<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">OutputIterator1</span><span class="special">,</span> <span class="identifier">OutputIterator2</span> <span class="special">&gt;</span>
- <a class="link" href="../boost/algorithm/partition_cop_idp423060544.html" title="Function template partition_copy"><span class="identifier">partition_copy</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">OutputIterator1</span><span class="special">,</span> <span class="identifier">OutputIterator2</span><span class="special">,</span>
- <span class="identifier">UnaryPredicate</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.cxx11.partition_point_hpp"></a>Header &lt;<a href="../../../boost/algorithm/cxx11/partition_point.hpp" target="_top">boost/algorithm/cxx11/partition_point.hpp</a>&gt;</h3></div></div></div>
-<p>Find the partition point in a sequence. </p>
-<p>Marshall Clow </p>
-<p>
-</p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../ForwardIterator.html" title="Concept ForwardIterator">ForwardIterator</a><span class="special">,</span> <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="identifier">ForwardIterator</span>
- <a class="link" href="../boost/algorithm/partition_poi_idp423070720.html" title="Function template partition_point"><span class="identifier">partition_point</span></a><span class="special">(</span><span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">ForwardIterator</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">Range</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <a class="link" href="../boost/algorithm/partition_poi_idp423077024.html" title="Function template partition_point"><span class="identifier">partition_point</span></a><span class="special">(</span><span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.cxx14.equal_hpp"></a>Header &lt;<a href="../../../boost/algorithm/cxx14/equal.hpp" target="_top">boost/algorithm/cxx14/equal.hpp</a>&gt;</h3></div></div></div>
-<p>Test ranges to if they are equal. </p>
-<p>Marshall Clow </p>
-<p>
-</p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator1</a><span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator2</a><span class="special">,</span>
- <span class="keyword">typename</span> BinaryPredicate<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/equal_idp423084448.html" title="Function template equal"><span class="identifier">equal</span></a><span class="special">(</span><span class="identifier">InputIterator1</span><span class="special">,</span> <span class="identifier">InputIterator1</span><span class="special">,</span> <span class="identifier">InputIterator2</span><span class="special">,</span>
- <span class="identifier">InputIterator2</span><span class="special">,</span> <span class="identifier">BinaryPredicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator1</a><span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator2</a><span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/equal_idp423092752.html" title="Function template equal"><span class="identifier">equal</span></a><span class="special">(</span><span class="identifier">InputIterator1</span><span class="special">,</span> <span class="identifier">InputIterator1</span><span class="special">,</span> <span class="identifier">InputIterator2</span><span class="special">,</span>
- <span class="identifier">InputIterator2</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.cxx14.mismatch_hpp"></a>Header &lt;<a href="../../../boost/algorithm/cxx14/mismatch.hpp" target="_top">boost/algorithm/cxx14/mismatch.hpp</a>&gt;</h3></div></div></div>
-<p>Find the first mismatched element in a sequence. </p>
-<p>Marshall Clow </p>
-<p>
-</p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator1</a><span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator2</a><span class="special">,</span>
- <span class="keyword">typename</span> BinaryPredicate<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">InputIterator1</span><span class="special">,</span> <span class="identifier">InputIterator2</span> <span class="special">&gt;</span>
- <a class="link" href="../boost/algorithm/mismatch_idp423102320.html" title="Function template mismatch"><span class="identifier">mismatch</span></a><span class="special">(</span><span class="identifier">InputIterator1</span><span class="special">,</span> <span class="identifier">InputIterator1</span><span class="special">,</span> <span class="identifier">InputIterator2</span><span class="special">,</span> <span class="identifier">InputIterator2</span><span class="special">,</span>
- <span class="identifier">BinaryPredicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator1</a><span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator2</a><span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">InputIterator1</span><span class="special">,</span> <span class="identifier">InputIterator2</span> <span class="special">&gt;</span>
- <a class="link" href="../boost/algorithm/mismatch_idp423110624.html" title="Function template mismatch"><span class="identifier">mismatch</span></a><span class="special">(</span><span class="identifier">InputIterator1</span><span class="special">,</span> <span class="identifier">InputIterator1</span><span class="special">,</span> <span class="identifier">InputIterator2</span><span class="special">,</span> <span class="identifier">InputIterator2</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.gather_hpp"></a>Header &lt;<a href="../../../boost/algorithm/gather.hpp" target="_top">boost/algorithm/gather.hpp</a>&gt;</h3></div></div></div>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
-
- <span class="comment">// iterator-based gather implementation </span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../BidirectionalIterator.html" title="Concept BidirectionalIterator">BidirectionalIterator</a><span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="identifier">BidirectionalIterator</span> <span class="special">&gt;</span>
- <a name="boost.algorithm.gather_idp423119296"></a><span class="identifier">gather</span><span class="special">(</span><span class="identifier">BidirectionalIterator</span> first<span class="special">,</span> <span class="identifier">BidirectionalIterator</span> last<span class="special">,</span>
- <span class="identifier">BidirectionalIterator</span> pivot<span class="special">,</span> <span class="identifier">Pred</span> pred<span class="special">)</span><span class="special">;</span>
-
- <span class="comment">// range-based gather implementation </span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> BidirectionalRange<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">BidirectionalRange</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">BidirectionalRange</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span>
- <a name="boost.algorithm.gather_idp423124048"></a><span class="identifier">gather</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">BidirectionalRange</span> <span class="special">&amp;</span> range<span class="special">,</span>
- <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">BidirectionalRange</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> pivot<span class="special">,</span>
- <span class="identifier">Pred</span> pred<span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.hex_hpp"></a>Header &lt;<a href="../../../boost/algorithm/hex.hpp" target="_top">boost/algorithm/hex.hpp</a>&gt;</h3></div></div></div>
-<p>Convert sequence of integral types into a sequence of hexadecimal characters and back. Based on the MySQL functions HEX and UNHEX. </p>
-<p>Marshall Clow </p>
-<p>
-</p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">struct</span> <a class="link" href="../boost/algorithm/hex_decode_error.html" title="Struct hex_decode_error">hex_decode_error</a><span class="special">;</span>
- <span class="keyword">struct</span> <a class="link" href="../boost/algorithm/not_enough_input.html" title="Struct not_enough_input">not_enough_input</a><span class="special">;</span>
- <span class="keyword">struct</span> <a class="link" href="../boost/algorithm/non_hex_input.html" title="Struct non_hex_input">non_hex_input</a><span class="special">;</span>
-
- <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">error_info</span><span class="special">&lt;</span> <span class="keyword">struct</span> <span class="identifier">bad_char_</span><span class="special">,</span> <span class="keyword">char</span> <span class="special">&gt;</span> <a name="boost.algorithm.bad_char"></a><span class="identifier">bad_char</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">&gt;</span>
- <span class="emphasis"><em><span class="identifier">unspecified</span></em></span> <a class="link" href="../boost/algorithm/hex_idp423135952.html" title="Function template hex"><span class="identifier">hex</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">&gt;</span>
- <span class="emphasis"><em><span class="identifier">unspecified</span></em></span> <a class="link" href="../boost/algorithm/hex_lower_idp423142640.html" title="Function template hex_lower"><span class="identifier">hex_lower</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">&gt;</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">enable_if</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_integral</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a class="link" href="../boost/algorithm/hex_idp423149440.html" title="Function template hex"><span class="identifier">hex</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span> <span class="special">*</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">&gt;</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">enable_if</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_integral</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a class="link" href="../boost/algorithm/hex_lower_idp423154992.html" title="Function template hex_lower"><span class="identifier">hex_lower</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span> <span class="special">*</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">&gt;</span>
- <span class="emphasis"><em><span class="identifier">unspecified</span></em></span> <a class="link" href="../boost/algorithm/hex_idp423160656.html" title="Function template hex"><span class="identifier">hex</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">&gt;</span>
- <span class="emphasis"><em><span class="identifier">unspecified</span></em></span> <a class="link" href="../boost/algorithm/hex_lower_idp423166336.html" title="Function template hex_lower"><span class="identifier">hex_lower</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../InputIterator.html" title="Concept InputIterator">InputIterator</a><span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">&gt;</span>
- <span class="identifier">OutputIterator</span> <a class="link" href="../boost/algorithm/unhex_idp423172128.html" title="Function template unhex"><span class="identifier">unhex</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">&gt;</span>
- <span class="identifier">OutputIterator</span> <a class="link" href="../boost/algorithm/unhex_idp423178688.html" title="Function template unhex"><span class="identifier">unhex</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span> <span class="special">*</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">,</span> <span class="keyword">typename</span> <a class="link" href="../OutputIterator.html" title="Concept OutputIterator">OutputIterator</a><span class="special">&gt;</span>
- <span class="identifier">OutputIterator</span> <a class="link" href="../boost/algorithm/unhex_idp423184240.html" title="Function template unhex"><span class="identifier">unhex</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">OutputIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> String<span class="special">&gt;</span> <span class="identifier">String</span> <a class="link" href="../boost/algorithm/hex_idp423189792.html" title="Function template hex"><span class="identifier">hex</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">String</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> String<span class="special">&gt;</span> <span class="identifier">String</span> <a class="link" href="../boost/algorithm/hex_lower_idp423193328.html" title="Function template hex_lower"><span class="identifier">hex_lower</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">String</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> String<span class="special">&gt;</span> <span class="identifier">String</span> <a class="link" href="../boost/algorithm/unhex_idp423196976.html" title="Function template unhex"><span class="identifier">unhex</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">String</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.is_palindrome_hpp"></a>Header &lt;<a href="../../../boost/algorithm/is_palindrome.hpp" target="_top">boost/algorithm/is_palindrome.hpp</a>&gt;</h3></div></div></div>
-<p>Checks the input sequence on palindrome. </p>
-<p>Alexander Zaitsev </p>
-<p>
-</p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../BidirectionalIterator.html" title="Concept BidirectionalIterator">BidirectionalIterator</a><span class="special">,</span> <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_palindrome_idp423203264.html" title="Function template is_palindrome"><span class="identifier">is_palindrome</span></a><span class="special">(</span><span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span>
- <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <a class="link" href="../BidirectionalIterator.html" title="Concept BidirectionalIterator">BidirectionalIterator</a><span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_palindrome_idp423209728.html" title="Function template is_palindrome"><span class="identifier">is_palindrome</span></a><span class="special">(</span><span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="identifier">BidirectionalIterator</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> R<span class="special">&gt;</span> <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_palindrome_idp423214688.html" title="Function template is_palindrome"><span class="identifier">is_palindrome</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">R</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> R<span class="special">,</span> <span class="keyword">typename</span> Predicate<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_palindrome_idp423218640.html" title="Function template is_palindrome"><span class="identifier">is_palindrome</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">R</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_palindrome_idp423224096.html" title="Function is_palindrome"><span class="identifier">is_palindrome</span></a><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span> <span class="special">*</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Predicate<span class="special">&gt;</span> <span class="keyword">bool</span> <a class="link" href="../boost/algorithm/is_palindrome_idp423227296.html" title="Function template is_palindrome"><span class="identifier">is_palindrome</span></a><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span> <span class="special">*</span><span class="special">,</span> <span class="identifier">Predicate</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.minmax_hpp"></a>Header &lt;<a href="../../../boost/algorithm/minmax.hpp" target="_top">boost/algorithm/minmax.hpp</a>&gt;</h3></div></div></div>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span>
- <span class="identifier">tuple</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="special">&gt;</span> <a name="boost.minmax_idp423233632"></a><span class="identifier">minmax</span><span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span> <span class="special">&amp;</span> a<span class="special">,</span> <span class="identifier">T</span> <span class="keyword">const</span> <span class="special">&amp;</span> b<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> BinaryPredicate<span class="special">&gt;</span>
- <span class="identifier">tuple</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="special">&gt;</span>
- <a name="boost.minmax_idp423236384"></a><span class="identifier">minmax</span><span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span> <span class="special">&amp;</span> a<span class="special">,</span> <span class="identifier">T</span> <span class="keyword">const</span> <span class="special">&amp;</span> b<span class="special">,</span> <span class="identifier">BinaryPredicate</span> comp<span class="special">)</span><span class="special">;</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.minmax_element_hpp"></a>Header &lt;<a href="../../../boost/algorithm/minmax_element.hpp" target="_top">boost/algorithm/minmax_element.hpp</a>&gt;</h3></div></div></div>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">ForwardIter</span><span class="special">,</span> <span class="identifier">ForwardIter</span> <span class="special">&gt;</span>
- <a name="boost.minmax_elemen_idp423241504"></a><span class="identifier">minmax_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">,</span> <span class="keyword">typename</span> BinaryPredicate<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">ForwardIter</span><span class="special">,</span> <span class="identifier">ForwardIter</span> <span class="special">&gt;</span>
- <a name="boost.minmax_elemen_idp423244256"></a><span class="identifier">minmax_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">,</span> <span class="identifier">BinaryPredicate</span> comp<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">&gt;</span>
- <span class="identifier">ForwardIter</span> <a name="boost.first_min_ele_idp423248128"></a><span class="identifier">first_min_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">,</span> <span class="keyword">typename</span> BinaryPredicate<span class="special">&gt;</span>
- <span class="identifier">ForwardIter</span> <a name="boost.first_min_ele_idp423250880"></a><span class="identifier">first_min_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">,</span>
- <span class="identifier">BinaryPredicate</span> comp<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">&gt;</span>
- <span class="identifier">ForwardIter</span> <a name="boost.last_min_elem_idp423254752"></a><span class="identifier">last_min_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">,</span> <span class="keyword">typename</span> BinaryPredicate<span class="special">&gt;</span>
- <span class="identifier">ForwardIter</span> <a name="boost.last_min_elem_idp423257504"></a><span class="identifier">last_min_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">,</span>
- <span class="identifier">BinaryPredicate</span> comp<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">&gt;</span>
- <span class="identifier">ForwardIter</span> <a name="boost.first_max_ele_idp423261376"></a><span class="identifier">first_max_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">,</span> <span class="keyword">typename</span> BinaryPredicate<span class="special">&gt;</span>
- <span class="identifier">ForwardIter</span> <a name="boost.first_max_ele_idp423264128"></a><span class="identifier">first_max_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">,</span>
- <span class="identifier">BinaryPredicate</span> comp<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">&gt;</span>
- <span class="identifier">ForwardIter</span> <a name="boost.last_max_elem_idp423268000"></a><span class="identifier">last_max_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">,</span> <span class="keyword">typename</span> BinaryPredicate<span class="special">&gt;</span>
- <span class="identifier">ForwardIter</span> <a name="boost.last_max_elem_idp423270752"></a><span class="identifier">last_max_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">,</span>
- <span class="identifier">BinaryPredicate</span> comp<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">ForwardIter</span><span class="special">,</span> <span class="identifier">ForwardIter</span> <span class="special">&gt;</span>
- <a name="boost.first_min_fir_idp423274624"></a><span class="identifier">first_min_first_max_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">,</span> <span class="keyword">typename</span> BinaryPredicate<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">ForwardIter</span><span class="special">,</span> <span class="identifier">ForwardIter</span> <span class="special">&gt;</span>
- <a name="boost.first_min_fir_idp423277376"></a><span class="identifier">first_min_first_max_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">,</span>
- <span class="identifier">BinaryPredicate</span> comp<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">ForwardIter</span><span class="special">,</span> <span class="identifier">ForwardIter</span> <span class="special">&gt;</span>
- <a name="boost.first_min_las_idp423281248"></a><span class="identifier">first_min_last_max_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">,</span> <span class="keyword">typename</span> BinaryPredicate<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">ForwardIter</span><span class="special">,</span> <span class="identifier">ForwardIter</span> <span class="special">&gt;</span>
- <a name="boost.first_min_las_idp423284000"></a><span class="identifier">first_min_last_max_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">,</span>
- <span class="identifier">BinaryPredicate</span> comp<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">ForwardIter</span><span class="special">,</span> <span class="identifier">ForwardIter</span> <span class="special">&gt;</span>
- <a name="boost.last_min_firs_idp423287872"></a><span class="identifier">last_min_first_max_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">,</span> <span class="keyword">typename</span> BinaryPredicate<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">ForwardIter</span><span class="special">,</span> <span class="identifier">ForwardIter</span> <span class="special">&gt;</span>
- <a name="boost.last_min_firs_idp423290624"></a><span class="identifier">last_min_first_max_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">,</span>
- <span class="identifier">BinaryPredicate</span> comp<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">ForwardIter</span><span class="special">,</span> <span class="identifier">ForwardIter</span> <span class="special">&gt;</span>
- <a name="boost.last_min_last_idp423294496"></a><span class="identifier">last_min_last_max_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ForwardIter<span class="special">,</span> <span class="keyword">typename</span> BinaryPredicate<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">ForwardIter</span><span class="special">,</span> <span class="identifier">ForwardIter</span> <span class="special">&gt;</span>
- <a name="boost.last_min_last_idp423297248"></a><span class="identifier">last_min_last_max_element</span><span class="special">(</span><span class="identifier">ForwardIter</span> first<span class="special">,</span> <span class="identifier">ForwardIter</span> last<span class="special">,</span>
- <span class="identifier">BinaryPredicate</span> comp<span class="special">)</span><span class="special">;</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.searching.boyer_moore_hpp"></a>Header &lt;<a href="../../../boost/algorithm/searching/boyer_moore.hpp" target="_top">boost/algorithm/searching/boyer_moore.hpp</a>&gt;</h3></div></div></div>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> patIter<span class="special">,</span> <span class="keyword">typename</span> traits <span class="special">=</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">BM_traits</span><span class="special">&lt;</span><span class="identifier">patIter</span><span class="special">&gt;</span> <span class="special">&gt;</span>
- <span class="keyword">class</span> <a class="link" href="../boost/algorithm/boyer_moore.html" title="Class template boyer_moore">boyer_moore</a><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> patIter<span class="special">,</span> <span class="keyword">typename</span> corpusIter<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">corpusIter</span><span class="special">,</span> <span class="identifier">corpusIter</span> <span class="special">&gt;</span>
- <a class="link" href="../boost/algorithm/boyer_moore_s_idp423312736.html" title="Function template boyer_moore_search"><span class="identifier">boyer_moore_search</span></a><span class="special">(</span><span class="identifier">corpusIter</span><span class="special">,</span> <span class="identifier">corpusIter</span><span class="special">,</span> <span class="identifier">patIter</span><span class="special">,</span> <span class="identifier">patIter</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> PatternRange<span class="special">,</span> <span class="keyword">typename</span> corpusIter<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">corpusIter</span><span class="special">,</span> <span class="identifier">corpusIter</span> <span class="special">&gt;</span>
- <a name="boost.algorithm.boyer_moore_s_idp423319408"></a><span class="identifier">boyer_moore_search</span><span class="special">(</span><span class="identifier">corpusIter</span> corpus_first<span class="special">,</span> <span class="identifier">corpusIter</span> corpus_last<span class="special">,</span>
- <span class="keyword">const</span> <span class="identifier">PatternRange</span> <span class="special">&amp;</span> pattern<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> patIter<span class="special">,</span> <span class="keyword">typename</span> CorpusRange<span class="special">&gt;</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">disable_if_c</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span> <span class="identifier">CorpusRange</span><span class="special">,</span> <span class="identifier">patIter</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">CorpusRange</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">CorpusRange</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a name="boost.algorithm.boyer_moore_s_idp423323280"></a><span class="identifier">boyer_moore_search</span><span class="special">(</span><span class="identifier">CorpusRange</span> <span class="special">&amp;</span> corpus<span class="special">,</span> <span class="identifier">patIter</span> pat_first<span class="special">,</span>
- <span class="identifier">patIter</span> pat_last<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> PatternRange<span class="special">,</span> <span class="keyword">typename</span> CorpusRange<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">CorpusRange</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">CorpusRange</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span>
- <a name="boost.algorithm.boyer_moore_s_idp423327360"></a><span class="identifier">boyer_moore_search</span><span class="special">(</span><span class="identifier">CorpusRange</span> <span class="special">&amp;</span> corpus<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">PatternRange</span> <span class="special">&amp;</span> pattern<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">&gt;</span>
- <a class="link" href="../boost/algorithm/boyer_moore.html" title="Class template boyer_moore">boost::algorithm::boyer_moore</a><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span>
- <a name="boost.algorithm.make_boyer_mo_idp423330736"></a><span class="identifier">make_boyer_moore</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span> r<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">&gt;</span>
- <a class="link" href="../boost/algorithm/boyer_moore.html" title="Class template boyer_moore">boost::algorithm::boyer_moore</a><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">Range</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span>
- <a name="boost.algorithm.make_boyer_mo_idp423333120"></a><span class="identifier">make_boyer_moore</span><span class="special">(</span><span class="identifier">Range</span> <span class="special">&amp;</span> r<span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.searching.boyer_moore_horspool_hpp"></a>Header &lt;<a href="../../../boost/algorithm/searching/boyer_moore_horspool.hpp" target="_top">boost/algorithm/searching/boyer_moore_horspool.hpp</a>&gt;</h3></div></div></div>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> patIter<span class="special">,</span> <span class="keyword">typename</span> traits <span class="special">=</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">BM_traits</span><span class="special">&lt;</span><span class="identifier">patIter</span><span class="special">&gt;</span> <span class="special">&gt;</span>
- <span class="keyword">class</span> <a class="link" href="../boost/algorithm/boyer_moore_horspool.html" title="Class template boyer_moore_horspool">boyer_moore_horspool</a><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> patIter<span class="special">,</span> <span class="keyword">typename</span> corpusIter<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">corpusIter</span><span class="special">,</span> <span class="identifier">corpusIter</span> <span class="special">&gt;</span>
- <a class="link" href="../boost/algorithm/boyer_moore_h_idp423347248.html" title="Function template boyer_moore_horspool_search"><span class="identifier">boyer_moore_horspool_search</span></a><span class="special">(</span><span class="identifier">corpusIter</span><span class="special">,</span> <span class="identifier">corpusIter</span><span class="special">,</span> <span class="identifier">patIter</span><span class="special">,</span> <span class="identifier">patIter</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> PatternRange<span class="special">,</span> <span class="keyword">typename</span> corpusIter<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">corpusIter</span><span class="special">,</span> <span class="identifier">corpusIter</span> <span class="special">&gt;</span>
- <a name="boost.algorithm.boyer_moore_h_idp423353920"></a><span class="identifier">boyer_moore_horspool_search</span><span class="special">(</span><span class="identifier">corpusIter</span> corpus_first<span class="special">,</span>
- <span class="identifier">corpusIter</span> corpus_last<span class="special">,</span>
- <span class="keyword">const</span> <span class="identifier">PatternRange</span> <span class="special">&amp;</span> pattern<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> patIter<span class="special">,</span> <span class="keyword">typename</span> CorpusRange<span class="special">&gt;</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">disable_if_c</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span> <span class="identifier">CorpusRange</span><span class="special">,</span> <span class="identifier">patIter</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">CorpusRange</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">CorpusRange</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a name="boost.algorithm.boyer_moore_h_idp423357792"></a><span class="identifier">boyer_moore_horspool_search</span><span class="special">(</span><span class="identifier">CorpusRange</span> <span class="special">&amp;</span> corpus<span class="special">,</span> <span class="identifier">patIter</span> pat_first<span class="special">,</span>
- <span class="identifier">patIter</span> pat_last<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> PatternRange<span class="special">,</span> <span class="keyword">typename</span> CorpusRange<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">CorpusRange</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">CorpusRange</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span>
- <a name="boost.algorithm.boyer_moore_h_idp423361872"></a><span class="identifier">boyer_moore_horspool_search</span><span class="special">(</span><span class="identifier">CorpusRange</span> <span class="special">&amp;</span> corpus<span class="special">,</span>
- <span class="keyword">const</span> <span class="identifier">PatternRange</span> <span class="special">&amp;</span> pattern<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">&gt;</span>
- <a class="link" href="../boost/algorithm/boyer_moore_horspool.html" title="Class template boyer_moore_horspool">boost::algorithm::boyer_moore_horspool</a><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span>
- <a name="boost.algorithm.make_boyer_mo_idp423365248"></a><span class="identifier">make_boyer_moore_horspool</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span> r<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">&gt;</span>
- <a class="link" href="../boost/algorithm/boyer_moore_horspool.html" title="Class template boyer_moore_horspool">boost::algorithm::boyer_moore_horspool</a><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">Range</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span>
- <a name="boost.algorithm.make_boyer_mo_idp423367632"></a><span class="identifier">make_boyer_moore_horspool</span><span class="special">(</span><span class="identifier">Range</span> <span class="special">&amp;</span> r<span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.searching.knuth_morris_pratt_hpp"></a>Header &lt;<a href="../../../boost/algorithm/searching/knuth_morris_pratt.hpp" target="_top">boost/algorithm/searching/knuth_morris_pratt.hpp</a>&gt;</h3></div></div></div>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> patIter<span class="special">&gt;</span> <span class="keyword">class</span> <a class="link" href="../boost/algorithm/knuth_morris_pratt.html" title="Class template knuth_morris_pratt">knuth_morris_pratt</a><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> patIter<span class="special">,</span> <span class="keyword">typename</span> corpusIter<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">corpusIter</span><span class="special">,</span> <span class="identifier">corpusIter</span> <span class="special">&gt;</span>
- <a class="link" href="../boost/algorithm/knuth_morris__idp423381008.html" title="Function template knuth_morris_pratt_search"><span class="identifier">knuth_morris_pratt_search</span></a><span class="special">(</span><span class="identifier">corpusIter</span><span class="special">,</span> <span class="identifier">corpusIter</span><span class="special">,</span> <span class="identifier">patIter</span><span class="special">,</span> <span class="identifier">patIter</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> PatternRange<span class="special">,</span> <span class="keyword">typename</span> corpusIter<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">corpusIter</span><span class="special">,</span> <span class="identifier">corpusIter</span> <span class="special">&gt;</span>
- <a name="boost.algorithm.knuth_morris__idp423387680"></a><span class="identifier">knuth_morris_pratt_search</span><span class="special">(</span><span class="identifier">corpusIter</span> corpus_first<span class="special">,</span>
- <span class="identifier">corpusIter</span> corpus_last<span class="special">,</span>
- <span class="keyword">const</span> <span class="identifier">PatternRange</span> <span class="special">&amp;</span> pattern<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> patIter<span class="special">,</span> <span class="keyword">typename</span> CorpusRange<span class="special">&gt;</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">disable_if_c</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span> <span class="identifier">CorpusRange</span><span class="special">,</span> <span class="identifier">patIter</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">CorpusRange</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">CorpusRange</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a name="boost.algorithm.knuth_morris__idp423391552"></a><span class="identifier">knuth_morris_pratt_search</span><span class="special">(</span><span class="identifier">CorpusRange</span> <span class="special">&amp;</span> corpus<span class="special">,</span> <span class="identifier">patIter</span> pat_first<span class="special">,</span>
- <span class="identifier">patIter</span> pat_last<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> PatternRange<span class="special">,</span> <span class="keyword">typename</span> CorpusRange<span class="special">&gt;</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">CorpusRange</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">CorpusRange</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span>
- <a name="boost.algorithm.knuth_morris__idp423395632"></a><span class="identifier">knuth_morris_pratt_search</span><span class="special">(</span><span class="identifier">CorpusRange</span> <span class="special">&amp;</span> corpus<span class="special">,</span>
- <span class="keyword">const</span> <span class="identifier">PatternRange</span> <span class="special">&amp;</span> pattern<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">&gt;</span>
- <a class="link" href="../boost/algorithm/knuth_morris_pratt.html" title="Class template knuth_morris_pratt">boost::algorithm::knuth_morris_pratt</a><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span>
- <a name="boost.algorithm.make_knuth_mo_idp423399008"></a><span class="identifier">make_knuth_morris_pratt</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Range</span> <span class="special">&amp;</span> r<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Range<span class="special">&gt;</span>
- <a class="link" href="../boost/algorithm/knuth_morris_pratt.html" title="Class template knuth_morris_pratt">boost::algorithm::knuth_morris_pratt</a><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">Range</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span>
- <a name="boost.algorithm.make_knuth_mo_idp423401392"></a><span class="identifier">make_knuth_morris_pratt</span><span class="special">(</span><span class="identifier">Range</span> <span class="special">&amp;</span> r<span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.sort_subrange_hpp"></a>Header &lt;<a href="../../../boost/algorithm/sort_subrange.hpp" target="_top">boost/algorithm/sort_subrange.hpp</a>&gt;</h3></div></div></div>
-<p>Sort a subrange. </p>
-<p>Marshall Clow</p>
-<p>
-Suggested by Sean Parent in his CppCon 2015 keynote </p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">namespace</span> <span class="identifier">algorithm</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">&gt;</span>
- <span class="keyword">void</span> <a name="boost.algorithm.sort_subrange_idp423406416"></a><span class="identifier">sort_subrange</span><span class="special">(</span><span class="identifier">Iterator</span> first<span class="special">,</span> <span class="identifier">Iterator</span> last<span class="special">,</span> <span class="identifier">Iterator</span> sub_first<span class="special">,</span>
- <span class="identifier">Iterator</span> sub_last<span class="special">,</span> <span class="identifier">Pred</span> p<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span>
- <span class="keyword">void</span> <a name="boost.algorithm.sort_subrange_idp423411536"></a><span class="identifier">sort_subrange</span><span class="special">(</span><span class="identifier">Iterator</span> first<span class="special">,</span> <span class="identifier">Iterator</span> last<span class="special">,</span> <span class="identifier">Iterator</span> sub_first<span class="special">,</span>
- <span class="identifier">Iterator</span> sub_last<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">&gt;</span>
- <span class="keyword">void</span> <a name="boost.algorithm.partition_sub_idp423415536"></a><span class="identifier">partition_subrange</span><span class="special">(</span><span class="identifier">Iterator</span> first<span class="special">,</span> <span class="identifier">Iterator</span> last<span class="special">,</span>
- <span class="identifier">Iterator</span> sub_first<span class="special">,</span> <span class="identifier">Iterator</span> sub_last<span class="special">,</span> <span class="identifier">Pred</span> p<span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span>
- <span class="keyword">void</span> <a name="boost.algorithm.partition_sub_idp423420656"></a><span class="identifier">partition_subrange</span><span class="special">(</span><span class="identifier">Iterator</span> first<span class="special">,</span> <span class="identifier">Iterator</span> last<span class="special">,</span>
- <span class="identifier">Iterator</span> sub_first<span class="special">,</span> <span class="identifier">Iterator</span> sub_last<span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.string_hpp"></a>Header &lt;<a href="../../../boost/algorithm/string.hpp" target="_top">boost/algorithm/string.hpp</a>&gt;</h3></div></div></div>
-<p>Cumulative include for string_algo library </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="header.boost.algorithm.string_regex_hpp"></a>Header &lt;<a href="../../../boost/algorithm/string_regex.hpp" target="_top">boost/algorithm/string_regex.hpp</a>&gt;</h3></div></div></div>
-<p>Cumulative include for string_algo library. In addition to string.hpp contains also regex-related stuff. </p>
-</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; 2010-2012 Marshall Clow<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="Misc.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../algorithm.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="../boost/algorithm/power_idp422669008.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>