libs/algorithm/doc/html/algorithm/CXX11.html

   1 <html>
   2 <head>
   3 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
   4 <title>C++11 Algorithms</title>
   5 <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
   6 <meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
   7 <link rel="home" href="../index.html" title="The Boost Algorithm Library">
   8 <link rel="up" href="../index.html" title="The Boost Algorithm Library">
   9 <link rel="prev" href="../the_boost_algorithm_library/Searching/KnuthMorrisPratt.html" title="Knuth-Morris-Pratt Search">
  10 <link rel="next" href="CXX14.html" title="C++14 Algorithms">
  11 </head>
  12 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
  13 <table cellpadding="2" width="100%"><tr>
  14 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
  15 <td align="center"><a href="../../../../../index.html">Home</a></td>
  16 <td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
  17 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
  18 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
  19 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
  20 </tr></table>
  21 <hr>
  22 <div class="spirit-nav">
  23 <a accesskey="p" href="../the_boost_algorithm_library/Searching/KnuthMorrisPratt.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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>
  24 </div>
  25 <div class="section">
  26 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
  27 <a name="algorithm.CXX11"></a><a class="link" href="CXX11.html" title="C++11 Algorithms">C++11 Algorithms</a>
  28 </h2></div></div></div>
  29 <div class="toc"><dl class="toc">
  30 <dt><span class="section"><a href="CXX11.html#algorithm.CXX11.CXX11_inner_algorithms"></a></span></dt>
  31 <dd><dl>
  32 <dt><span class="section"><a href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of">all_of</a></span></dt>
  33 <dt><span class="section"><a href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of">any_of</a></span></dt>
  34 <dt><span class="section"><a href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of">none_of</a></span></dt>
  35 <dt><span class="section"><a href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of">one_of</a></span></dt>
  36 <dt><span class="section"><a href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_sorted">is_sorted
  37         </a></span></dt>
  38 <dt><span class="section"><a href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned">is_partitioned
  39         </a></span></dt>
  40 <dt><span class="section"><a href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation">is_permutation
  41         </a></span></dt>
  42 <dt><span class="section"><a href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point">partition_point
  43         </a></span></dt>
  44 <dt><span class="section"><a href="CXX11.html#algorithm.CXX11.CXX11_inner_algorithms.partition_copy">partition_copy
  45         </a></span></dt>
  46 <dt><span class="section"><a href="CXX11.html#algorithm.CXX11.CXX11_inner_algorithms.copy_if">copy_if
  47         </a></span></dt>
  48 <dt><span class="section"><a href="CXX11.html#algorithm.CXX11.CXX11_inner_algorithms.copy_n">copy_n
  49         </a></span></dt>
  50 <dt><span class="section"><a href="CXX11.html#algorithm.CXX11.CXX11_inner_algorithms.iota">iota
  51         </a></span></dt>
  52 </dl></dd>
  53 </dl></div>
  54 <div class="section">
  55 <div class="titlepage"></div>
  56 <div class="section">
  57 <div class="titlepage"><div><div><h4 class="title">
  58 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of"></a><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of" title="all_of">all_of</a>
  59 </h4></div></div></div>
  60 <p>
  61           The header file 'boost/algorithm/cxx11/all_of.hpp' contains four variants
  62           of a single algorithm, <code class="computeroutput"><span class="identifier">all_of</span></code>.
  63           The algorithm tests all the elements of a sequence and returns true if
  64           they all share a property.
  65         </p>
  66 <p>
  67           The routine <code class="computeroutput"><span class="identifier">all_of</span></code> takes
  68           a sequence and a predicate. It will return true if the predicate returns
  69           true when applied to every element in the sequence.
  70         </p>
  71 <p>
  72           The routine <code class="computeroutput"><span class="identifier">all_of_equal</span></code>
  73           takes a sequence and a value. It will return true if every element in the
  74           sequence compares equal to the passed in value.
  75         </p>
  76 <p>
  77           Both routines come in two forms; the first one takes two iterators to define
  78           the range. The second form takes a single range parameter, and uses Boost.Range
  79           to traverse it.
  80         </p>
  81 <h6>
  82 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.h0"></a>
  83           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.interface"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.interface">interface</a>
  84         </h6>
  85 <p>
  86           The function <code class="computeroutput"><span class="identifier">all_of</span></code> returns
  87           true if the predicate returns true for every item in the sequence. There
  88           are two versions; one takes two iterators, and the other takes a range.
  89         </p>
  90 <p>
  91 </p>
  92 <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>
  93 <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>
  94         <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>
  95 <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>
  96         <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>
  97 <span class="special">}}</span>
  98 </pre>
  99 <p>
 100         </p>
 101 <p>
 102           The function <code class="computeroutput"><span class="identifier">all_of_equal</span></code>
 103           is similar to <code class="computeroutput"><span class="identifier">all_of</span></code>, but
 104           instead of taking a predicate to test the elements of the sequence, it
 105           takes a value to compare against.
 106         </p>
 107 <p>
 108 </p>
 109 <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>
 110 <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>
 111         <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>
 112 <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>
 113         <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>
 114 <span class="special">}}</span>
 115 </pre>
 116 <p>
 117         </p>
 118 <h6>
 119 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.h1"></a>
 120           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.examples"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.examples">Examples</a>
 121         </h6>
 122 <p>
 123           Given the container <code class="computeroutput"><span class="identifier">c</span></code> containing
 124           <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>
 125           <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>,
 126           then
 127 </p>
 128 <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>
 129 <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>
 130
 131 <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">;</span>
 132 <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>
 133 <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>
 134 <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>
 135 <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>
 136 <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>
 137 <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>
 138 <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>
 139 </pre>
 140 <p>
 141         </p>
 142 <h6>
 143 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.h2"></a>
 144           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.iterator_requirements"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.iterator_requirements">Iterator
 145           Requirements</a>
 146         </h6>
 147 <p>
 148           <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
 149           output iterators.
 150         </p>
 151 <h6>
 152 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.h3"></a>
 153           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.complexity"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.complexity">Complexity</a>
 154         </h6>
 155 <p>
 156           All of the variants of <code class="computeroutput"><span class="identifier">all_of</span></code>
 157           and <code class="computeroutput"><span class="identifier">all_of_equal</span></code> run in
 158           <span class="emphasis"><em>O(N)</em></span> (linear) time; that is, they compare against
 159           each element in the list once. If any of the comparisons fail, the algorithm
 160           will terminate immediately, without examining the remaining members of
 161           the sequence.
 162         </p>
 163 <h6>
 164 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.h4"></a>
 165           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.exception_safety"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.exception_safety">Exception
 166           Safety</a>
 167         </h6>
 168 <p>
 169           All of the variants of <code class="computeroutput"><span class="identifier">all_of</span></code>
 170           and <code class="computeroutput"><span class="identifier">all_of_equal</span></code> take their
 171           parameters by value or const reference, and do not depend upon any global
 172           state. Therefore, all the routines in this file provide the strong exception
 173           guarantee.
 174         </p>
 175 <h6>
 176 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.h5"></a>
 177           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.notes"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.all_of.notes">Notes</a>
 178         </h6>
 179 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 180 <li class="listitem">
 181               The routine <code class="computeroutput"><span class="identifier">all_of</span></code>
 182               is also available as part of the C++11 standard.
 183             </li>
 184 <li class="listitem">
 185               <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
 186               empty ranges, no matter what is passed to test against. When there
 187               are no items in the sequence to test, they all satisfy the condition
 188               to be tested against.
 189             </li>
 190 <li class="listitem">
 191               The second parameter to <code class="computeroutput"><span class="identifier">all_of_value</span></code>
 192               is a template parameter, rather than deduced from the first parameter
 193               (<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
 194               flexibility for callers, and takes advantage of built-in comparisons
 195               for the type that is pointed to by the iterator. The function is defined
 196               to return true if, for all elements in the sequence, the expression
 197               <code class="computeroutput"><span class="special">*</span><span class="identifier">iter</span>
 198               <span class="special">==</span> <span class="identifier">val</span></code>
 199               evaluates to true (where <code class="computeroutput"><span class="identifier">iter</span></code>
 200               is an iterator to each element in the sequence)
 201             </li>
 202 </ul></div>
 203 </div>
 204 <div class="section">
 205 <div class="titlepage"><div><div><h4 class="title">
 206 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of"></a><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of" title="any_of">any_of</a>
 207 </h4></div></div></div>
 208 <p>
 209           The header file 'boost/algorithm/cxx11/any_of.hpp' contains four variants
 210           of a single algorithm, <code class="computeroutput"><span class="identifier">any_of</span></code>.
 211           The algorithm tests the elements of a sequence and returns true if any
 212           of the elements has a particular property.
 213         </p>
 214 <p>
 215           The routine <code class="computeroutput"><span class="identifier">any_of</span></code> takes
 216           a sequence and a predicate. It will return true if the predicate returns
 217           true for any element in the sequence.
 218         </p>
 219 <p>
 220           The routine <code class="computeroutput"><span class="identifier">any_of_equal</span></code>
 221           takes a sequence and a value. It will return true if any element in the
 222           sequence compares equal to the passed in value.
 223         </p>
 224 <p>
 225           Both routines come in two forms; the first one takes two iterators to define
 226           the range. The second form takes a single range parameter, and uses Boost.Range
 227           to traverse it.
 228         </p>
 229 <h6>
 230 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.h0"></a>
 231           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.interface"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.interface">interface</a>
 232         </h6>
 233 <p>
 234           The function <code class="computeroutput"><span class="identifier">any_of</span></code> returns
 235           true if the predicate returns true any item in the sequence. There are
 236           two versions; one takes two iterators, and the other takes a range.
 237         </p>
 238 <p>
 239 </p>
 240 <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>
 241 <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>
 242         <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>
 243 <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>
 244         <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>
 245 <span class="special">}}</span>
 246 </pre>
 247 <p>
 248         </p>
 249 <p>
 250           The function <code class="computeroutput"><span class="identifier">any_of_equal</span></code>
 251           is similar to <code class="computeroutput"><span class="identifier">any_of</span></code>, but
 252           instead of taking a predicate to test the elements of the sequence, it
 253           takes a value to compare against.
 254         </p>
 255 <p>
 256 </p>
 257 <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>
 258 <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>
 259         <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>
 260 <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>
 261         <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>
 262 <span class="special">}}</span>
 263 </pre>
 264 <p>
 265         </p>
 266 <h6>
 267 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.h1"></a>
 268           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.examples"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.examples">Examples</a>
 269         </h6>
 270 <p>
 271           Given the container <code class="computeroutput"><span class="identifier">c</span></code> containing
 272           <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>
 273           <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>,
 274           then
 275 </p>
 276 <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>
 277 <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>
 278
 279 <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">;</span>
 280 <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>
 281 <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>
 282 <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>
 283 <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>
 284 <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>
 285 <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>
 286 <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>
 287 </pre>
 288 <p>
 289         </p>
 290 <h6>
 291 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.h2"></a>
 292           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.iterator_requirements"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.iterator_requirements">Iterator
 293           Requirements</a>
 294         </h6>
 295 <p>
 296           <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
 297           output iterators.
 298         </p>
 299 <h6>
 300 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.h3"></a>
 301           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.complexity"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.complexity">Complexity</a>
 302         </h6>
 303 <p>
 304           All of the variants of <code class="computeroutput"><span class="identifier">any_of</span></code>
 305           and <code class="computeroutput"><span class="identifier">any_of_equal</span></code> run in
 306           <span class="emphasis"><em>O(N)</em></span> (linear) time; that is, they compare against
 307           each element in the list once. If any of the comparisons succeed, the algorithm
 308           will terminate immediately, without examining the remaining members of
 309           the sequence.
 310         </p>
 311 <h6>
 312 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.h4"></a>
 313           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.exception_safety"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.exception_safety">Exception
 314           Safety</a>
 315         </h6>
 316 <p>
 317           All of the variants of <code class="computeroutput"><span class="identifier">any_of</span></code>
 318           and <code class="computeroutput"><span class="identifier">any_of_equal</span></code> take their
 319           parameters by value or const reference, and do not depend upon any global
 320           state. Therefore, all the routines in this file provide the strong exception
 321           guarantee.
 322         </p>
 323 <h6>
 324 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.h5"></a>
 325           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.notes"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.any_of.notes">Notes</a>
 326         </h6>
 327 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 328 <li class="listitem">
 329               The routine <code class="computeroutput"><span class="identifier">any_of</span></code>
 330               is also available as part of the C++11 standard.
 331             </li>
 332 <li class="listitem">
 333               <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
 334               empty ranges, no matter what is passed to test against.
 335             </li>
 336 <li class="listitem">
 337               The second parameter to <code class="computeroutput"><span class="identifier">any_of_value</span></code>
 338               is a template parameter, rather than deduced from the first parameter
 339               (<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
 340               flexibility for callers, and takes advantage of built-in comparisons
 341               for the type that is pointed to by the iterator. The function is defined
 342               to return true if, for any element in the sequence, the expression
 343               <code class="computeroutput"><span class="special">*</span><span class="identifier">iter</span>
 344               <span class="special">==</span> <span class="identifier">val</span></code>
 345               evaluates to true (where <code class="computeroutput"><span class="identifier">iter</span></code>
 346               is an iterator to each element in the sequence)
 347             </li>
 348 </ul></div>
 349 </div>
 350 <div class="section">
 351 <div class="titlepage"><div><div><h4 class="title">
 352 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of"></a><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of" title="none_of">none_of</a>
 353 </h4></div></div></div>
 354 <p>
 355           The header file 'boost/algorithm/cxx11/none_of.hpp' contains four variants
 356           of a single algorithm, <code class="computeroutput"><span class="identifier">none_of</span></code>.
 357           The algorithm tests all the elements of a sequence and returns true if
 358           they none of them share a property.
 359         </p>
 360 <p>
 361           The routine <code class="computeroutput"><span class="identifier">none_of</span></code> takes
 362           a sequence and a predicate. It will return true if the predicate returns
 363           false when applied to every element in the sequence.
 364         </p>
 365 <p>
 366           The routine <code class="computeroutput"><span class="identifier">none_of_equal</span></code>
 367           takes a sequence and a value. It will return true if none of the elements
 368           in the sequence compare equal to the passed in value.
 369         </p>
 370 <p>
 371           Both routines come in two forms; the first one takes two iterators to define
 372           the range. The second form takes a single range parameter, and uses Boost.Range
 373           to traverse it.
 374         </p>
 375 <h6>
 376 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.h0"></a>
 377           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.interface"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.interface">interface</a>
 378         </h6>
 379 <p>
 380           The function <code class="computeroutput"><span class="identifier">none_of</span></code> returns
 381           true if the predicate returns false for every item in the sequence. There
 382           are two versions; one takes two iterators, and the other takes a range.
 383         </p>
 384 <p>
 385 </p>
 386 <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>
 387 <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>
 388         <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>
 389 <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>
 390         <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>
 391 <span class="special">}}</span>
 392 </pre>
 393 <p>
 394         </p>
 395 <p>
 396           The function <code class="computeroutput"><span class="identifier">none_of_equal</span></code>
 397           is similar to <code class="computeroutput"><span class="identifier">none_of</span></code>,
 398           but instead of taking a predicate to test the elements of the sequence,
 399           it takes a value to compare against.
 400         </p>
 401 <p>
 402 </p>
 403 <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>
 404 <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>
 405         <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>
 406 <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>
 407         <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>
 408 <span class="special">}}</span>
 409 </pre>
 410 <p>
 411         </p>
 412 <h6>
 413 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.h1"></a>
 414           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.examples"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.examples">Examples</a>
 415         </h6>
 416 <p>
 417           Given the container <code class="computeroutput"><span class="identifier">c</span></code> containing
 418           <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>
 419           <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>,
 420           then
 421 </p>
 422 <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>
 423 <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>
 424
 425 <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">;</span>
 426
 427 <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>
 428 <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>
 429 <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>
 430 <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>
 431 <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>
 432 <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>
 433 <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>
 434 </pre>
 435 <p>
 436         </p>
 437 <h6>
 438 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.h2"></a>
 439           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.iterator_requirements"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.iterator_requirements">Iterator
 440           Requirements</a>
 441         </h6>
 442 <p>
 443           <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
 444           output iterators.
 445         </p>
 446 <h6>
 447 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.h3"></a>
 448           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.complexity"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.complexity">Complexity</a>
 449         </h6>
 450 <p>
 451           All of the variants of <code class="computeroutput"><span class="identifier">none_of</span></code>
 452           and <code class="computeroutput"><span class="identifier">none_of_equal</span></code> run in
 453           <span class="emphasis"><em>O(N)</em></span> (linear) time; that is, they compare against
 454           each element in the list once. If any of the comparisons succeed, the algorithm
 455           will terminate immediately, without examining the remaining members of
 456           the sequence.
 457         </p>
 458 <h6>
 459 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.h4"></a>
 460           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.exception_safety"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.exception_safety">Exception
 461           Safety</a>
 462         </h6>
 463 <p>
 464           All of the variants of <code class="computeroutput"><span class="identifier">none_of</span></code>
 465           and <code class="computeroutput"><span class="identifier">none_of_equal</span></code> take
 466           their parameters by value or const reference, and do not depend upon any
 467           global state. Therefore, all the routines in this file provide the strong
 468           exception guarantee.
 469         </p>
 470 <h6>
 471 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.h5"></a>
 472           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.notes"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.none_of.notes">Notes</a>
 473         </h6>
 474 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 475 <li class="listitem">
 476               The routine <code class="computeroutput"><span class="identifier">none_of</span></code>
 477               is also available as part of the C++11 standard.
 478             </li>
 479 <li class="listitem">
 480               <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
 481               empty ranges, no matter what is passed to test against.
 482             </li>
 483 <li class="listitem">
 484               The second parameter to <code class="computeroutput"><span class="identifier">none_of_value</span></code>
 485               is a template parameter, rather than deduced from the first parameter
 486               (<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
 487               flexibility for callers, and takes advantage of built-in comparisons
 488               for the type that is pointed to by the iterator. The function is defined
 489               to return true if, for all elements in the sequence, the expression
 490               <code class="computeroutput"><span class="special">*</span><span class="identifier">iter</span>
 491               <span class="special">==</span> <span class="identifier">val</span></code>
 492               evaluates to false (where <code class="computeroutput"><span class="identifier">iter</span></code>
 493               is an iterator to each element in the sequence)
 494             </li>
 495 </ul></div>
 496 </div>
 497 <div class="section">
 498 <div class="titlepage"><div><div><h4 class="title">
 499 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of"></a><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of" title="one_of">one_of</a>
 500 </h4></div></div></div>
 501 <p>
 502           The header file 'boost/algorithm/cxx11/one_of.hpp' contains four variants
 503           of a single algorithm, <code class="computeroutput"><span class="identifier">one_of</span></code>.
 504           The algorithm tests the elements of a sequence and returns true if exactly
 505           one of the elements in the sequence has a particular property.
 506         </p>
 507 <p>
 508           The routine <code class="computeroutput"><span class="identifier">one_of</span></code> takes
 509           a sequence and a predicate. It will return true if the predicate returns
 510           true for one element in the sequence.
 511         </p>
 512 <p>
 513           The routine <code class="computeroutput"><span class="identifier">one_of_equal</span></code>
 514           takes a sequence and a value. It will return true if one element in the
 515           sequence compares equal to the passed in value.
 516         </p>
 517 <p>
 518           Both routines come in two forms; the first one takes two iterators to define
 519           the range. The second form takes a single range parameter, and uses Boost.Range
 520           to traverse it.
 521         </p>
 522 <h6>
 523 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.h0"></a>
 524           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.interface"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.interface">interface</a>
 525         </h6>
 526 <p>
 527           The function <code class="computeroutput"><span class="identifier">one_of</span></code> returns
 528           true if the predicate returns true for one item in the sequence. There
 529           are two versions; one takes two iterators, and the other takes a range.
 530         </p>
 531 <p>
 532 </p>
 533 <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>
 534 <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>
 535         <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>
 536 <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>
 537         <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>
 538 <span class="special">}}</span>
 539 </pre>
 540 <p>
 541         </p>
 542 <p>
 543           The function <code class="computeroutput"><span class="identifier">one_of_equal</span></code>
 544           is similar to <code class="computeroutput"><span class="identifier">one_of</span></code>, but
 545           instead of taking a predicate to test the elements of the sequence, it
 546           takes a value to compare against.
 547         </p>
 548 <p>
 549 </p>
 550 <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>
 551 <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>
 552         <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>
 553 <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>
 554         <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>
 555 <span class="special">}}</span>
 556 </pre>
 557 <p>
 558         </p>
 559 <h6>
 560 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.h1"></a>
 561           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.examples"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.examples">Examples</a>
 562         </h6>
 563 <p>
 564           Given the container <code class="computeroutput"><span class="identifier">c</span></code> containing
 565           <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>
 566           <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>,
 567           then
 568 </p>
 569 <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>
 570 <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>
 571
 572 <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">;</span>
 573 <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>
 574 <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>
 575 <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>
 576 <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>
 577 <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>
 578 <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>
 579 <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>
 580 </pre>
 581 <p>
 582         </p>
 583 <h6>
 584 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.h2"></a>
 585           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.iterator_requirements"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.iterator_requirements">Iterator
 586           Requirements</a>
 587         </h6>
 588 <p>
 589           <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
 590           output iterators.
 591         </p>
 592 <h6>
 593 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.h3"></a>
 594           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.complexity"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.complexity">Complexity</a>
 595         </h6>
 596 <p>
 597           All of the variants of <code class="computeroutput"><span class="identifier">one_of</span></code>
 598           and <code class="computeroutput"><span class="identifier">one_of_equal</span></code> run in
 599           <span class="emphasis"><em>O(N)</em></span> (linear) time; that is, they compare against
 600           each element in the list once. If more than one of the elements in the
 601           sequence satisfy the condition, then algorithm will return false immediately,
 602           without examining the remaining members of the sequence.
 603         </p>
 604 <h6>
 605 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.h4"></a>
 606           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.exception_safety"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.exception_safety">Exception
 607           Safety</a>
 608         </h6>
 609 <p>
 610           All of the variants of <code class="computeroutput"><span class="identifier">one_of</span></code>
 611           and <code class="computeroutput"><span class="identifier">one_of_equal</span></code> take their
 612           parameters by value or const reference, and do not depend upon any global
 613           state. Therefore, all the routines in this file provide the strong exception
 614           guarantee.
 615         </p>
 616 <h6>
 617 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.h5"></a>
 618           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.notes"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.one_of.notes">Notes</a>
 619         </h6>
 620 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 621 <li class="listitem">
 622               <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
 623               empty ranges, no matter what is passed to test against.
 624             </li>
 625 <li class="listitem">
 626               The second parameter to <code class="computeroutput"><span class="identifier">one_of_equal</span></code>
 627               is a template parameter, rather than deduced from the first parameter
 628               (<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
 629               flexibility for callers, and takes advantage of built-in comparisons
 630               for the type that is pointed to by the iterator. The function is defined
 631               to return true if, for one element in the sequence, the expression
 632               <code class="computeroutput"><span class="special">*</span><span class="identifier">iter</span>
 633               <span class="special">==</span> <span class="identifier">val</span></code>
 634               evaluates to true (where <code class="computeroutput"><span class="identifier">iter</span></code>
 635               is an iterator to each element in the sequence)
 636             </li>
 637 </ul></div>
 638 </div>
 639 <div class="section">
 640 <div class="titlepage"><div><div><h4 class="title">
 641 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_sorted"></a><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_sorted" title="is_sorted">is_sorted
 642         </a>
 643 </h4></div></div></div>
 644 <p>
 645           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
 646           if a sequence is ordered.
 647         </p>
 648 <h6>
 649 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_sorted.h0"></a>
 650           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_sorted.is_sorted"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_sorted.is_sorted">is_sorted</a>
 651         </h6>
 652 <p>
 653           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
 654           completely sorted according so some criteria. If no comparison predicate
 655           is specified, then <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span></code>
 656           is used (i.e, the test is to see if the sequence is non-decreasing)
 657         </p>
 658 <p>
 659 </p>
 660 <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>
 661         <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>
 662         <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>
 663
 664         <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>
 665         <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>
 666
 667
 668         <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>
 669         <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>
 670
 671         <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>
 672         <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>
 673 <span class="special">}}</span>
 674 </pre>
 675 <p>
 676         </p>
 677 <p>
 678           Iterator requirements: The <code class="computeroutput"><span class="identifier">is_sorted</span></code>
 679           functions will work forward iterators or better.
 680         </p>
 681 <h6>
 682 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_sorted.h1"></a>
 683           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_sorted.is_sorted_until"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_sorted.is_sorted_until">is_sorted_until</a>
 684         </h6>
 685 <p>
 686           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
 687           <code class="computeroutput"><span class="identifier">is_sorted</span> <span class="special">(</span>
 688           <span class="identifier">first</span><span class="special">,</span>
 689           <span class="identifier">last</span> <span class="special">)</span></code>
 690           returns <code class="computeroutput"><span class="identifier">last</span></code>. Otherwise,
 691           it returns the last iterator i in [first,last] for which the range [first,i)
 692           is sorted.
 693         </p>
 694 <p>
 695           In short, it returns the element in the sequence that is "out of order".
 696           If the entire sequence is sorted (according to the predicate), then it
 697           will return <code class="computeroutput"><span class="identifier">last</span></code>.
 698         </p>
 699 <p>
 700 </p>
 701 <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>
 702         <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>
 703         <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>
 704
 705         <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>
 706         <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>
 707
 708
 709         <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>
 710         <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>
 711
 712         <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>
 713         <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>
 714 <span class="special">}}</span>
 715 </pre>
 716 <p>
 717         </p>
 718 <p>
 719           Iterator requirements: The <code class="computeroutput"><span class="identifier">is_sorted_until</span></code>
 720           functions will work on forward iterators or better. Since they have to
 721           return a place in the input sequence, input iterators will not suffice.
 722         </p>
 723 <p>
 724           Complexity: <code class="computeroutput"><span class="identifier">is_sorted_until</span></code>
 725           will make at most <span class="emphasis"><em>N-1</em></span> calls to the predicate (given
 726           a sequence of length <span class="emphasis"><em>N</em></span>).
 727         </p>
 728 <p>
 729           Examples:
 730         </p>
 731 <p>
 732           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>
 733           <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>,
 734           <code class="computeroutput"><span class="identifier">is_sorted_until</span> <span class="special">(</span>
 735           <span class="identifier">beg</span><span class="special">,</span>
 736           <span class="identifier">end</span><span class="special">,</span>
 737           <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>
 738           would return an iterator pointing at the second <code class="computeroutput"><span class="number">3</span></code>.
 739         </p>
 740 <p>
 741           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>
 742           <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>,
 743           <code class="computeroutput"><span class="identifier">is_sorted_until</span> <span class="special">(</span>
 744           <span class="identifier">beg</span><span class="special">,</span>
 745           <span class="identifier">end</span><span class="special">,</span>
 746           <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>
 747           would return <code class="computeroutput"><span class="identifier">end</span></code>.
 748         </p>
 749 <p>
 750           There are also a set of "wrapper functions" for is_ordered which
 751           make it easy to see if an entire sequence is ordered. These functions return
 752           a boolean indicating success or failure rather than an iterator to where
 753           the out of order items were found.
 754         </p>
 755 <p>
 756           To test if a sequence is increasing (each element at least as large as
 757           the preceding one):
 758 </p>
 759 <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>
 760         <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>
 761         <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>
 762
 763         <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>
 764         <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>
 765 <span class="special">}}</span>
 766 </pre>
 767 <p>
 768         </p>
 769 <p>
 770           To test if a sequence is decreasing (each element no larger than the preceding
 771           one):
 772         </p>
 773 <p>
 774 </p>
 775 <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>
 776         <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>
 777         <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>
 778
 779         <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>
 780         <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>
 781 <span class="special">}}</span>
 782 </pre>
 783 <p>
 784         </p>
 785 <p>
 786           To test if a sequence is strictly increasing (each element larger than
 787           the preceding one):
 788 </p>
 789 <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>
 790         <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>
 791         <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>
 792
 793         <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>
 794         <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>
 795 <span class="special">}}</span>
 796 </pre>
 797 <p>
 798         </p>
 799 <p>
 800           To test if a sequence is strictly decreasing (each element smaller than
 801           the preceding one):
 802 </p>
 803 <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>
 804         <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>
 805         <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>
 806
 807         <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>
 808         <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>
 809 <span class="special">}}</span>
 810 </pre>
 811 <p>
 812         </p>
 813 <p>
 814           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
 815           as <code class="computeroutput"><span class="identifier">is_sorted</span></code>.
 816         </p>
 817 <h6>
 818 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_sorted.h2"></a>
 819           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_sorted.notes"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_sorted.notes">Notes</a>
 820         </h6>
 821 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 822 <li class="listitem">
 823               The routines <code class="computeroutput"><span class="identifier">is_sorted</span></code>
 824               and <code class="computeroutput"><span class="identifier">is_sorted_until</span></code>
 825               are part of the C++11 standard. When compiled using a C++11 implementation,
 826               the implementation from the standard library will be used.
 827             </li>
 828 <li class="listitem">
 829               <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
 830               for empty ranges and ranges of length one.
 831             </li>
 832 </ul></div>
 833 </div>
 834 <div class="section">
 835 <div class="titlepage"><div><div><h4 class="title">
 836 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned"></a><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned" title="is_partitioned">is_partitioned
 837         </a>
 838 </h4></div></div></div>
 839 <p>
 840           The header file 'is_partitioned.hpp' contains two variants of a single
 841           algorithm, <code class="computeroutput"><span class="identifier">is_partitioned</span></code>.
 842           The algorithm tests to see if a sequence is partitioned according to a
 843           predicate; in other words, all the items in the sequence that satisfy the
 844           predicate are at the beginning of the sequence.
 845         </p>
 846 <p>
 847           The routine <code class="computeroutput"><span class="identifier">is_partitioned</span></code>
 848           takes a sequence and a predicate. It returns true if the sequence is partitioned
 849           according to the predicate.
 850         </p>
 851 <p>
 852           <code class="computeroutput"><span class="identifier">is_partitioned</span></code> come in
 853           two forms; the first one takes two iterators to define the range. The second
 854           form takes a single range parameter, and uses Boost.Range to traverse it.
 855         </p>
 856 <h6>
 857 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.h0"></a>
 858           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.interface"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.interface">interface</a>
 859         </h6>
 860 <p>
 861           The function <code class="computeroutput"><span class="identifier">is_partitioned</span></code>
 862           returns true if the items in the sequence are separated according to their
 863           ability to satisfy the predicate. There are two versions; one takes two
 864           iterators, and the other takes a range.
 865         </p>
 866 <p>
 867 </p>
 868 <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>
 869         <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>
 870 <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>
 871         <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>
 872 </pre>
 873 <p>
 874         </p>
 875 <h6>
 876 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.h1"></a>
 877           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.examples"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.examples">Examples</a>
 878         </h6>
 879 <p>
 880           Given the container <code class="computeroutput"><span class="identifier">c</span></code> containing
 881           <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>
 882           <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>,
 883           then
 884 </p>
 885 <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>
 886 <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>
 887
 888 <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>
 889 <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>
 890 <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>
 891 <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>
 892 <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>
 893 </pre>
 894 <p>
 895         </p>
 896 <h6>
 897 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.h2"></a>
 898           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.iterator_requirements"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.iterator_requirements">Iterator
 899           Requirements</a>
 900         </h6>
 901 <p>
 902           <code class="computeroutput"><span class="identifier">is_partitioned</span></code> works on
 903           all iterators except output iterators.
 904         </p>
 905 <h6>
 906 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.h3"></a>
 907           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.complexity"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.complexity">Complexity</a>
 908         </h6>
 909 <p>
 910           Both of the variants of <code class="computeroutput"><span class="identifier">is_partitioned</span></code>
 911           run in <span class="emphasis"><em>O(N)</em></span> (linear) time; that is, they compare against
 912           each element in the list once. If the sequence is found to be not partitioned
 913           at any point, the routine will terminate immediately, without examining
 914           the rest of the elements.
 915         </p>
 916 <h6>
 917 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.h4"></a>
 918           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.exception_safety"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.exception_safety">Exception
 919           Safety</a>
 920         </h6>
 921 <p>
 922           Both of the variants of <code class="computeroutput"><span class="identifier">is_partitioned</span></code>
 923           take their parameters by value or const reference, and do not depend upon
 924           any global state. Therefore, all the routines in this file provide the
 925           strong exception guarantee.
 926         </p>
 927 <h6>
 928 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.h5"></a>
 929           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.notes"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_partitioned.notes">Notes</a>
 930         </h6>
 931 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 932 <li class="listitem">
 933               The iterator-based version of the routine <code class="computeroutput"><span class="identifier">is_partitioned</span></code>
 934               is also available as part of the C++11 standard.
 935             </li>
 936 <li class="listitem">
 937               <code class="computeroutput"><span class="identifier">is_partitioned</span></code> returns
 938               true for empty and single-element ranges, no matter what predicate
 939               is passed to test against.
 940             </li>
 941 </ul></div>
 942 </div>
 943 <div class="section">
 944 <div class="titlepage"><div><div><h4 class="title">
 945 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation"></a><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation" title="is_permutation">is_permutation
 946         </a>
 947 </h4></div></div></div>
 948 <p>
 949           The header file 'is_permutation.hpp' contains six variants of a single
 950           algorithm, <code class="computeroutput"><span class="identifier">is_permutation</span></code>.
 951           The algorithm tests to see if one sequence is a permutation of a second
 952           one; in other words, it contains all the same members, possibly in a different
 953           order.
 954         </p>
 955 <p>
 956           The routine <code class="computeroutput"><span class="identifier">is_permutation</span></code>
 957           takes two sequences and an (optional) predicate. It returns true if the
 958           two sequences contain the same members. If it is passed a predicate, it
 959           uses the predicate to compare the elements of the sequence to see if they
 960           are the same.
 961         </p>
 962 <p>
 963           <code class="computeroutput"><span class="identifier">is_permutation</span></code> come in
 964           three forms. The first one takes two iterators to define the first range,
 965           and the starting iterator of the second range. The second form takes a
 966           two iterators to define the first range and two more to define the second
 967           range. The third form takes a single range parameter, and uses Boost.Range
 968           to traverse it.
 969         </p>
 970 <h6>
 971 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.h0"></a>
 972           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.interface"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.interface">Interface</a>
 973         </h6>
 974 <p>
 975           The function <code class="computeroutput"><span class="identifier">is_permutation</span></code>
 976           returns true if the two input sequences contain the same elements. There
 977           are six versions; two take three iterators, two take four iterators, and
 978           the other two take two ranges.
 979         </p>
 980 <p>
 981           In general, you should prefer the four iterator versions over the three
 982           iterator ones. The three iterator version has to "create" the
 983           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
 984           than the first, that's undefined behavior.
 985         </p>
 986 <p>
 987 </p>
 988 <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>
 989 <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>
 990
 991 <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>
 992 <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>
 993                       <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>
 994
 995
 996 <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>
 997 <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>
 998
 999 <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>
