<?xml version="1.0" encoding="utf-8"?>
<!-- generator="FeedCreator 1.7.2-ppt DokuWiki" -->
<?xml-stylesheet href="http://cppreference.com/wiki/lib/exe/css.php?s=feed" type="text/css"?>
<rdf:RDF
    xmlns="http://purl.org/rss/1.0/"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
    xmlns:dc="http://purl.org/dc/elements/1.1/">
    <channel rdf:about="http://cppreference.com/wiki/feed.php">
        <title>C++ Reference stl:algorithm</title>
        <description></description>
        <link>http://cppreference.com/wiki/</link>
        <image rdf:resource="http://cppreference.com/wiki/lib/images/favicon.ico" />
       <dc:date>2010-09-09T09:40:09-07:00</dc:date>
        <items>
            <rdf:Seq>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/accumulate?rev=1269273377&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/adjacent_difference?rev=1271340482&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/adjacent_find?rev=1255074703&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/binary_search?rev=1272938157&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/copy?rev=1269190752&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/copy_backward?rev=1262095470&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/copy_n?rev=1222179168&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/count?rev=1255074951&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/count_if?rev=1266338785&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/equal?rev=1266671998&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/equal_range?rev=1255078375&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/fill?rev=1255076822&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/fill_n?rev=1255076976&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/find?rev=1255074195&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/find_end?rev=1255193036&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/find_first_of?rev=1255074615&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/find_if?rev=1255193197&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/for_each?rev=1277296735&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/generate?rev=1255077078&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/generate_n?rev=1255220511&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/includes?rev=1255197151&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/inner_product?rev=1255073898&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/inplace_merge?rev=1276164038&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/is_heap?rev=1259345679&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/iter_swap?rev=1255080357&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/lexicographical_compare?rev=1255079547&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/lexicographical_compare_3way?rev=1222179129&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/lower_bound?rev=1275586203&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/make_heap?rev=1255356343&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/max?rev=1224024125&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/max_element?rev=1255079801&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/merge?rev=1255078523&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/min?rev=1224024125&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/min_element?rev=1255079839&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/mismatch?rev=1255075254&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/next_permutation?rev=1274629797&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/nth_element?rev=1255356450&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/partial_sort?rev=1255356520&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/partial_sort_copy?rev=1270641716&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/partial_sum?rev=1255074006&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/partition?rev=1255078757&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/pop_heap?rev=1255356794&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/prev_permutation?rev=1255079679&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/push_heap?rev=1270642127&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/random_sample?rev=1224024125&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/random_sample_n?rev=1222179232&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/random_shuffle?rev=1270642420&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/remove?rev=1255076490&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/remove_copy?rev=1255076596&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/remove_copy_if?rev=1255076640&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/remove_if?rev=1275080570&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/replace?rev=1255076235&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/replace_copy?rev=1255076348&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/replace_copy_if?rev=1255076424&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/replace_if?rev=1255076290&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/reverse?rev=1255077204&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/reverse_copy?rev=1255077248&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/rotate?rev=1255077475&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/rotate_copy?rev=1255077632&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/search?rev=1255075421&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/search_n?rev=1255075542&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/set_difference?rev=1270643449&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/set_intersection?rev=1270643602&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/set_symmetric_difference?rev=1270643760&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/set_union?rev=1270643830&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/sort?rev=1276536786&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/sort_heap?rev=1270643912&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/stable_partition?rev=1255078795&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/stable_sort?rev=1255357263&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/start?rev=1263907758&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/swap?rev=1224024126&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/swap_ranges?rev=1255080182&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/transform?rev=1269152128&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/unique?rev=1270644260&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/unique_copy?rev=1255076132&amp;do=diff"/>
                <rdf:li rdf:resource="http://cppreference.com/wiki/stl/algorithm/upper_bound?rev=1271996873&amp;do=diff"/>
            </rdf:Seq>
        </items>
    </channel>
    <image rdf:about="http://cppreference.com/wiki/lib/images/favicon.ico">
        <title>C++ Reference</title>
        <link>http://cppreference.com/wiki/</link>
        <url>http://cppreference.com/wiki/lib/images/favicon.ico</url>
    </image>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/accumulate?rev=1269273377&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-03-22T08:56:17-07:00</dc:date>
        <title>accumulate</title>
        <link>http://cppreference.com/wiki/stl/algorithm/accumulate?rev=1269273377&amp;do=diff</link>
        <description>accumulate

Syntax:

#include &lt;numeric&gt;
TYPE accumulate( input_iterator start, input_iterator end, TYPE val );
TYPE accumulate( input_iterator start, input_iterator end, TYPE val, BinaryFunction f );

The accumulate function computes the sum of val and all of the elements in
the range [start,end).</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/adjacent_difference?rev=1271340482&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-04-15T07:08:02-07:00</dc:date>
        <title>adjacent_difference</title>
        <link>http://cppreference.com/wiki/stl/algorithm/adjacent_difference?rev=1271340482&amp;do=diff</link>
        <description>adjacent_difference

Syntax:

    #include &lt;numeric&gt;
    output_iterator adjacent_difference( input_iterator start, input_iterator end, output_iterator result );
    output_iterator adjacent_difference( input_iterator start, input_iterator end, output_iterator result, BinaryFunction f );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/adjacent_find?rev=1255074703&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T00:51:43-07:00</dc:date>
        <title>adjacent_find</title>
        <link>http://cppreference.com/wiki/stl/algorithm/adjacent_find?rev=1255074703&amp;do=diff</link>
        <description>adjacent_find

Syntax:

    #include &lt;algorithm&gt;
    forward_iterator adjacent_find( forward_iterator start, forward_iterator end );
    forward_iterator adjacent_find( forward_iterator start, forward_iterator end, BinPred pr );


The adjacent_find() function searches between start and end for two consecutive
identical elements. If the binary predicate pr is specified, then it is used to
test whether two elements are the same or not.
The return value is an iterator that points to the first of th…</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/binary_search?rev=1272938157&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-05-03T18:55:57-07:00</dc:date>
        <title>binary_search</title>
        <link>http://cppreference.com/wiki/stl/algorithm/binary_search?rev=1272938157&amp;do=diff</link>
        <description>binary_search

Syntax:

    #include &lt;algorithm&gt;
    bool binary_search( forward_iterator start, forward_iterator end, const TYPE&amp; val );
    bool binary_search( forward_iterator start, forward_iterator end, const TYPE&amp; val, Comp f );

The binary_search() function searches from start to end for val. The elements
between start and end that are searched should be in ascending order as defined
by the &lt; operator. Note that a binary search will not work unless the elements
being searched are in order…</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/copy?rev=1269190752&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-03-21T09:59:12-07:00</dc:date>
        <title>copy</title>
        <link>http://cppreference.com/wiki/stl/algorithm/copy?rev=1269190752&amp;do=diff</link>
        <description>copy

Syntax:

    #include &lt;algorithm&gt;
    output_iterator copy( input_iterator start, input_iterator end, output_iterator dest );

The copy function copies the elements between start and end to dest. In other
words, after copy has run,

   *dest = *start
   *(dest+1) = *(start+1)
   *(dest+2) = *(start+2)
   ...
   *(dest+N) = *(start+N)</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/copy_backward?rev=1262095470&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-12-29T06:04:30-07:00</dc:date>
        <title>copy_backward</title>
        <link>http://cppreference.com/wiki/stl/algorithm/copy_backward?rev=1262095470&amp;do=diff</link>
        <description>copy_backward

Syntax:

#include &lt;algorithm&gt;
bidirectional_iterator2 copy_backward( bidirectional_iterator start,
                                       bidirectional_iterator end,
                                       bidirectional_iterator2 dest );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/copy_n?rev=1222179168&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-23T07:12:48-07:00</dc:date>
        <title>copy_n</title>
        <link>http://cppreference.com/wiki/stl/algorithm/copy_n?rev=1222179168&amp;do=diff</link>
        <description>copy_n


This function was part of the original SGI STL library, but never has been a part of ISO C++.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/count?rev=1255074951&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T00:55:51-07:00</dc:date>
        <title>count</title>
        <link>http://cppreference.com/wiki/stl/algorithm/count?rev=1255074951&amp;do=diff</link>
        <description>count

Syntax:

    #include &lt;algorithm&gt;
    typename iterator_traits&lt;input_iterator&gt;::difference_type
    count( input_iterator start, input_iterator end, const TYPE&amp; val );

The count() function returns the number of elements between start and end that
match val.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/count_if?rev=1266338785&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-02-16T08:46:25-07:00</dc:date>
        <title>count_if</title>
        <link>http://cppreference.com/wiki/stl/algorithm/count_if?rev=1266338785&amp;do=diff</link>
        <description>count_if

Syntax:

    #include &lt;algorithm&gt;
    typename iterator_traits&lt;input_iterator&gt;::difference_type
    count_if( input_iterator start, input_iterator end, UnaryPred p );

The count_if function returns the number of elements between start and end
for which the predicate p returns true.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/equal?rev=1266671998&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-02-20T05:19:58-07:00</dc:date>
        <title>equal</title>
        <link>http://cppreference.com/wiki/stl/algorithm/equal?rev=1266671998&amp;do=diff</link>
        <description>equal

Syntax:

    #include &lt;algorithm&gt;
    bool equal( input_iterator start1, input_iterator end1, input_iterator2 start2 );
    bool equal( input_iterator start1, input_iterator end1, input_iterator2 start2, BinPred p );

The equal function returns true if the elements in two ranges are the same.
The first range of elements are those between start1 and end1. The second range
of elements has the same size as the first range but starts at start2.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/equal_range?rev=1255078375&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:52:55-07:00</dc:date>
        <title>equal_range</title>
        <link>http://cppreference.com/wiki/stl/algorithm/equal_range?rev=1255078375&amp;do=diff</link>
        <description>equal_range

Syntax:

    #include &lt;algorithm&gt;
    pair&lt;forward_iterator,forward_iterator&gt; equal_range( forward_iterator first, forward_iterator last, const TYPE&amp; val );
    pair&lt;forward_iterator,forward_iterator&gt; equal_range( forward_iterator first, forward_iterator last, const TYPE&amp; val, CompFn comp );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/fill?rev=1255076822&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:27:02-07:00</dc:date>
        <title>fill</title>
        <link>http://cppreference.com/wiki/stl/algorithm/fill?rev=1255076822&amp;do=diff</link>
        <description>fill

Syntax:

    #include &lt;algorithm&gt;
    void fill( forward_iterator start, forward_iterator end, const TYPE&amp; val );

The function fill() assigns val to all of the elements between start and end.

For example, the following code uses fill() to set all of the elements of a
vector of integers to -1:</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/fill_n?rev=1255076976&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:29:36-07:00</dc:date>
        <title>fill_n</title>
        <link>http://cppreference.com/wiki/stl/algorithm/fill_n?rev=1255076976&amp;do=diff</link>
        <description>fill_n

Syntax:

    #include &lt;algorithm&gt;
    void fill_n( output_iterator start, SIZE n, const TYPE&amp; val );

The fill_n() function is similar to fill. Instead of assigning val
to a range of elements, however, fill_n() assigns val to the first n elements
starting at start.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/find?rev=1255074195&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T00:43:15-07:00</dc:date>
        <title>find</title>
        <link>http://cppreference.com/wiki/stl/algorithm/find?rev=1255074195&amp;do=diff</link>
        <description>find

Syntax:

    #include &lt;algorithm&gt;
    input_iterator find( input_iterator start, input_iterator end, const TYPE&amp; val );