1000 <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>
1001                       <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>
1002                       <span class="identifier">BinaryPredicate</span> <span class="identifier">p</span> <span class="special">);</span>
1003
1004 <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>
1005 <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>
1006
1007 <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>
1008 <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>
1009 </pre>
1010 <p>
1011         </p>
1012 <h6>
1013 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.h1"></a>
1014           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.examples"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.examples">Examples</a>
1015         </h6>
1016 <p>
1017           Given the container <code class="computeroutput"><span class="identifier">c1</span></code>
1018           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>
1019           <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>,
1020           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>
1021           <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>,
1022           then
1023 </p>
1024 <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>
1025 <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>
1026
1027 <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>
1028 </pre>
1029 <p>
1030         </p>
1031 <h6>
1032 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.h2"></a>
1033           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.iterator_requirements"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.iterator_requirements">Iterator
1034           Requirements</a>
1035         </h6>
1036 <p>
1037           <code class="computeroutput"><span class="identifier">is_permutation</span></code> works on
1038           forward iterators or better.
1039         </p>
1040 <h6>
1041 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.h3"></a>
1042           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.complexity"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.complexity">Complexity</a>
1043         </h6>
1044 <p>
1045           All of the variants of <code class="computeroutput"><span class="identifier">is_permutation</span></code>
1046           run in <span class="emphasis"><em>O(N^2)</em></span> (quadratic) time; that is, they compare
1047           against each element in the list (potentially) N times. If passed random-access
1048           iterators, <code class="computeroutput"><span class="identifier">is_permutation</span></code>
1049           can return quickly if the sequences are different sizes.
1050         </p>
1051 <h6>
1052 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.h4"></a>
1053           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.exception_safety"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.exception_safety">Exception
1054           Safety</a>
1055         </h6>
1056 <p>
1057           All of the variants of <code class="computeroutput"><span class="identifier">is_permutation</span></code>
1058           take their parameters by value, and do not depend upon any global state.
1059           Therefore, all the routines in this file provide the strong exception guarantee.
1060         </p>
1061 <h6>
1062 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.h5"></a>
1063           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.notes"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.is_permutation.notes">Notes</a>
1064         </h6>
1065 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1066 <li class="listitem">
1067               The three iterator versions of the routine <code class="computeroutput"><span class="identifier">is_permutation</span></code>
1068               are also available as part of the C++11 standard.
1069             </li>
1070 <li class="listitem">
1071               The four iterator versions of the routine <code class="computeroutput"><span class="identifier">is_permutation</span></code>
1072               are part of the proposed C++14 standard. When C++14 standard libraries
1073               become available, the implementation should be changed to use the implementation
1074               from the standard library (if available).
1075             </li>
1076 <li class="listitem">
1077               <code class="computeroutput"><span class="identifier">is_permutation</span></code> returns
1078               true when passed a pair of empty ranges, no matter what predicate is
1079               passed to test with.
1080             </li>
1081 </ul></div>
1082 </div>
1083 <div class="section">
1084 <div class="titlepage"><div><div><h4 class="title">
1085 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point"></a><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point" title="partition_point">partition_point
1086         </a>
1087 </h4></div></div></div>
1088 <p>
1089           The header file 'partition_point.hpp' contains two variants of a single
1090           algorithm, <code class="computeroutput"><span class="identifier">partition_point</span></code>.
1091           Given a partitioned sequence and a predicate, the algorithm finds the partition
1092           point; i.e, the first element in the sequence that does not satisfy the
1093           predicate.
1094         </p>
1095 <p>
1096           The routine <code class="computeroutput"><span class="identifier">partition_point</span></code>
1097           takes a partitioned sequence and a predicate. It returns an iterator which
1098           'points to' the first element in the sequence that does not satisfy the
1099           predicate. If all the items in the sequence satisfy the predicate, then
1100           it returns one past the final element in the sequence.
1101         </p>
1102 <p>
1103           <code class="computeroutput"><span class="identifier">partition_point</span></code> come in
1104           two forms; the first one takes two iterators to define the range. The second
1105           form takes a single range parameter, and uses Boost.Range to traverse it.
1106         </p>
1107 <h6>
1108 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.h0"></a>
1109           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.interface"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.interface">interface</a>
1110         </h6>
1111 <p>
1112           There are two versions; one takes two iterators, and the other takes a
1113           range.
1114         </p>
1115 <p>
1116 </p>
1117 <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>
1118         <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>
1119 <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>
1120         <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>
1121 </pre>
1122 <p>
1123         </p>
1124 <h6>
1125 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.h1"></a>
1126           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.examples"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.examples">Examples</a>
1127         </h6>
1128 <p>
1129           Given the container <code class="computeroutput"><span class="identifier">c</span></code> containing
1130           <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>
1131           <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>,
1132           then
1133 </p>
1134 <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>
1135 <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>
1136
1137 <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>
1138 <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>
1139 <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>
1140 <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>
1141 </pre>
1142 <p>
1143         </p>
1144 <h6>
1145 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.h2"></a>
1146           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.iterator_requirements"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.iterator_requirements">Iterator
1147           Requirements</a>
1148         </h6>
1149 <p>
1150           <code class="computeroutput"><span class="identifier">partition_point</span></code> requires
1151           forward iterators or better; it will not work on input iterators or output
1152           iterators.
1153         </p>
1154 <h6>
1155 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.h3"></a>
1156           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.complexity"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.complexity">Complexity</a>
1157         </h6>
1158 <p>
1159           Both of the variants of <code class="computeroutput"><span class="identifier">partition_point</span></code>
1160           run in <span class="emphasis"><em>O( log (N))</em></span> (logarithmic) time; that is, the
1161           predicate will be will be applied approximately <span class="emphasis"><em>log(N)</em></span>
1162           times. To do this, however, the algorithm needs to know the size of the
1163           sequence. For forward and bidirectional iterators, calculating the size
1164           of the sequence is an <span class="emphasis"><em>O(N)</em></span> operation.
1165         </p>
1166 <h6>
1167 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.h4"></a>
1168           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.exception_safety"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.exception_safety">Exception
1169           Safety</a>
1170         </h6>
1171 <p>
1172           Both of the variants of <code class="computeroutput"><span class="identifier">partition_point</span></code>
1173           take their parameters by value or const reference, and do not depend upon
1174           any global state. Therefore, all the routines in this file provide the
1175           strong exception guarantee.
1176         </p>
1177 <h6>
1178 <a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.h5"></a>
1179           <span class="phrase"><a name="the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.notes"></a></span><a class="link" href="CXX11.html#the_boost_algorithm_library.CXX11.CXX11_inner_algorithms.partition_point.notes">Notes</a>
1180         </h6>
1181 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1182 <li class="listitem">
1183               The iterator-based version of the routine <code class="computeroutput"><span class="identifier">partition_point</span></code>
1184               is also available as part of the C++11 standard.
1185             </li>
1186 <li class="listitem">
1187               For empty ranges, the partition point is the end of the range.
1188             </li>
1189 </ul></div>
1190 </div>
1191 <div class="section">
1192 <div class="titlepage"><div><div><h4 class="title">
1193 <a name="algorithm.CXX11.CXX11_inner_algorithms.partition_copy"></a><a class="link" href="CXX11.html#algorithm.CXX11.CXX11_inner_algorithms.partition_copy" title="partition_copy">partition_copy
1194         </a>
1195 </h4></div></div></div>
1196 <p>
1197           <span class="bold"><strong><code class="literal"><a class="link" href="../header/boost/algorithm/cxx11/partition_copy_hpp.html" title="Header &lt;boost/algorithm/cxx11/partition_copy.hpp&gt;">partition_copy</a>
1198           </code> </strong></span> Copy a subset of a sequence to a new sequence
1199         </p>
1200 </div>
1201 <div class="section">
1202 <div class="titlepage"><div><div><h4 class="title">
1203 <a name="algorithm.CXX11.CXX11_inner_algorithms.copy_if"></a><a class="link" href="CXX11.html#algorithm.CXX11.CXX11_inner_algorithms.copy_if" title="copy_if">copy_if
1204         </a>
1205 </h4></div></div></div>
1206 <p>
1207           <span class="bold"><strong><code class="literal"><a class="link" href="../header/boost/algorithm/cxx11/copy_if_hpp.html" title="Header &lt;boost/algorithm/cxx11/copy_if.hpp&gt;">copy_if</a>
1208           </code> </strong></span> Copy a subset of a sequence to a new sequence
1209         </p>
1210 </div>
1211 <div class="section">
1212 <div class="titlepage"><div><div><h4 class="title">
1213 <a name="algorithm.CXX11.CXX11_inner_algorithms.copy_n"></a><a class="link" href="CXX11.html#algorithm.CXX11.CXX11_inner_algorithms.copy_n" title="copy_n">copy_n
1214         </a>
1215 </h4></div></div></div>
1216 <p>
1217           <span class="bold"><strong><code class="literal"><a class="link" href="../header/boost/algorithm/cxx11/copy_n_hpp.html" title="Header &lt;boost/algorithm/cxx11/copy_n.hpp&gt;">copy_n</a>
1218           </code> </strong></span> Copy n items from one sequence to another
1219         </p>
1220 </div>
1221 <div class="section">
1222 <div class="titlepage"><div><div><h4 class="title">
1223 <a name="algorithm.CXX11.CXX11_inner_algorithms.iota"></a><a class="link" href="CXX11.html#algorithm.CXX11.CXX11_inner_algorithms.iota" title="iota">iota
1224         </a>
1225 </h4></div></div></div>
1226 <p>
1227           <span class="bold"><strong><code class="literal"><a class="link" href="../header/boost/algorithm/cxx11/iota_hpp.html" title="Header &lt;boost/algorithm/cxx11/iota.hpp&gt;">iota</a>
1228           </code> </strong></span> Generate an increasing series
1229         </p>
1230 </div>
1231 </div>
1232 </div>
1233 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
1234 <td align="left"></td>
1235 <td align="right"><div class="copyright-footer">Copyright &#169; 2010-2012 Marshall Clow<p>
1236         Distributed under the Boost Software License, Version 1.0. (See accompanying
1237         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>)
1238       </p>
1239 </div></td>
1240 </tr></table>
1241 <hr>
1242 <div class="spirit-nav">
1243 <a accesskey="p" href="../the_boost_algorithm_library/Searching/KnuthMorrisPratt.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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>
1244 </div>
1245 </body>
1246 </html>