The find() algorithm looks for an element matching val between start and end.
If an element matching val is found, the return value is an iterator that
points to that element. Otherwise, the return value is an iterator that points
to end.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/find_end?rev=1255193036&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-10T09:43:56-07:00</dc:date>
        <title>find_end</title>
        <link>http://cppreference.com/wiki/stl/algorithm/find_end?rev=1255193036&amp;do=diff</link>
        <description>find_end

Syntax:

    #include &lt;algorithm&gt;
    forward_iterator find_end( forward_iterator start, forward_iterator end, forward_iterator2 seq_start, forward_iterator2 seq_end );
    forward_iterator find_end( forward_iterator start, forward_iterator end, forward_iterator2 seq_start, forward_iterator2 seq_end, BinPred bp );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/find_first_of?rev=1255074615&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T00:50:15-07:00</dc:date>
        <title>find_first_of</title>
        <link>http://cppreference.com/wiki/stl/algorithm/find_first_of?rev=1255074615&amp;do=diff</link>
        <description>find_first_of

Syntax:

    #include &lt;algorithm&gt;
    forward_iterator find_first_of( forward_iterator start, forward_iterator end, forward_iterator2 find_start, forward_iterator2 find_end );
    forward_iterator find_first_of( forward_iterator start, forward_iterator end, forward_iterator2 find_start, forward_iterator2 find_end, BinPred bp );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/find_if?rev=1255193197&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-10T09:46:37-07:00</dc:date>
        <title>find_if</title>
        <link>http://cppreference.com/wiki/stl/algorithm/find_if?rev=1255193197&amp;do=diff</link>
        <description>find_if

Syntax:

    #include &lt;algorithm&gt;
    input_iterator find_if( input_iterator start, input_iterator end, UnPred up );

The find_if() function searches for the first element between start and end for
which the unary predicate up returns true.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/for_each?rev=1277296735&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-06-23T05:38:55-07:00</dc:date>
        <title>for_each</title>
        <link>http://cppreference.com/wiki/stl/algorithm/for_each?rev=1277296735&amp;do=diff</link>
        <description>for_each

Syntax:

    #include &lt;algorithm&gt;
    UnaryFunction for_each( input_iterator start, input_iterator end, UnaryFunction f );

The for_each algorithm applies the function f to each of the elements between
start and end. The return value of for_each is f.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/generate?rev=1255077078&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:31:18-07:00</dc:date>
        <title>generate</title>
        <link>http://cppreference.com/wiki/stl/algorithm/generate?rev=1255077078&amp;do=diff</link>
        <description>generate

Syntax:

    #include &lt;algorithm&gt;
    void generate( forward_iterator start, forward_iterator end, Generator g );

The generate() function runs the Generator function object g a number of times,
saving the result of each execution in the range [start,end).</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/generate_n?rev=1255220511&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-10T17:21:51-07:00</dc:date>
        <title>generate_n</title>
        <link>http://cppreference.com/wiki/stl/algorithm/generate_n?rev=1255220511&amp;do=diff</link>
        <description>generate_n

Syntax:

    #include &lt;algorithm&gt;
    void generate_n( output_iterator result, SIZE num, Generator g );

The generate_n() function runs the Generator function object g num times,
saving the result of each execution in result, (result+1), etc.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/includes?rev=1255197151&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-10T10:52:31-07:00</dc:date>
        <title>includes</title>
        <link>http://cppreference.com/wiki/stl/algorithm/includes?rev=1255197151&amp;do=diff</link>
        <description>includes

Syntax:

    #include &lt;algorithm&gt;

    template&lt; typename InIterA, typename InIterB &gt;
    bool includes( InIterA start1, InIterA end1, InIterB start2, InIterB end2 );

    template&lt; typename InIterA, typename InIterB, typename StrictWeakOrdering &gt;
    bool includes( InIterA start1, InIterA end1, InIterB start2, InIterB end2, StrictWeakOrdering cmp );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/inner_product?rev=1255073898&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T00:38:18-07:00</dc:date>
        <title>inner_product</title>
        <link>http://cppreference.com/wiki/stl/algorithm/inner_product?rev=1255073898&amp;do=diff</link>
        <description>inner_product

Syntax:

    #include &lt;numeric&gt;
    TYPE inner_product( input_iterator start1, input_iterator end1, input_iterator2 start2, TYPE val );
    TYPE inner_product( input_iterator start1, input_iterator end1, input_iterator2 start2, TYPE val, BinaryFunction f1, BinaryFunction2 f2 );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/inplace_merge?rev=1276164038&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-06-10T03:00:38-07:00</dc:date>
        <title>inplace_merge</title>
        <link>http://cppreference.com/wiki/stl/algorithm/inplace_merge?rev=1276164038&amp;do=diff</link>
        <description>inplace_merge

Syntax:

    #include &lt;algorithm&gt;
    void inplace_merge( bidirectional_iterator start, bidirectional_iterator middle, bidirectional_iterator end );
    void inplace_merge( bidirectional_iterator start, bidirectional_iterator middle, bidirectional_iterator end, StrictWeakOrdering cmp );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/is_heap?rev=1259345679&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-11-27T10:14:39-07:00</dc:date>
        <title>is_heap</title>
        <link>http://cppreference.com/wiki/stl/algorithm/is_heap?rev=1259345679&amp;do=diff</link>
        <description>is_heap

Syntax:

    #include &lt;algorithm&gt;
    bool is_heap(iterator start, iterator end);
    bool is_heap(iterator start, iterator end, StrictWeakOrdering cmp);

The is_heap() function returns true if the given range [start,end) is a heap.

If the strict weak ordering comparison function object cmp is given, then it is
used instead of the &lt; operator to compare elements.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/iter_swap?rev=1255080357&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T02:25:57-07:00</dc:date>
        <title>iter_swap</title>
        <link>http://cppreference.com/wiki/stl/algorithm/iter_swap?rev=1255080357&amp;do=diff</link>
        <description>iter_swap

Syntax:

    #include &lt;algorithm&gt;
    void iter_swap( forward_iterator a, forward_iterator b );

A call to iter_swap() exchanges the values of two elements exactly as a call to

   swap( *a, *b );

would.

Related Topics: swap, swap_ranges</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/lexicographical_compare?rev=1255079547&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T02:12:27-07:00</dc:date>
        <title>lexicographical_compare</title>
        <link>http://cppreference.com/wiki/stl/algorithm/lexicographical_compare?rev=1255079547&amp;do=diff</link>
        <description>lexicographical_compare

Syntax:

    #include &lt;algorithm&gt;
    bool lexicographical_compare( input_iterator start1, input_iterator end1, input_iterator2 start2, input_iterator2 end2 );
    bool lexicographical_compare( input_iterator start1, input_iterator end1, input_iterator2 start2, input_iterator2 end2, BinPred p );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/lexicographical_compare_3way?rev=1222179129&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-23T07:12:09-07:00</dc:date>
        <title>lexicographical_compare_3way</title>
        <link>http://cppreference.com/wiki/stl/algorithm/lexicographical_compare_3way?rev=1222179129&amp;do=diff</link>
        <description>lexicographical_compare_3way


This function was part of the original SGI STL library, but never has been a part of ISO C++.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/lower_bound?rev=1275586203&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-06-03T10:30:03-07:00</dc:date>
        <title>lower_bound</title>
        <link>http://cppreference.com/wiki/stl/algorithm/lower_bound?rev=1275586203&amp;do=diff</link>
        <description>lower_bound

Syntax:

    #include &lt;algorithm&gt;
    forward_iterator lower_bound( forward_iterator first, forward_iterator last, const TYPE&amp; val );
    forward_iterator lower_bound( forward_iterator first, forward_iterator last, const TYPE&amp; val, CompFn f );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/make_heap?rev=1255356343&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-12T07:05:43-07:00</dc:date>
        <title>make_heap</title>
        <link>http://cppreference.com/wiki/stl/algorithm/make_heap?rev=1255356343&amp;do=diff</link>
        <description>make_heap

Syntax:

    #include &lt;algorithm&gt;
    void make_heap( random_access_iterator start, random_access_iterator end );
    void make_heap( random_access_iterator start, random_access_iterator end, StrictWeakOrdering cmp );

The make_heap() function turns the given range of elements [start,end) into a
heap.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/max?rev=1224024125&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-10-14T15:42:05-07:00</dc:date>
        <title>max</title>
        <link>http://cppreference.com/wiki/stl/algorithm/max?rev=1224024125&amp;do=diff</link>
        <description>max

Syntax:

    #include &lt;algorithm&gt;
    const TYPE&amp; max( const TYPE&amp; x, const TYPE&amp; y );
    const TYPE&amp; max( const TYPE&amp; x, const TYPE&amp; y, BinPred p );

The max() function returns the greater of x and y.

If the binary predicate p is given, then it will be used instead of the &lt;
operator to compare the two elements.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/max_element?rev=1255079801&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T02:16:41-07:00</dc:date>
        <title>max_element</title>
        <link>http://cppreference.com/wiki/stl/algorithm/max_element?rev=1255079801&amp;do=diff</link>
        <description>max_element

Syntax:

  #include &lt;algorithm&gt;
  forward_iterator max_element( forward_iterator start, forward_iterator end );
  forward_iterator max_element( forward_iterator start, forward_iterator end, BinPred p );

The max_element() function returns an iterator to the largest element in the
range [start,end).</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/merge?rev=1255078523&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:55:23-07:00</dc:date>
        <title>merge</title>
        <link>http://cppreference.com/wiki/stl/algorithm/merge?rev=1255078523&amp;do=diff</link>
        <description>merge

Syntax:

    #include &lt;algorithm&gt;
    output_iterator merge( input_iterator start1, input_iterator end1, input_iterator2 start2, input_iterator2 end2, output_iterator result );
    output_iterator merge( input_iterator start1, input_iterator end1, input_iterator2 start2, input_iterator2 end2, output_iterator result, StrictWeakOrdering cmp );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/min?rev=1224024125&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-10-14T15:42:05-07:00</dc:date>
        <title>min</title>
        <link>http://cppreference.com/wiki/stl/algorithm/min?rev=1224024125&amp;do=diff</link>
        <description>min

Syntax:

    #include &lt;algorithm&gt;
    const TYPE&amp; min( const TYPE&amp; x, const TYPE&amp; y );
    const TYPE&amp; min( const TYPE&amp; x, const TYPE&amp; y, BinPred p );

The min() function, unsurprisingly, returns the smaller of x and y.

By default, the &lt; operator is used to compare the two elements. If the binary
predicate p is given, it will be used instead.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/min_element?rev=1255079839&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T02:17:19-07:00</dc:date>
        <title>min_element</title>
        <link>http://cppreference.com/wiki/stl/algorithm/min_element?rev=1255079839&amp;do=diff</link>
        <description>min_element

Syntax:

    #include &lt;algorithm&gt;
    forward_iterator min_element( forward_iterator start, forward_iterator end );
    forward_iterator min_element( forward_iterator start, forward_iterator end, BinPred p );

The min_element() function returns an iterator to the smallest element in the
range [start,end).</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/mismatch?rev=1255075254&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:00:54-07:00</dc:date>
        <title>mismatch</title>
        <link>http://cppreference.com/wiki/stl/algorithm/mismatch?rev=1255075254&amp;do=diff</link>
        <description>mismatch

Syntax:

    #include &lt;algorithm&gt;
    pair &lt;input_iterator1,input_iterator2&gt; mismatch( input_iterator1 start1, input_iterator1 end1, input_iterator2 start2 );
    pair &lt;input_iterator1,input_iterator2&gt; mismatch( input_iterator1 start1, input_iterator1 end1, input_iterator2 start2, BinPred p );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/next_permutation?rev=1274629797&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-05-23T08:49:57-07:00</dc:date>
        <title>next_permutation</title>
        <link>http://cppreference.com/wiki/stl/algorithm/next_permutation?rev=1274629797&amp;do=diff</link>
        <description>next_permutation

Syntax:

    #include &lt;algorithm&gt;
    bool next_permutation( bidirectional_iterator start, bidirectional_iterator end );
    bool next_permutation( bidirectional_iterator start, bidirectional_iterator end, StrictWeakOrdering cmp );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/nth_element?rev=1255356450&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-12T07:07:30-07:00</dc:date>
        <title>nth_element</title>
        <link>http://cppreference.com/wiki/stl/algorithm/nth_element?rev=1255356450&amp;do=diff</link>
        <description>nth_element

Syntax:

    #include &lt;algorithm&gt;
    void nth_element( random_access_iterator start, random_access_iterator nth, random_access_iterator end );
    void nth_element( random_access_iterator start, random_access_iterator nth, random_access_iterator end, StrictWeakOrdering cmp );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/partial_sort?rev=1255356520&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-12T07:08:40-07:00</dc:date>
        <title>partial_sort</title>
        <link>http://cppreference.com/wiki/stl/algorithm/partial_sort?rev=1255356520&amp;do=diff</link>
        <description>partial_sort

Syntax:

    #include &lt;algorithm&gt;
    void partial_sort( random_access_iterator start, random_access_iterator middle, random_access_iterator end );
    void partial_sort( random_access_iterator start, random_access_iterator middle, random_access_iterator end, StrictWeakOrdering cmp );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/partial_sort_copy?rev=1270641716&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-04-07T05:01:56-07:00</dc:date>
        <title>partial_sort_copy</title>
        <link>http://cppreference.com/wiki/stl/algorithm/partial_sort_copy?rev=1270641716&amp;do=diff</link>
        <description>partial_sort_copy

Syntax:

    #include &lt;algorithm&gt;
    random_access_iterator partial_sort_copy( input_iterator start, input_iterator end, random_access_iterator result_start, random_access_iterator result_end );
    random_access_iterator partial_sort_copy( input_iterator start, input_iterator end, random_access_iterator result_start, random_access_iterator result_end, StrictWeakOrdering cmp );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/partial_sum?rev=1255074006&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T00:40:06-07:00</dc:date>
        <title>partial_sum</title>
        <link>http://cppreference.com/wiki/stl/algorithm/partial_sum?rev=1255074006&amp;do=diff</link>
        <description>partial_sum

Syntax:

    #include &lt;numeric&gt;
    output_iterator partial_sum( input_iterator start, input_iterator end, output_iterator result );
    output_iterator partial_sum( input_iterator start, input_iterator end, output_iterator result, BinOp p );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/partition?rev=1255078757&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:59:17-07:00</dc:date>
        <title>partition</title>
        <link>http://cppreference.com/wiki/stl/algorithm/partition?rev=1255078757&amp;do=diff</link>
        <description>partition

Syntax:

    #include &lt;algorithm&gt;
    bidirectional_iterator partition( bidirectional_iterator start, bidirectional_iterator end, Predicate p );

The partition algorithm re-orders the elements in [start,end) such that the
elements for which the predicate p returns true come before the elements for
which p returns false.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/pop_heap?rev=1255356794&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-12T07:13:14-07:00</dc:date>
        <title>pop_heap</title>
        <link>http://cppreference.com/wiki/stl/algorithm/pop_heap?rev=1255356794&amp;do=diff</link>
        <description>pop_heap

Syntax:

    #include &lt;algorithm&gt;
    void pop_heap( random_access_iterator start, random_access_iterator end );
    void pop_heap( random_access_iterator start, random_access_iterator end, StrictWeakOrdering cmp );

The pop_heap() function removes the largest element (defined as the element at
the front of the heap) from the given heap.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/prev_permutation?rev=1255079679&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T02:14:39-07:00</dc:date>
        <title>prev_permutation</title>
        <link>http://cppreference.com/wiki/stl/algorithm/prev_permutation?rev=1255079679&amp;do=diff</link>
        <description>prev_permutation

Syntax:

    #include &lt;algorithm&gt;
    bool prev_permutation( bidirectional_iterator start, bidirectional_iterator end );
    bool prev_permutation( bidirectional_iterator start, bidirectional_iterator end, StrictWeakOrdering cmp );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/push_heap?rev=1270642127&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-04-07T05:08:47-07:00</dc:date>
        <title>push_heap</title>
        <link>http://cppreference.com/wiki/stl/algorithm/push_heap?rev=1270642127&amp;do=diff</link>
        <description>push_heap

Syntax:

    #include &lt;algorithm&gt;
    void push_heap( random_access_iterator start, random_access_iterator end );
    void push_heap( random_access_iterator start, random_access_iterator end, StrictWeakOrdering cmp );

The push_heap() function adds an element (defined as the last element before
end) to a heap (defined as the range of elements between [start,''end-1).</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/random_sample?rev=1224024125&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-10-14T15:42:05-07:00</dc:date>
        <title>random_sample</title>
        <link>http://cppreference.com/wiki/stl/algorithm/random_sample?rev=1224024125&amp;do=diff</link>
        <description>random_sample


This function was part of the original SGI STL library, but never has been a part of ISO C++.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/random_sample_n?rev=1222179232&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-23T07:13:52-07:00</dc:date>
        <title>random_sample_n</title>
        <link>http://cppreference.com/wiki/stl/algorithm/random_sample_n?rev=1222179232&amp;do=diff</link>
        <description>random_sample_n


This function was part of the original SGI STL library, but never has been a part of ISO C++.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/random_shuffle?rev=1270642420&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-04-07T05:13:40-07:00</dc:date>
        <title>random_shuffle</title>
        <link>http://cppreference.com/wiki/stl/algorithm/random_shuffle?rev=1270642420&amp;do=diff</link>
        <description>random_shuffle

Syntax:

    #include &lt;algorithm&gt;
    void random_shuffle( random_access_iterator start, random_access_iterator end );
    void random_shuffle( random_access_iterator start, random_access_iterator end, RandomNumberGenerator&amp; rnd );

The random_shuffle() function randomly re-orders the elements in the range
[start,end). If a random number generator function object rnd is supplied, it
will be used instead of an internal random number generator.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/remove?rev=1255076490&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:21:30-07:00</dc:date>
        <title>remove</title>
        <link>http://cppreference.com/wiki/stl/algorithm/remove?rev=1255076490&amp;do=diff</link>
        <description>remove

Syntax:

    #include &lt;algorithm&gt;
    forward_iterator remove( forward_iterator start, forward_iterator end, const TYPE&amp; val );

The remove algorithm removes all of the elements in the range [start,end) that are equal to val.

The return value of this function is an iterator after the last element of the new sequence that should contain no elements equal to val.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/remove_copy?rev=1255076596&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:23:16-07:00</dc:date>
        <title>remove_copy</title>
        <link>http://cppreference.com/wiki/stl/algorithm/remove_copy?rev=1255076596&amp;do=diff</link>
        <description>remove_copy

Syntax:

    #include &lt;algorithm&gt;
    output_iterator remove_copy( input_iterator start, input_iterator end, output_iterator result, const TYPE&amp; val );

The remove_copy() algorithm copies the range [start,end) to result but omits
any elements that are equal to val.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/remove_copy_if?rev=1255076640&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:24:00-07:00</dc:date>
        <title>remove_copy_if</title>
        <link>http://cppreference.com/wiki/stl/algorithm/remove_copy_if?rev=1255076640&amp;do=diff</link>
        <description>remove_copy_if

Syntax:

    #include &lt;algorithm&gt;
    output_iterator remove_copy_if( input_iterator start, input_iterator end, output_iterator result, Predicate p );

The remove_copy_if() function copies the range of elements [start,end) to
result, omitting any elements for which the predicate function p returns true.
The return value of remove_copy_if() is an iterator the end of the new range.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/remove_if?rev=1275080570&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-05-28T14:02:50-07:00</dc:date>
        <title>remove_if</title>
        <link>http://cppreference.com/wiki/stl/algorithm/remove_if?rev=1275080570&amp;do=diff</link>
        <description>remove_if

Syntax:

    #include &lt;algorithm&gt;
    forward_iterator remove_if( forward_iterator start, forward_iterator end, Predicate p );

The remove_if() function removes all elements in the range [start,end) for
which the predicate p returns true.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/replace?rev=1255076235&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:17:15-07:00</dc:date>
        <title>replace</title>
        <link>http://cppreference.com/wiki/stl/algorithm/replace?rev=1255076235&amp;do=diff</link>
        <description>replace

Syntax:

    #include &lt;algorithm&gt;
    void replace( forward_iterator start, forward_iterator end, const TYPE&amp; old_value, const TYPE&amp; new_value );

The replace() function sets every element in the range [start,end) that is
equal to old_value to have new_value instead.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/replace_copy?rev=1255076348&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:19:08-07:00</dc:date>
        <title>replace_copy</title>
        <link>http://cppreference.com/wiki/stl/algorithm/replace_copy?rev=1255076348&amp;do=diff</link>
        <description>replace_copy

Syntax:

    #include &lt;algorithm&gt;
    output_iterator replace_copy( input_iterator start, input_iterator end, output_iterator result, const TYPE&amp; old_value, const TYPE&amp; new_value );

The replace_copy() function copies the elements in the range [start,end) to the
destination result. Any elements in the range that are equal to old_value are
replaced with new_value.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/replace_copy_if?rev=1255076424&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:20:24-07:00</dc:date>
        <title>replace_copy_if</title>
        <link>http://cppreference.com/wiki/stl/algorithm/replace_copy_if?rev=1255076424&amp;do=diff</link>
        <description>replace_copy_if

Syntax:

    #include &lt;algorithm&gt;
    output_iterator replace_copy_if( input_iterator start, input_iterator end, output_iterator result, Predicate p, const TYPE&amp; new_value );

The replace_copy_if() function copies the elements in the range [start,end) to
the destination result. Any elements for which the predicate p is true are
replaced with new_value.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/replace_if?rev=1255076290&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:18:10-07:00</dc:date>
        <title>replace_if</title>
        <link>http://cppreference.com/wiki/stl/algorithm/replace_if?rev=1255076290&amp;do=diff</link>
        <description>replace_if

Syntax:

    #include &lt;algorithm&gt;
    void replace_if( forward_iterator start, forward_iterator end, Predicate p, const TYPE&amp; new_value );

The replace_if() function assigns every element in the range [start,end) for
which the predicate function p returns true the value of new_value.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/reverse?rev=1255077204&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:33:24-07:00</dc:date>
        <title>reverse</title>
        <link>http://cppreference.com/wiki/stl/algorithm/reverse?rev=1255077204&amp;do=diff</link>
        <description>reverse

Syntax:

    #include &lt;algorithm&gt;
    void reverse( bidirectional_iterator start, bidirectional_iterator end );

The reverse() algorithm reverses the order of elements in the range
[start,end).

Related Topics: reverse_copy</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/reverse_copy?rev=1255077248&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:34:08-07:00</dc:date>
        <title>reverse_copy</title>
        <link>http://cppreference.com/wiki/stl/algorithm/reverse_copy?rev=1255077248&amp;do=diff</link>
        <description>reverse_copy

Syntax:

    #include &lt;algorithm&gt;
    output_iterator reverse_copy( bidirectional_iterator start, bidirectional_iterator end, output_iterator result );

The reverse_copy() algorithm copies the elements in the range [start,end) to
result such that the elements in the new range are in reverse order.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/rotate?rev=1255077475&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:37:55-07:00</dc:date>
        <title>rotate</title>
        <link>http://cppreference.com/wiki/stl/algorithm/rotate?rev=1255077475&amp;do=diff</link>
        <description>rotate

Syntax:

    #include &lt;algorithm&gt;
    void rotate( forward_iterator start, forward_iterator middle, forward_iterator end );

The rotate() algorithm moves the elements in the range [start,end) such that
the middle element is now where start used to be, (middle+1) is now at
(start+1), etc.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/rotate_copy?rev=1255077632&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:40:32-07:00</dc:date>
        <title>rotate_copy</title>
        <link>http://cppreference.com/wiki/stl/algorithm/rotate_copy?rev=1255077632&amp;do=diff</link>
        <description>rotate_copy

Syntax:

    #include &lt;algorithm&gt;
    output_iterator rotate_copy( forward_iterator start, forward_iterator middle, forward_iterator end, output_iterator result );

The rotate_copy() algorithm is similar to the rotate() algorithm, except that
the range of elements is copied to result before being rotated.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/search?rev=1255075421&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:03:41-07:00</dc:date>
        <title>search</title>
        <link>http://cppreference.com/wiki/stl/algorithm/search?rev=1255075421&amp;do=diff</link>
        <description>search

Syntax:

    #include &lt;algorithm&gt;
    forward_iterator search( forward_iterator start1, forward_iterator end1, forward_iterator2 start2, forward_iterator2 end2 );
    forward_iterator search( forward_iterator start1, forward_iterator end1, forward_iterator2 start2, forward_iterator2 end2, BinPred p );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/search_n?rev=1255075542&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:05:42-07:00</dc:date>
        <title>search_n</title>
        <link>http://cppreference.com/wiki/stl/algorithm/search_n?rev=1255075542&amp;do=diff</link>
        <description>search_n

Syntax:

    #include &lt;algorithm&gt;
    forward_iterator search_n( forward_iterator start, forward_iterator end, SIZE num, const TYPE&amp; val );
    forward_iterator search_n( forward_iterator start, forward_iterator end, SIZE num, const TYPE&amp; val, BinPred p );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/set_difference?rev=1270643449&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-04-07T05:30:49-07:00</dc:date>
        <title>set_difference</title>
        <link>http://cppreference.com/wiki/stl/algorithm/set_difference?rev=1270643449&amp;do=diff</link>
        <description>set_difference

Syntax:

    #include &lt;algorithm&gt;
    template&lt; typename InIterA, typename InIterB, typename OutIter &gt;
    OutIter set_difference( InIterA start1, InIterA end1, InIterB start2, InIterB end2, OutIter result );
    template&lt; typename InIterA, typename InIterB, typename OutIter, typename StrictWeakOrdering &gt;
    OutIter set_difference( InIterA start1, InIterA end1, InIterB start2, InIterB end2, OutIter result, StrictWeakOrdering cmp );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/set_intersection?rev=1270643602&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-04-07T05:33:22-07:00</dc:date>
        <title>set_intersection</title>
        <link>http://cppreference.com/wiki/stl/algorithm/set_intersection?rev=1270643602&amp;do=diff</link>
        <description>set_intersection

Syntax:

    #include &lt;algorithm&gt;
    template&lt; typename InIterA, typename InIterB, typename OutIter &gt;
    OutIter set_intersection( InIterA start1, InIterA end1, InIterB start2, InIterB end2, OutIter result );
    template&lt; typename InIterA, typename InIterB, typename OutIter, typename StrictWeakOrdering &gt;
    OutIter set_intersection( InIterA start1, InIterA end1, InIterB start2, InIterB end2, OutIter result, StrictWeakOrdering cmp );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/set_symmetric_difference?rev=1270643760&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-04-07T05:36:00-07:00</dc:date>
        <title>set_symmetric_difference</title>
        <link>http://cppreference.com/wiki/stl/algorithm/set_symmetric_difference?rev=1270643760&amp;do=diff</link>
        <description>set_symmetric_difference

Syntax:

    #include &lt;algorithm&gt;
    output_iterator set_symmetric_difference( input_iterator start1, input_iterator end1, input_iterator2 start2, input_iterator2 end2, output_iterator result );
    output_iterator set_symmetric_difference( input_iterator start1, input_iterator end1, input_iterator2 start2, input_iterator2 end2, output_iterator result, StrictWeakOrdering cmp );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/set_union?rev=1270643830&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-04-07T05:37:10-07:00</dc:date>
        <title>set_union</title>
        <link>http://cppreference.com/wiki/stl/algorithm/set_union?rev=1270643830&amp;do=diff</link>
        <description>set_union

Syntax:

    #include &lt;algorithm&gt;
    output_iterator set_union( input_iterator start1, input_iterator end1, input_iterator2 start2, input_iterator2 end2, output_iterator result );
    output_iterator set_union( input_iterator start1, input_iterator end1, input_iterator2 start2, input_iterator2 end2, output_iterator result, StrictWeakOrdering cmp );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/sort?rev=1276536786&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-06-14T10:33:06-07:00</dc:date>
        <title>sort</title>
        <link>http://cppreference.com/wiki/stl/algorithm/sort?rev=1276536786&amp;do=diff</link>
        <description>sort


Syntax:

    #include &lt;algorithm&gt;
    void sort( random_iterator start, random_iterator end );
    void sort( random_iterator start, random_iterator end, StrictWeakOrdering cmp );

The sort() algorithm sorts the elements in the range [start,end) into ascending
order. If two elements are equal, there is no guarantee what order they will be
in.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/sort_heap?rev=1270643912&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-04-07T05:38:32-07:00</dc:date>
        <title>sort_heap</title>
        <link>http://cppreference.com/wiki/stl/algorithm/sort_heap?rev=1270643912&amp;do=diff</link>
        <description>sort_heap

Syntax:

    #include &lt;algorithm&gt;
    void sort_heap (random_access_iterator start, random_access_iterator end);
    void sort_heap (random_access_iterator start, random_access_iterator end, StrictWeakOrdering cmp);

The sort_heap() function turns the heap defined by [start,end) into a sorted
range.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/stable_partition?rev=1255078795&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:59:55-07:00</dc:date>
        <title>stable_partition</title>
        <link>http://cppreference.com/wiki/stl/algorithm/stable_partition?rev=1255078795&amp;do=diff</link>
        <description>stable_partition

Syntax:

    #include &lt;algorithm&gt;
    bidirectional_iterator stable_partition( bidirectional_iterator start, bidirectional_iterator end, Predicate p );

The stable_partition() function behaves similarily to partition(). The
difference between the two algorithms is that stable_partition() will preserve
the initial ordering of the elements in the two groups.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/stable_sort?rev=1255357263&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-12T07:21:03-07:00</dc:date>
        <title>stable_sort</title>
        <link>http://cppreference.com/wiki/stl/algorithm/stable_sort?rev=1255357263&amp;do=diff</link>
        <description>stable_sort

Syntax:

    #include &lt;algorithm&gt;
    void stable_sort( random_access_iterator start, random_access_iterator end );
    void stable_sort( random_access_iterator start, random_access_iterator end, StrictWeakOrdering cmp );

The stable_sort() algorithm is like the sort() algorithm, in that it sorts a
range of elements into ascending order. Unlike sort(), however, stable_sort()
will preserve the original ordering of elements that are equal to each other.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/start?rev=1263907758&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-01-19T05:29:18-07:00</dc:date>
        <title>C++ Algorithms</title>
        <link>http://cppreference.com/wiki/stl/algorithm/start?rev=1263907758&amp;do=diff</link>
        <description>The following functions are defined in &lt;algorithm&gt; or &lt;numeric&gt;
, and are part of the std namespace.

accumulatesum up a range of elementsadjacent_differencecompute the differences between adjacent elements in a rangeadjacent_findfinds two identical (or some other relationship) items adjacent to each otherbinary_searchdetermine if an element exists in a certain rangecopycopy some range of elements to a new locationcopy_backwardcopy a range of elements in backwards ordercountreturn the number of …</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/swap?rev=1224024126&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2008-10-14T15:42:06-07:00</dc:date>
        <title>swap</title>
        <link>http://cppreference.com/wiki/stl/algorithm/swap?rev=1224024126&amp;do=diff</link>
        <description>swap

Syntax:

    #include &lt;algorithm&gt;
    void swap( Assignable&amp; a, Assignable&amp; b );

The swap() function swaps the values of a and b.
swap() expects that its arguments will conform to the Assignable model; that
is, they should have a copy constructor and work with the = operator. This
function performs one copy and two assignments.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/swap_ranges?rev=1255080182&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T02:23:02-07:00</dc:date>
        <title>swap_ranges</title>
        <link>http://cppreference.com/wiki/stl/algorithm/swap_ranges?rev=1255080182&amp;do=diff</link>
        <description>swap_ranges

Syntax:

    #include &lt;algorithm&gt;
    forward_iterator2 swap_ranges( forward_iterator start1, forward_iterator end1, forward_iterator2 start2 );

The swap_ranges() function exchanges the elements in the range [start1,end1)
with the range of the same size starting at start2.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/transform?rev=1269152128&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-03-20T23:15:28-07:00</dc:date>
        <title>transform</title>
        <link>http://cppreference.com/wiki/stl/algorithm/transform?rev=1269152128&amp;do=diff</link>
        <description>transform

Syntax:

    #include &lt;algorithm&gt;
    output_iterator transform( input_iterator start, input_iterator end, output_iterator result, UnaryFunction f );
    output_iterator transform( input_iterator start1, input_iterator end1, input_iterator2 start2, output_iterator result, BinaryFunction f );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/unique?rev=1270644260&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-04-07T05:44:20-07:00</dc:date>
        <title>unique</title>
        <link>http://cppreference.com/wiki/stl/algorithm/unique?rev=1270644260&amp;do=diff</link>
        <description>unique

Syntax:

    #include &lt;algorithm&gt;
    forward_iterator p_end unique( forward_iterator start, forward_iterator end );
    forward_iterator p_end unique( forward_iterator start, forward_iterator end, BinPred p );

The unique() algorithm removes all consecutive duplicate elements from the range [start, end].
The duplicate values are moved to the sequence's end.</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/unique_copy?rev=1255076132&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-09T01:15:32-07:00</dc:date>
        <title>unique_copy</title>
        <link>http://cppreference.com/wiki/stl/algorithm/unique_copy?rev=1255076132&amp;do=diff</link>
        <description>unique_copy

Syntax:

    #include &lt;algorithm&gt;
    output_iterator unique_copy( input_iterator start, input_iterator end, output_iterator result );
    output_iterator unique_copy( input_iterator start, input_iterator end, output_iterator result, BinPred p );</description>
    </item>
    <item rdf:about="http://cppreference.com/wiki/stl/algorithm/upper_bound?rev=1271996873&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2010-04-22T21:27:53-07:00</dc:date>
        <title>upper_bound</title>
        <link>http://cppreference.com/wiki/stl/algorithm/upper_bound?rev=1271996873&amp;do=diff</link>
        <description>upper_bound

Syntax:

    #include &lt;algorithm&gt;
    forward_iterator upper_bound( forward_iterator start, forward_iterator end, const TYPE&amp; val );
    forward_iterator upper_bound( forward_iterator start, forward_iterator end, const TYPE&amp; val, StrictWeakOrdering cmp );</description>
    </item>
</rdf:RDF>
