Merge bug fixes to master

Merge broken links to master. NFC
Merge for the 1.68.0 beta
2025-06-25 20:11:50 +02:00 · 2018-12-04 09:35:03 -08:00 · 2018-07-31 22:57:40 -07:00 · 2018-07-04 11:27:27 -07:00 · 2018-05-01 08:17:06 -07:00 · 2017-06-28 20:13:38 -07:00
62 changed files with 135 additions and 418 deletions
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@ -16,18 +16,17 @@ using quickbook ;
 using doxygen ;
 using boostbook ;

-doxygen autodoc 
-    : 
-        [ glob ../../../boost/algorithm/*.hpp 
+doxygen autodoc
+    :
+        [ glob ../../../boost/algorithm/*.hpp
               ../../../boost/algorithm/searching/*.hpp
               ../../../boost/algorithm/cxx11/*.hpp
               ../../../boost/algorithm/cxx14/*.hpp
-               ../../../boost/algorithm/cxx17/*.hpp
        ]
-    : 
+    :
       <doxygen:param>"PREDEFINED=\"BOOST_ALGORITHM_DOXYGEN=1\""
       <doxygen:param>WARNINGS=YES # Default NO, but useful to see warnings, especially in a logfile.
-    ; 
+    ;


 xml algorithm : algorithm.qbk ;
@ -36,13 +35,13 @@ boostbook standalone
  :
    algorithm
  :
-    <dependency>autodoc 
+    <dependency>autodoc
    <xsl:param>boost.root=../../../..
    <xsl:param>"boost.doxygen.reftitle=Boost.Algorithms C++ Reference"
    <xsl:param>chapter.autolabel=0
    <xsl:param>chunk.section.depth=8
-    <xsl:param>toc.section.depth=3
-    <xsl:param>toc.max.depth=3
+    <xsl:param>toc.section.depth=2
+    <xsl:param>toc.max.depth=2
    <xsl:param>generate.section.toc.level=1
  ;

--- a/doc/algorithm.qbk
+++ b/doc/algorithm.qbk
@ -46,11 +46,7 @@ Thanks to all the people who have reviewed this library and made suggestions for
 [include knuth_morris_pratt.qbk]
 [endsect]

-
 [section:CXX11 C++11 Algorithms]
-
-[section:CXX11_inner_algorithms]
-
 [include all_of.qbk]
 [include any_of.qbk]
 [include none_of.qbk]
@ -59,204 +55,24 @@ Thanks to all the people who have reviewed this library and made suggestions for
 [include is_partitioned.qbk]
 [include is_permutation.qbk]
 [include partition_point.qbk]
-
-[section:partition_copy partition_copy ]
-[*[^[link header.boost.algorithm.cxx11.partition_copy_hpp            partition_copy]              ] ]
-Copy a subset of a sequence to a new sequence
-[endsect:partition_copy]
-
-[section:copy_if        copy_if        ]
-[*[^[link header.boost.algorithm.cxx11.copy_if_hpp                   copy_if]                     ] ]
-Copy a subset of a sequence to a new sequence
-[endsect:copy_if]
-
-[section:copy_n         copy_n         ]
-[*[^[link header.boost.algorithm.cxx11.copy_n_hpp                    copy_n]                      ] ]
-Copy n items from one sequence to another
-[endsect:copy_n]
-
-[section:iota           iota           ]
-[*[^[link header.boost.algorithm.cxx11.iota_hpp                      iota]                        ] ]
-Generate an increasing series
-[endsect:iota]
-
-[endsect:CXX11_inner_algorithms]
-
-[endsect:CXX11]
-
+[endsect]

 [section:CXX14 C++14 Algorithms]
-
-[section:CXX14_inner_algorithms]
-
 [include equal.qbk]
 [include mismatch.qbk]
-
-[endsect:CXX14_inner_algorithms]
-
-[endsect:CXX14]
-
-
-[section:CXX17 C++17 Algorithms]
-
-[section:CXX17_inner_algorithms]
-
-[section:for_each_n for_each_n]
-[*[^[link boost.algorithm.for_each_n                                 for_each_n]                  ] ]
-Apply a functor to the elements of a sequence
-[endsect:for_each_n]
-
-[endsect:CXX17_inner_algorithms]
-
-[endsect:CXX17]
-
+[endsect]

 [section:Misc Other Algorithms]
-
-[section:misc_inner_algorithms]
-
-[section:none_of_equal             none_of_equal             ]
-[*[^[link header.boost.algorithm.cxx11.none_of_hpp                   none_of_equal]               ] ]
-Whether none of a range's elements matches a value
-[endsect:none_of_equal]
-
-[section:one_of_equal              one_of_equal              ]
-[*[^[link header.boost.algorithm.cxx11.one_of_hpp                    one_of_equal]                ] ]
-Whether only one of a range's elements matches a value
-[endsect:one_of_equal]
-
-[section:is_decreasing             is_decreasing             ]
-[*[^[link header.boost.algorithm.cxx11.is_sorted_hpp                 is_decreasing]               ] ]
-Whether an entire sequence is decreasing; i.e, each item is less than or equal to the previous one
-[endsect:is_decreasing]
-
-[section:is_increasing             is_increasing             ]
-[*[^[link header.boost.algorithm.cxx11.is_sorted_hpp                 is_increasing]               ] ]
-Whether an entire sequence is increasing; i.e, each item is greater than or equal to the previous one
-[endsect:is_increasing]
-
-[section:is_strictly_decreasing    is_strictly_decreasing    ]
-[*[^[link header.boost.algorithm.cxx11.is_sorted_hpp                 is_strictly_decreasing]      ] ]
-Whether an entire sequence is strictly decreasing; i.e, each item is less than the previous one
-[endsect:is_strictly_decreasing]
-
-[section:is_strictly_increasing    is_strictly_increasing    ]
-[*[^[link header.boost.algorithm.cxx11.is_sorted_hpp                 is_strictly_increasing]      ] ]
-Whether an entire sequence is strictly increasing; i.e, each item is greater than the previous one
-[endsect:is_strictly_increasing]
-
 [include clamp-hpp.qbk]
-
-[section:clamp_range               clamp_range               ]
-[*[^[link header.boost.algorithm.clamp_hpp                           clamp_range]                 ] ]
-Perform [^clamp] on the elements of a range and write the results into an output iterator
-[endsect:clamp_range]
-
 [include find_not.qbk]
-
 [include find_backward.qbk]
-
-[section:find_not_backward         find_not_backward         ]
-[*[^[link header.boost.algorithm.find_backward_hpp                   find_not_backward]           ] ]
-Find the last element in a sequence that does not equal a value.
-See [link the_boost_algorithm_library.Misc.misc_inner_algorithms.find_backward find_backward].
-[endsect:find_not_backward]
-
-[section:find_if_backward          find_if_backward          ]
-[*[^[link header.boost.algorithm.find_backward_hpp                   find_if_backward]            ] ]
-Find the last element in a sequence that satisfies a predicate.
-See [link the_boost_algorithm_library.Misc.misc_inner_algorithms.find_backward find_backward].
-[endsect:find_if_backward]
-
-[section:find_if_not               find_if_not               ]
-[*[^[link header.boost.algorithm.cxx11.find_if_not_hpp               find_if_not]                 ] ]
-Find the first element in a sequence that does not satisfy a predicate.
-See [link the_boost_algorithm_library.Misc.misc_inner_algorithms.find_not find_not].
-[endsect:find_if_not]
-
-[section:find_if_not_backward      find_if_not_backward      ]
-[*[^[link header.boost.algorithm.find_backward_hpp                   find_if_not_backward]        ] ]
-Find the last element in a sequence that does not satisfy a predicate.
-See [link the_boost_algorithm_library.Misc.misc_inner_algorithms.find_backward find_backward].
-[endsect:find_if_not_backward]
-
 [include gather.qbk]
-
 [include hex.qbk]
-
-[section:unhex                     unhex                     ]
-[*[^[link header.boost.algorithm.hex_hpp                             unhex]                       ] ]
-Convert a sequence of hexadecimal characters into a sequence of integers or characters
-[endsect:unhex]
-
-[section:hex_lower                 hex_lower                 ]
-[*[^[link header.boost.algorithm.hex_hpp                             hex_lower]                   ] ]
-Convert a sequence of integral types into a lower case hexadecimal sequence of characters
-[endsect:hex_lower]
-
 [include is_palindrome.qbk]
-
 [include is_partitioned_until.qbk]
-
-[section:apply_reverse_permutation apply_reverse_permutation ]
-See below
-[endsect:apply_reverse_permutation]
-
 [include apply_permutation.qbk]
+[endsect]

-[section:copy_until                copy_until                ]
-[*[^[link header.boost.algorithm.cxx11.copy_if_hpp                   copy_until]                  ] ]
-Copy all the elements at the start of the input range that do not satisfy the predicate to the output range
-[endsect:copy_until]
-
-[section:copy_while                copy_while                ]
-[*[^[link header.boost.algorithm.cxx11.copy_if_hpp                   copy_while]                  ] ]
-Copy all the elements at the start of the input range that satisfy the predicate to the output range
-[endsect:copy_while]
-
-[section:iota_n                    iota_n                    ]
-[*[^[link boost.algorithm.iota_n                                     iota_n]                      ] ]
-Write a sequence of n increasing values to an output iterator
-[endsect:iota_n]
-
-[section:power                     power                     ]
-[*[^[link header.boost.algorithm.algorithm_hpp                       power]                       ] ]
-Raise a value to an integral power ([^constexpr] since C++14)
-[endsect:power]
-
-[endsect:misc_inner_algorithms]
-
-[endsect:Misc]
-
-
-[section:not_yet_documented_cxx17_algos Not-yet-documented C++17 Algorithms]
-
-* [*[^[link header.boost.algorithm.cxx17.exclusive_scan_hpp            exclusive_scan]              ] ]
-* [*[^[link header.boost.algorithm.cxx17.inclusive_scan_hpp            inclusive_scan]              ] ]
-* [*[^[link header.boost.algorithm.cxx17.reduce_hpp                    reduce]                      ] ]
-* [*[^[link header.boost.algorithm.cxx17.transform_exclusive_scan_hpp  transform_exclusive_scan]    ] ]
-* [*[^[link header.boost.algorithm.cxx17.transform_inclusive_scan_hpp  transform_inclusive_scan]    ] ]
-* [*[^[link header.boost.algorithm.cxx17.transform_reduce_hpp          transform_reduce]            ] ]
-
-[endsect:not_yet_documented_cxx17_algos]
-
-
-[section:not_yet_documented_other_algos Not-yet-documented Other Algorithms]
-
-* [*[^[link header.boost.algorithm.minmax_hpp                          minmax]                      ] ]
-* [*[^[link header.boost.algorithm.minmax_element_hpp                  first_max_element]           ] ]
-* [*[^[link header.boost.algorithm.minmax_element_hpp                  first_min_element]           ] ]
-* [*[^[link header.boost.algorithm.minmax_element_hpp                  first_min_first_max_element] ] ]
-* [*[^[link header.boost.algorithm.minmax_element_hpp                  first_min_last_max_element]  ] ]
-* [*[^[link header.boost.algorithm.minmax_element_hpp                  last_max_element]            ] ]
-* [*[^[link header.boost.algorithm.minmax_element_hpp                  last_min_element]            ] ]
-* [*[^[link header.boost.algorithm.minmax_element_hpp                  last_min_first_max_element]  ] ]
-* [*[^[link header.boost.algorithm.minmax_element_hpp                  last_min_last_max_element]   ] ]
-* [*[^[link header.boost.algorithm.minmax_element_hpp                  minmax_element]              ] ]
-* [*[^[link header.boost.algorithm.sort_subrange_hpp                   partition_subrange]          ] ]
-* [*[^[link header.boost.algorithm.sort_subrange_hpp                   sort_subrange]               ] ]
-
-[endsect:not_yet_documented_other_algos]


 [xinclude autodoc.xml]
--- a/doc/apply_permutation.qbk
+++ b/doc/apply_permutation.qbk
@ -9,7 +9,7 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ]

-The header file [^[link header.boost.algorithm.apply_permutation_hpp apply_permutation.hpp]] contains two algorithms, `apply_permutation` and `apply_reverse_permutation`. There are also range-based versions.
+The header file 'apply_permutation.hpp' contains two algorithms, apply_permutation and apply_reverse_permutation. Also there are range-based versions. 
 The algorithms transform the item sequence according to index sequence order.

 The routine `apply_permutation` takes a item sequence and a order sequence. It reshuffles item sequence according to order sequence. Every value in order sequence means where the item comes from. Order sequence needs to be exactly a permutation of the sequence [0, 1, ... , N], where N is the biggest index in the item sequence (zero-indexed).
--- a/example/Jamfile.v2
+++ b/example/Jamfile.v2
@ -18,8 +18,8 @@ project /boost/algorithm/example
    :
    ;

-exe clamp_example   : clamp_example.cpp : ;
+exe clamp_example   : clamp_example.cpp ;
 exe search_example  : search_example.cpp ;
-exe is_palindrome_example  : is_palindrome_example.cpp : <cxxstd>11 ;
-exe is_partitioned_until_example  : is_partitioned_until_example.cpp : <cxxstd>11 ;
-exe apply_permutation_example  : apply_permutation_example.cpp : <cxxstd>11 ;
+exe is_palindrome_example  : is_palindrome_example.cpp;
+exe is_partitioned_until_example  : is_partitioned_until_example.cpp;
+exe apply_permutation_example  : apply_permutation_example.cpp;
--- a/example/is_partitioned_until_example.cpp
+++ b/example/is_partitioned_until_example.cpp
@ -32,8 +32,8 @@ struct isOddComp

 int main ( int /*argc*/, char * /*argv*/ [] )
 {
-    std::vector<int> good{1, 2, 4};
-    std::vector<int> bad{1, 2, 3};
+    std::vector<int> good({1, 2, 4});
+    std::vector<int> bad({1, 2, 3});

    //Use custom function
    auto it1 = ba::is_partitioned_until(good.begin(), good.end(), isOdd);
--- a/example/search_example.cpp
+++ b/example/search_example.cpp
@ -27,7 +27,7 @@ int main ( int /*argc*/, char * /*argv*/ [] ) {
 //  algorithms. They all have the same (dual) interface.

 //  There is a procedural interface, based on std::search:
-    if ( ba::boyer_moore_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != std::make_pair(haystack.end(), haystack.end()))
+    if ( ba::boyer_moore_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != haystack.end ())
        std::cout << "Found '" << needle1 << "'  in '" << haystack << "' (boyer-moore 1)" << std::endl;
    else
        std::cout << "Did NOT find '" << needle1 << "'  in '" << haystack << "' (boyer-moore 1)" << std::endl;
@ -36,19 +36,19 @@ int main ( int /*argc*/, char * /*argv*/ [] ) {
 //  you can create a search object and use that over and over again - amortizing the setup
 //  costs across several searches
    ba::boyer_moore<std::string::const_iterator> search1 ( needle1.begin (), needle1.end ());
-    if ( search1 ( haystack.begin (), haystack.end ()) != std::make_pair(haystack.end(), haystack.end()))
+    if ( search1 ( haystack.begin (), haystack.end ()) != haystack.end ())
        std::cout << "Found '" << needle1 << "'  in '" << haystack << "' (boyer-moore 2)" << std::endl;
    else
        std::cout << "Did NOT find '" << needle1 << "'  in '" << haystack << "' (boyer-moore 2)" << std::endl;

 //  There is also an implementation of boyer-moore-horspool searching
-    if ( ba::boyer_moore_horspool_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != std::make_pair(haystack.end(), haystack.end()))
+    if ( ba::boyer_moore_horspool_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != haystack.end ())
        std::cout << "Found '" << needle1 << "'  in '" << haystack << "' (boyer-moore-horspool)" << std::endl;
    else
        std::cout << "Did NOT find '" << needle1 << "'  in '" << haystack << "' (boyer-moore-horspool)" << std::endl;

 //  And also the knuth-pratt-morris search algorithm
-    if ( ba::knuth_morris_pratt_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != std::make_pair(haystack.end(), haystack.end()))
+    if ( ba::knuth_morris_pratt_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != haystack.end ())
        std::cout << "Found '" << needle1 << "'  in '" << haystack << "' (knuth_morris_pratt)" << std::endl;
    else
        std::cout << "Did NOT find '" << needle1 << "'  in '" << haystack << "' (knuth_morris_pratt)" << std::endl;
--- a/include/boost/algorithm/algorithm.hpp
+++ b/include/boost/algorithm/algorithm.hpp
@ -19,7 +19,6 @@

 #include <functional> // for plus and multiplies

-#include <boost/config.hpp>
 #include <boost/utility/enable_if.hpp> // for boost::disable_if
 #include <boost/type_traits/is_integral.hpp>

--- a/include/boost/algorithm/apply_permutation.hpp
+++ b/include/boost/algorithm/apply_permutation.hpp
@ -21,7 +21,6 @@
 #include <algorithm>
 #include <type_traits>

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

--- a/include/boost/algorithm/clamp.hpp
+++ b/include/boost/algorithm/clamp.hpp
@ -23,7 +23,6 @@
 #include <iterator>         //  For std::iterator_traits
 #include <cassert>

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/mpl/identity.hpp>      // for identity
--- a/include/boost/algorithm/cxx11/all_of.hpp
+++ b/include/boost/algorithm/cxx11/all_of.hpp
@ -12,7 +12,6 @@
 #ifndef BOOST_ALGORITHM_ALL_OF_HPP
 #define BOOST_ALGORITHM_ALL_OF_HPP

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

--- a/include/boost/algorithm/cxx11/any_of.hpp
+++ b/include/boost/algorithm/cxx11/any_of.hpp
@ -14,7 +14,6 @@
 #ifndef BOOST_ALGORITHM_ANY_OF_HPP
 #define BOOST_ALGORITHM_ANY_OF_HPP

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

--- a/include/boost/algorithm/cxx11/copy_if.hpp
+++ b/include/boost/algorithm/cxx11/copy_if.hpp
@ -13,8 +13,6 @@
 #define BOOST_ALGORITHM_COPY_IF_HPP

 #include <utility>    // for std::pair, std::make_pair
-
-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

--- a/include/boost/algorithm/cxx11/copy_n.hpp
+++ b/include/boost/algorithm/cxx11/copy_n.hpp
@ -12,8 +12,6 @@
 #ifndef BOOST_ALGORITHM_COPY_N_HPP
 #define BOOST_ALGORITHM_COPY_N_HPP

-#include <boost/config.hpp>
-
 namespace boost { namespace algorithm {

 /// \fn copy_n ( InputIterator first, Size n, OutputIterator result )
--- a/include/boost/algorithm/cxx11/find_if_not.hpp
+++ b/include/boost/algorithm/cxx11/find_if_not.hpp
@ -12,7 +12,6 @@
 #ifndef BOOST_ALGORITHM_FIND_IF_NOT_HPP
 #define BOOST_ALGORITHM_FIND_IF_NOT_HPP

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

--- a/include/boost/algorithm/cxx11/iota.hpp
+++ b/include/boost/algorithm/cxx11/iota.hpp
@ -12,7 +12,6 @@
 #ifndef BOOST_ALGORITHM_IOTA_HPP
 #define BOOST_ALGORITHM_IOTA_HPP

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

--- a/include/boost/algorithm/cxx11/is_partitioned.hpp
+++ b/include/boost/algorithm/cxx11/is_partitioned.hpp
@ -12,7 +12,6 @@
 #ifndef BOOST_ALGORITHM_IS_PARTITIONED_HPP
 #define BOOST_ALGORITHM_IS_PARTITIONED_HPP

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

--- a/include/boost/algorithm/cxx11/is_permutation.hpp
+++ b/include/boost/algorithm/cxx11/is_permutation.hpp
@ -17,7 +17,6 @@
 #include <functional>   // for std::equal_to
 #include <iterator>

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/utility/enable_if.hpp>
--- a/include/boost/algorithm/cxx11/is_sorted.hpp
+++ b/include/boost/algorithm/cxx11/is_sorted.hpp
@ -16,7 +16,6 @@
 #include <functional>
 #include <iterator>

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

--- a/include/boost/algorithm/cxx11/none_of.hpp
+++ b/include/boost/algorithm/cxx11/none_of.hpp
@ -12,7 +12,6 @@
 #ifndef BOOST_ALGORITHM_NONE_OF_HPP
 #define BOOST_ALGORITHM_NONE_OF_HPP

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

--- a/include/boost/algorithm/cxx11/one_of.hpp
+++ b/include/boost/algorithm/cxx11/one_of.hpp
@ -12,12 +12,10 @@
 #ifndef BOOST_ALGORITHM_ONE_OF_HPP
 #define BOOST_ALGORITHM_ONE_OF_HPP

-#include <boost/config.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
 #include <boost/algorithm/cxx11/none_of.hpp>

+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>

 namespace boost { namespace algorithm {

--- a/include/boost/algorithm/cxx11/partition_point.hpp
+++ b/include/boost/algorithm/cxx11/partition_point.hpp
@ -14,7 +14,6 @@

 #include <iterator>    // for std::distance, advance

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

--- a/include/boost/algorithm/cxx14/equal.hpp
+++ b/include/boost/algorithm/cxx14/equal.hpp
@ -14,8 +14,6 @@

 #include <iterator>

-#include <boost/config.hpp>
-
 namespace boost { namespace algorithm {

 namespace detail {
--- a/include/boost/algorithm/cxx14/is_permutation.hpp
+++ b/include/boost/algorithm/cxx14/is_permutation.hpp
@ -16,7 +16,6 @@
 #include <functional>   // for std::equal_to
 #include <iterator>

-#include <boost/config.hpp>
 #include <boost/algorithm/cxx11/is_permutation.hpp>
 #include <boost/algorithm/cxx14/mismatch.hpp>

--- a/include/boost/algorithm/cxx14/mismatch.hpp
+++ b/include/boost/algorithm/cxx14/mismatch.hpp
@ -13,7 +13,6 @@
 #define BOOST_ALGORITHM_MISMATCH_HPP

 #include <utility>      // for std::pair
-
 #include <boost/config.hpp>

 namespace boost { namespace algorithm {
--- a/include/boost/algorithm/cxx17/exclusive_scan.hpp
+++ b/include/boost/algorithm/cxx17/exclusive_scan.hpp
@ -15,7 +15,6 @@
 #include <functional>     // for std::plus
 #include <iterator>       // for std::iterator_traits

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/value_type.hpp>
--- a/include/boost/algorithm/cxx17/for_each_n.hpp
+++ b/include/boost/algorithm/cxx17/for_each_n.hpp
@ -14,8 +14,6 @@

 #include <utility>      // for std::pair

-#include <boost/config.hpp>
-
 namespace boost { namespace algorithm {

 /// \fn for_each_n(InputIterator first, Size n, Function f);
--- a/include/boost/algorithm/cxx17/inclusive_scan.hpp
+++ b/include/boost/algorithm/cxx17/inclusive_scan.hpp
@ -9,13 +9,12 @@
 /// \brief Combine the (transformed) elements of a sequence (or two) into a single value.
 /// \author Marshall Clow

-#ifndef BOOST_ALGORITHM_INCLUSIVE_SCAN_HPP
-#define BOOST_ALGORITHM_INCLUSIVE_SCAN_HPP
+#ifndef BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
+#define BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP

 #include <functional>     // for std::plus
 #include <iterator>       // for std::iterator_traits

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/value_type.hpp>
@ -58,4 +57,4 @@ OutputIterator inclusive_scan(InputIterator first, InputIterator last,

 }} // namespace boost and algorithm

-#endif // BOOST_ALGORITHM_INCLUSIVE_SCAN_HPP
+#endif // BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
--- a/include/boost/algorithm/cxx17/reduce.hpp
+++ b/include/boost/algorithm/cxx17/reduce.hpp
@ -15,7 +15,6 @@
 #include <functional>     // for std::plus
 #include <iterator>       // for std::iterator_traits

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/value_type.hpp>
--- a/include/boost/algorithm/cxx17/transform_exclusive_scan.hpp
+++ b/include/boost/algorithm/cxx17/transform_exclusive_scan.hpp
@ -15,7 +15,6 @@
 #include <functional>     // for std::plus
 #include <iterator>       // for std::iterator_traits

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/value_type.hpp>
--- a/include/boost/algorithm/cxx17/transform_inclusive_scan.hpp
+++ b/include/boost/algorithm/cxx17/transform_inclusive_scan.hpp
@ -15,7 +15,6 @@
 #include <functional>     // for std::plus
 #include <iterator>       // for std::iterator_traits

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/value_type.hpp>
--- a/include/boost/algorithm/cxx17/transform_reduce.hpp
+++ b/include/boost/algorithm/cxx17/transform_reduce.hpp
@ -15,7 +15,6 @@
 #include <functional>     // for std::plus
 #include <iterator>       // for std::iterator_traits

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/value_type.hpp>
--- a/include/boost/algorithm/find_backward.hpp
+++ b/include/boost/algorithm/find_backward.hpp
@ -2,17 +2,18 @@
   Copyright (c) T. Zachary Laine 2018.

   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
 */
 #ifndef BOOST_ALGORITHM_FIND_BACKWARD_HPP
 #define BOOST_ALGORITHM_FIND_BACKWARD_HPP

-#include <utility>
-
 #include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

+#include <utility>
+
+
 namespace boost { namespace algorithm {

 template<typename BidiIter, typename T>
--- a/include/boost/algorithm/find_not.hpp
+++ b/include/boost/algorithm/find_not.hpp
@ -2,17 +2,18 @@
   Copyright (c) T. Zachary Laine 2018.

   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
 */
 #ifndef BOOST_ALGORITHM_FIND_NOT_HPP
 #define BOOST_ALGORITHM_FIND_NOT_HPP

-#include <utility>
-
 #include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

+#include <utility>
+
+
 namespace boost { namespace algorithm {

 template<typename InputIter, typename Sentinel, typename T>        
--- a/include/boost/algorithm/gather.hpp
+++ b/include/boost/algorithm/gather.hpp
@ -22,10 +22,8 @@

 #include <algorithm>                // for std::stable_partition
 #include <functional>
-#include <utility>                  // for std::make_pair

-#include <boost/config.hpp>
-#include <boost/bind/bind.hpp>      // for boost::bind
+#include <boost/bind.hpp>           // for boost::bind
 #include <boost/range/begin.hpp>    // for boost::begin(range)
 #include <boost/range/end.hpp>      // for boost::end(range)

@ -82,14 +80,13 @@ namespace boost { namespace algorithm {
 */

 template <
-    typename BidirectionalIterator,  // models BidirectionalIterator
-    typename Pred>                   // models UnaryPredicate
+    typename BidirectionalIterator,  // Iter models BidirectionalIterator
+    typename Pred>                   // Pred models UnaryPredicate
 std::pair<BidirectionalIterator, BidirectionalIterator> gather 
        ( BidirectionalIterator first, BidirectionalIterator last, BidirectionalIterator pivot, Pred pred )
 {
 //  The first call partitions everything up to (but not including) the pivot element,
 //  while the second call partitions the rest of the sequence.
-    using namespace boost::placeholders;
    return std::make_pair (
        std::stable_partition ( first, pivot, !boost::bind<bool> ( pred, _1 )),
        std::stable_partition ( pivot, last,   boost::bind<bool> ( pred, _1 )));
--- a/include/boost/algorithm/hex.hpp
+++ b/include/boost/algorithm/hex.hpp
@ -23,7 +23,6 @@
 #include <iterator>     // for std::iterator_traits
 #include <stdexcept>

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/exception/exception.hpp>
--- a/include/boost/algorithm/is_palindrome.hpp
+++ b/include/boost/algorithm/is_palindrome.hpp
@ -19,7 +19,6 @@
 #include <functional>
 #include <cstring>

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

--- a/include/boost/algorithm/is_partitioned_until.hpp
+++ b/include/boost/algorithm/is_partitioned_until.hpp
@ -12,7 +12,6 @@
 #ifndef BOOST_ALGORITHM_IS_PARTITIONED_UNTIL_HPP
 #define BOOST_ALGORITHM_IS_PARTITIONED_UNTIL_HPP

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

--- a/include/boost/algorithm/minmax.hpp
+++ b/include/boost/algorithm/minmax.hpp
@ -25,7 +25,6 @@
 *
 */

-#include <boost/config.hpp>
 #include <boost/tuple/tuple.hpp> // for using pairs with boost::cref
 #include <boost/ref.hpp>

--- a/include/boost/algorithm/minmax_element.hpp
+++ b/include/boost/algorithm/minmax_element.hpp
@ -28,8 +28,6 @@

 #include <utility> // for std::pair and std::make_pair

-#include <boost/config.hpp>
-
 namespace boost {

  namespace detail {  // for obtaining a uniform version of minmax_element
--- a/include/boost/algorithm/searching/boyer_moore.hpp
+++ b/include/boost/algorithm/searching/boyer_moore.hpp
@ -12,7 +12,6 @@

 #include <iterator>     // for std::iterator_traits

-#include <boost/config.hpp>
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>

--- a/include/boost/algorithm/searching/boyer_moore_horspool.hpp
+++ b/include/boost/algorithm/searching/boyer_moore_horspool.hpp
@ -12,7 +12,6 @@

 #include <iterator>     // for std::iterator_traits

-#include <boost/config.hpp>
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>

--- a/include/boost/algorithm/searching/knuth_morris_pratt.hpp
+++ b/include/boost/algorithm/searching/knuth_morris_pratt.hpp
@ -13,7 +13,6 @@
 #include <vector>
 #include <iterator>     // for std::iterator_traits

-#include <boost/config.hpp>
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>

--- a/include/boost/algorithm/sort_subrange.hpp
+++ b/include/boost/algorithm/sort_subrange.hpp
@ -22,7 +22,6 @@
 #include <iterator>         // For std::iterator_traits
 #include <algorithm>        // For nth_element and partial_sort

-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

--- a/include/boost/algorithm/string/compare.hpp
+++ b/include/boost/algorithm/string/compare.hpp
@ -65,7 +65,7 @@ namespace boost {
            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {
-                #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
+                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
                    return std::toupper(Arg1)==std::toupper(Arg2);
                #else
                    return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc);
@ -118,7 +118,7 @@ namespace boost {
            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {
-                #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
+                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
                    return std::toupper(Arg1)<std::toupper(Arg2);
                #else
                    return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc);
@ -171,7 +171,7 @@ namespace boost {
            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {
-                #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
+                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
                    return std::toupper(Arg1)<=std::toupper(Arg2);
                #else
                    return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc);
--- a/include/boost/algorithm/string/detail/case_conv.hpp
+++ b/include/boost/algorithm/string/detail/case_conv.hpp
@ -15,9 +15,6 @@
 #include <locale>
 #include <functional>

-#include <boost/iterator/transform_iterator.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
 #include <boost/type_traits/make_unsigned.hpp>

 namespace boost {
@ -43,7 +40,7 @@ namespace boost {
                // Operation
                CharT operator ()( CharT Ch ) const
                {
-                    #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
+                    #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
                        return std::tolower( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch ));
                    #else
                        return std::tolower<CharT>( Ch, *m_Loc );
@ -65,7 +62,7 @@ namespace boost {
                // Operation
                CharT operator ()( CharT Ch ) const
                {
-                    #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
+                    #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
                        return std::toupper( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch ));
                    #else
                        return std::toupper<CharT>( Ch, *m_Loc );
--- a/include/boost/algorithm/string/detail/classification.hpp
+++ b/include/boost/algorithm/string/detail/classification.hpp
@ -13,12 +13,10 @@

 #include <boost/algorithm/string/config.hpp>
 #include <algorithm>
-#include <cstring>
 #include <functional>
 #include <locale>

 #include <boost/range/begin.hpp>
-#include <boost/range/distance.hpp>
 #include <boost/range/end.hpp>

 #include <boost/algorithm/string/predicate_facade.hpp>
@ -47,7 +45,7 @@ namespace boost {
                    return std::use_facet< std::ctype<CharT> >(m_Locale).is( m_Type, Ch );
                }

-                #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x582) && !defined(_USE_OLD_RW_STL)
+                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x582) && !defined(_USE_OLD_RW_STL)
                    template<>
                    bool operator()( char const Ch ) const
                    {
--- a/include/boost/algorithm/string/detail/find_format_all.hpp
+++ b/include/boost/algorithm/string/detail/find_format_all.hpp
@ -18,8 +18,6 @@
 #include <boost/algorithm/string/detail/find_format_store.hpp>
 #include <boost/algorithm/string/detail/replace_storage.hpp>

-#include <deque>
-
 namespace boost {
    namespace algorithm {
        namespace detail {
--- a/include/boost/algorithm/string/detail/finder.hpp
+++ b/include/boost/algorithm/string/detail/finder.hpp
@ -13,7 +13,7 @@

 #include <boost/algorithm/string/config.hpp>
 #include <boost/algorithm/string/constants.hpp>
-#include <iterator>
+#include <boost/detail/iterator.hpp>

 #include <boost/range/iterator_range_core.hpp>
 #include <boost/range/begin.hpp>
@ -127,8 +127,8 @@ namespace boost {
                    if( boost::empty(m_Search) )
                        return result_type( End, End );

-                    typedef BOOST_STRING_TYPENAME
-                        std::iterator_traits<ForwardIteratorT>::iterator_category category;
+                    typedef BOOST_STRING_TYPENAME boost::detail::
+                        iterator_traits<ForwardIteratorT>::iterator_category category;

                    return findit( Begin, End, category() );
                }
@ -344,8 +344,9 @@ namespace boost {
                typedef iterator_range<ForwardIteratorT> result_type;

                input_iterator_type It=Begin;
-                for( unsigned int Index=0; Index<N && It!=End; ++Index,++It )
-                    ;
+                for(
+                    unsigned int Index=0;
+                    Index<N && It!=End; ++Index,++It ) {};

                return result_type( Begin, It );
            }
@ -374,8 +375,8 @@ namespace boost {
                ForwardIteratorT End,
                unsigned int N )
            {
-                typedef BOOST_STRING_TYPENAME
-                    std::iterator_traits<ForwardIteratorT>::iterator_category category;
+                typedef BOOST_STRING_TYPENAME boost::detail::
+                    iterator_traits<ForwardIteratorT>::iterator_category category;

                return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() );
            }
@ -396,12 +397,10 @@ namespace boost {
                input_iterator_type It2=Begin;

                // Advance It2 by N increments
-                for( Index=0; Index<N && It2!=End; ++Index,++It2 )
-                    ;
+                for( Index=0; Index<N && It2!=End; ++Index,++It2 ) {};

                // Advance It, It2 to the end
-                for(; It2!=End; ++It,++It2 )
-                	;
+                for(; It2!=End; ++It,++It2 ) {};

                return result_type( It, It2 );
            }
@ -418,8 +417,9 @@ namespace boost {
                typedef iterator_range<ForwardIteratorT> result_type;

                input_iterator_type It=End;
-                for( unsigned int Index=0; Index<N && It!=Begin; ++Index,--It )
-                    ;
+                for(
+                    unsigned int Index=0;
+                    Index<N && It!=Begin; ++Index,--It ) {};

                return result_type( It, End );
            }
@ -448,8 +448,8 @@ namespace boost {
                ForwardIteratorT End,
                unsigned int N )
            {
-                typedef BOOST_STRING_TYPENAME
-                    std::iterator_traits<ForwardIteratorT>::iterator_category category;
+                typedef BOOST_STRING_TYPENAME boost::detail::
+                    iterator_traits<ForwardIteratorT>::iterator_category category;

                return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() );
            }
--- a/include/boost/algorithm/string/detail/formatter.hpp
+++ b/include/boost/algorithm/string/detail/formatter.hpp
@ -42,7 +42,7 @@ namespace boost {
                    m_Format(::boost::begin(Format), ::boost::end(Format)) {}

                // Operation
-#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
                template<typename Range2T>
                result_type& operator()(const Range2T&)
                {
--- a/include/boost/algorithm/string/detail/trim.hpp
+++ b/include/boost/algorithm/string/detail/trim.hpp
@ -12,7 +12,7 @@
 #define BOOST_STRING_TRIM_DETAIL_HPP

 #include <boost/algorithm/string/config.hpp>
-#include <iterator>
+#include <boost/detail/iterator.hpp>

 namespace boost {
    namespace algorithm {
@ -80,8 +80,8 @@ namespace boost {
                ForwardIteratorT InEnd, 
                PredicateT IsSpace )
            {
-                typedef BOOST_STRING_TYPENAME
-                    std::iterator_traits<ForwardIteratorT>::iterator_category category;
+                typedef BOOST_STRING_TYPENAME boost::detail::
+                    iterator_traits<ForwardIteratorT>::iterator_category category;

                return ::boost::algorithm::detail::trim_end_iter_select( InBegin, InEnd, IsSpace, category() );
            }
--- a/include/boost/algorithm/string/find_format.hpp
+++ b/include/boost/algorithm/string/find_format.hpp
@ -12,6 +12,7 @@
 #define BOOST_STRING_FIND_FORMAT_HPP

 #include <deque>
+#include <boost/detail/iterator.hpp>
 #include <boost/range/iterator_range_core.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
@ -39,7 +40,7 @@ namespace boost {
            this substring and replace it in the input.
            The result is a modified copy of the input. It is returned as a sequence 
            or copied to the output iterator.
-
+    
            \param Output An output iterator to which the result will be copied
            \param Input An input sequence
            \param Finder A Finder object used to search for a match to be replaced
--- a/include/boost/algorithm/string/formatter.hpp
+++ b/include/boost/algorithm/string/formatter.hpp
@ -11,6 +11,7 @@
 #ifndef BOOST_STRING_FORMATTER_HPP
 #define BOOST_STRING_FORMATTER_HPP

+#include <boost/detail/iterator.hpp>
 #include <boost/range/value_type.hpp>
 #include <boost/range/iterator_range_core.hpp>
 #include <boost/range/as_literal.hpp>
--- a/include/boost/algorithm/string/iter_find.hpp
+++ b/include/boost/algorithm/string/iter_find.hpp
@ -71,11 +71,7 @@ namespace boost {
        inline SequenceSequenceT&
        iter_find(
            SequenceSequenceT& Result,
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-            RangeT&& Input,
-#else
            RangeT& Input,
-#endif
            FinderT Finder )
        {
            BOOST_CONCEPT_ASSERT((
@ -146,11 +142,7 @@ namespace boost {
        inline SequenceSequenceT&
        iter_split(
            SequenceSequenceT& Result,
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-            RangeT&& Input,
-#else
            RangeT& Input,
-#endif
            FinderT Finder )
        {
            BOOST_CONCEPT_ASSERT((
--- a/include/boost/algorithm/string/predicate.hpp
+++ b/include/boost/algorithm/string/predicate.hpp
@ -11,7 +11,6 @@
 #ifndef BOOST_STRING_PREDICATE_HPP
 #define BOOST_STRING_PREDICATE_HPP

-#include <iterator>
 #include <boost/algorithm/string/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
@ -145,10 +144,10 @@ namespace boost {
            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
            iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));

-            typedef BOOST_STRING_TYPENAME
+            typedef BOOST_STRING_TYPENAME 
                range_const_iterator<Range1T>::type Iterator1T;
-            typedef BOOST_STRING_TYPENAME
-                std::iterator_traits<Iterator1T>::iterator_category category;
+            typedef BOOST_STRING_TYPENAME boost::detail::
+                iterator_traits<Iterator1T>::iterator_category category;

            return detail::
                ends_with_iter_select( 
--- a/include/boost/algorithm/string/split.hpp
+++ b/include/boost/algorithm/string/split.hpp
@ -61,11 +61,7 @@ namespace boost {
        template< typename SequenceSequenceT, typename Range1T, typename Range2T >
        inline SequenceSequenceT& find_all(
            SequenceSequenceT& Result,
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-            Range1T&& Input,
-#else
            Range1T& Input,
-#endif
            const Range2T& Search)
        {
            return ::boost::algorithm::iter_find(
@ -100,11 +96,7 @@ namespace boost {
        template< typename SequenceSequenceT, typename Range1T, typename Range2T >
        inline SequenceSequenceT& ifind_all(
            SequenceSequenceT& Result,
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-            Range1T&& Input,
-#else
            Range1T& Input,
-#endif
            const Range2T& Search,
            const std::locale& Loc=std::locale() )
        {
@ -147,11 +139,7 @@ namespace boost {
        template< typename SequenceSequenceT, typename RangeT, typename PredicateT >
        inline SequenceSequenceT& split(
            SequenceSequenceT& Result,
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-            RangeT&& Input,
-#else
            RangeT& Input,
-#endif
            PredicateT Pred,
            token_compress_mode_type eCompress=token_compress_off )
        {
--- a/minmax/doc/minmax_synopsis.html
+++ b/minmax/doc/minmax_synopsis.html
@ -24,7 +24,7 @@ namespace boost {
  tuple&lt;T const&amp;, T const&amp;> >
  minmax(const T&amp; a, const T&amp; b);

-  template &lt;class T, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class T, class <a href="http://www.sgi.com/tech/stl/  BinaryPredicate.html">BinaryPredicate</a>>
  tuple&lt;T const&amp;, T const&amp;> >
  minmax(const T&amp; a, const T&amp; b, BinaryPredicate comp);

@ -38,77 +38,77 @@ Synopsis of <tt>&lt;boost/algorithm/minmax_element.hpp></tt></h3>

 namespace boost {

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  minmax_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  minmax_element(ForwardIterator first, ForwardIterator last,
                 BinaryPredicate comp);

  // Variants

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
  ForwardIterator first_min_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
  ForwardIterator first_min_element(ForwardIterator first, ForwardIterator last,
                                    BinaryPredicate comp);

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
  ForwardIterator last_min_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
  ForwardIterator last_min_element(ForwardIterator first, ForwardIterator last,
                                   BinaryPredicate comp);

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
  ForwardIterator first_max_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
  ForwardIterator first_max_element(ForwardIterator first, ForwardIterator last,
                                    BinaryPredicate comp);

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
  ForwardIterator last_max_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
  ForwardIterator last_max_element(ForwardIterator first, ForwardIterator last,
                                   BinaryPredicate comp);

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  first_min_first_max_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  first_min_first_max_element(ForwardIterator first, ForwardIterator last,
                             BinaryPredicate comp);

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  first_min_last_max_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  first_min_last_max_element(ForwardIterator first, ForwardIterator last,
                             BinaryPredicate comp);

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  last_min_first_max_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  last_min_first_max_element(ForwardIterator first, ForwardIterator last,
                             BinaryPredicate comp);

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  last_min_last_max_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  last_min_last_max_element(ForwardIterator first, ForwardIterator last,
                            BinaryPredicate comp);
--- a/minmax/index.html
+++ b/minmax/index.html
@ -95,7 +95,7 @@ namespace boost {
  tuple&lt;T const&amp;, T const&amp;>
  minmax(const T&amp; a, const T&amp; b);

-  template &lt;class T, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class T, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
  tuple&lt;T const&amp;, T const&amp;>
  minmax(const T&amp; a, const T&amp; b, BinaryPredicate comp);

@ -109,11 +109,11 @@ Synopsis of <tt>&lt;boost/algorithm/minmax_element.hpp></tt></h3>

 namespace boost {

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  minmax_element(ForwardIterator first, ForwardIterator last);

-  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
  std::pair&lt;ForwardIterator,ForwardIterator>
  minmax_element(ForwardIterator first, ForwardIterator last,
                 BinaryPredicate comp);
@ -190,26 +190,26 @@ in <a href="../../../boost/algorithm/minmax_element.hpp">minmax_element.hpp</a>.
 <a name="reqs">
 <h3>
 Requirements on types</h3>
-For minmax, <tt>T</tt> must be a model of <a href="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThan
+For minmax, <tt>T</tt> must be a model of <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThan
 Comparable</a>.
 <p>For all the other function templates, versions with two template parameters:
 <ul>
 <li>
-<tt>ForwardIterator</tt> is a model of <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">Forward
+<tt>ForwardIterator</tt> is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward
 Iterator</a>.</li>

 <li>
-<tt>ForwardIterator</tt>'s value type is <a href="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThan
+<tt>ForwardIterator</tt>'s value type is <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThan
 Comparable</a>.</li>
 </ul>
 For the versions with three template parameters:
 <ul>
 <li>
-<tt>ForwardIterator</tt> is a model of <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">Forward
+<tt>ForwardIterator</tt> is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward
 Iterator</a>.</li>

 <li>
-<tt>BinaryPredicate</tt> is a model of <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">Binary
+<tt>BinaryPredicate</tt> is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary
 Predicate</a>.</li>

 <li>
@ -285,8 +285,8 @@ the library under
  assert( result1.get<0>() == 0 );
  assert( result1.get<1>() == 1 );

-  <a href="https://www.boost.org/sgi/stl/List.html">list</a>&lt;int> L;
-  <a href="https://www.boost.org/sgi/stl/generate_n.html">generate_n</a>(<a href="https://www.boost.org/sgi/stl/front_insert_iterator.html">front_inserter</a>(L), 1000, rand);
+  <a href="http://www.sgi.com/tech/stl/List.html">list</a>&lt;int> L;
+  <a href="http://www.sgi.com/tech/stl/generate_n.html">generate_n</a>(<a href="http://www.sgi.com/tech/stl/front_insert_iterator.html">front_inserter</a>(L), 1000, rand);

  typedef list&lt;int>::const_iterator iterator;
  pair&lt; iterator, iterator > result2 = boost::minmax_element(L.begin(), L.end());
@ -512,13 +512,13 @@ release, Eric Niebler noted the bad behavior of <tt>std::pair</tt> for
 All my thanks for the excellent advice and reviews from all.
 <h3>
 See also</h3>
-<tt><a href="https://www.boost.org/sgi/stl/min.html">min</a></tt>, <tt><a href="https://www.boost.org/sgi/stl/max.html">max</a></tt>,
-<tt><a href="https://www.boost.org/sgi/stl/min_element.html">min_element</a></tt>,
-<tt><a href="https://www.boost.org/sgi/stl/max_element.html">max_element</a></tt>,
-<tt><a href="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThan
+<tt><a href="http://www.sgi.com/tech/stl/min.html">min</a></tt>, <tt><a href="http://www.sgi.com/tech/stl/max.html">max</a></tt>,
+<tt><a href="http://www.sgi.com/tech/stl/min_element.html">min_element</a></tt>,
+<tt><a href="http://www.sgi.com/tech/stl/max_element.html">max_element</a></tt>,
+<tt><a href="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThan
 Comparable</a></tt>,
-<tt><a href="https://www.boost.org/sgi/stl/sort.html">sort</a></tt>,
-<tt><a href="https://www.boost.org/sgi/stl/nth_element.html">nth_element</a></tt>
+<tt><a href="http://www.sgi.com/tech/stl/sort.html">sort</a></tt>,
+<tt><a href="http://www.sgi.com/tech/stl/nth_element.html">nth_element</a></tt>
 .
 <hr SIZE="6">
 <br>Last modified 2012-12-10
--- a/string/doc/external_concepts.html
+++ b/string/doc/external_concepts.html
@ -31,7 +31,7 @@
               typedef <i>implementation defined </i> foo_type;</code><p  >The corresponding external concept is the ExternalFooConcept.</p><p  >A type <code>T</code> fullfills the ExternalFooConcept if these
            free-standing functions and type-generators exists:</p><code>void foo( const T&, int ); <br>
                int bar( T& ); <br>
-             foo_type_of< T >::type;</code> <br> <br><hr size="1" ><h3  >Literature</h3><ul  ><li  > <a href="http://www.boost.org/more/generic_programming.html#type_generator" target="_self" >Type Generators</a> </li><li  > <a href="http://www.boost.org/more/generic_programming.html#concept" target="_self" >Concepts</a> </li><li  > <a href="https://www.boost.org/sgi/stl/stl_introduction.html" target="_self" >Concepts and SGI STL</a> </li></ul><hr size="1" ><p  >&copy; Thorsten Ottosen 2003-2004 (nesotto_AT_cs.auc.dk).
+             foo_type_of< T >::type;</code> <br> <br><hr size="1" ><h3  >Literature</h3><ul  ><li  > <a href="http://www.boost.org/more/generic_programming.html#type_generator" target="_self" >Type Generators</a> </li><li  > <a href="http://www.boost.org/more/generic_programming.html#concept" target="_self" >Concepts</a> </li><li  > <a href="http://www.sgi.com/tech/stl/stl_introduction.html" target="_self" >Concepts and SGI STL</a> </li></ul><hr size="1" ><p  >&copy; Thorsten Ottosen 2003-2004 (nesotto_AT_cs.auc.dk).
 <br>Use, modification and distribution is subject to the Boost
 Software License, Version 1.0. (See accompanying file
 <code class="filename">LICENSE_1_0.txt</code> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
--- a/string/example/predicate_example.cpp
+++ b/string/example/predicate_example.cpp
@ -12,6 +12,8 @@
 #include <functional>
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/algorithm/string/classification.hpp>
+#include <boost/bind.hpp>
+

 using namespace std;
 using namespace boost;
--- a/string/example/rle_example.cpp
+++ b/string/example/rle_example.cpp
@ -16,7 +16,7 @@
 #include <string>
 #include <iostream>
 #include <limits>
-#include <iterator>
+#include <boost/detail/iterator.hpp>
 #include <boost/algorithm/string/find_format.hpp>
 #include <boost/algorithm/string/finder.hpp>

@ -46,7 +46,7 @@ struct find_compressF
        ForwardIteratorT End ) const
    {
        typedef ForwardIteratorT input_iterator_type;
-        typedef typename std::iterator_traits<input_iterator_type>::value_type value_type;
+        typedef typename boost::detail::iterator_traits<input_iterator_type>::value_type value_type;
        typedef iterator_range<input_iterator_type> result_type;

        // begin of the matching segment
@ -144,7 +144,7 @@ struct find_decompressF
        ForwardIteratorT End ) const
    {
        typedef ForwardIteratorT input_iterator_type;
-        typedef typename std::iterator_traits<input_iterator_type>::value_type value_type;
+        typedef typename boost::detail::iterator_traits<input_iterator_type>::value_type value_type;
        typedef iterator_range<input_iterator_type> result_type;

        for(input_iterator_type It=Begin; It!=End; It++)
@ -153,12 +153,12 @@ struct find_decompressF
            {
                // Repeat mark found, extract body
                input_iterator_type It2=It++; 
-
+                
                if ( It==End ) break;
                    It++; 
                if ( It==End ) break;
                    It++;
-
+                
                return result_type( It2, It );
            }
        }
--- a/string/test/split_test.cpp
+++ b/string/test/split_test.cpp
@ -7,8 +7,6 @@

 //  See http://www.boost.org for updates, documentation, and revision history.

-#include <boost/algorithm/string/config.hpp>
-
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/classification.hpp>
 // equals predicate is used for result comparison
@ -84,28 +82,6 @@ void iterator_test()
        string("xx") );
    deep_compare( tokens, vtokens );

-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    // If using a compiler that supports forwarding references, we should be able to use rvalues, too
-    find_all(
-        tokens,
-        string("xx-abc--xx-abb"),
-        "xx" );
-
-    BOOST_REQUIRE( tokens.size()==2 );
-    BOOST_CHECK( tokens[0]==string("xx") );
-    BOOST_CHECK( tokens[1]==string("xx") );
-
-    ifind_all(
-        tokens,
-        string("Xx-abc--xX-abb-xx"),
-        "xx" );
-
-    BOOST_REQUIRE( tokens.size()==3 );
-    BOOST_CHECK( tokens[0]==string("Xx") );
-    BOOST_CHECK( tokens[1]==string("xX") );
-    BOOST_CHECK( tokens[2]==string("xx") );
-#endif
-
    // split tests
    split(
        tokens,
@ -168,21 +144,6 @@ void iterator_test()
    BOOST_REQUIRE( tokens.size()==1 );
    BOOST_CHECK( tokens[0]==string("") );

-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    // If using a compiler that supports forwarding references, we should be able to use rvalues, too
-    split(
-        tokens,
-        string("Xx-abc--xX-abb-xx"),
-        is_any_of("xX"),
-        token_compress_on );
-
-    BOOST_REQUIRE( tokens.size()==4 );
-    BOOST_CHECK( tokens[0]==string("") );
-    BOOST_CHECK( tokens[1]==string("-abc--") );
-    BOOST_CHECK( tokens[2]==string("-abb-") );
-    BOOST_CHECK( tokens[3]==string("") );
-#endif
-

    find_iterator<string::iterator> fiter=make_find_iterator(str1, first_finder("xx"));
    find_iterator<string::iterator> fiter2;
--- a/test/apply_permutation_test.cpp
+++ b/test/apply_permutation_test.cpp
@ -14,19 +14,19 @@

 #define BOOST_TEST_MAIN

-#include <boost/test/included/unit_test.hpp>
+#include <boost/test/unit_test.hpp>

 namespace ba = boost::algorithm;


-BOOST_AUTO_TEST_CASE(test_apply_permutation)
+void test_apply_permutation()
 {
    //Empty
    {
        std::vector<int> vec, order, result;
        
        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+        BOOST_CHECK(vec == result);
    }
    //1 element
    {
@ -36,7 +36,7 @@ BOOST_AUTO_TEST_CASE(test_apply_permutation)
        result = vec;
        
        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+        BOOST_CHECK(vec == result);
    }
    //2 elements, no changes
    {
@ -46,7 +46,7 @@ BOOST_AUTO_TEST_CASE(test_apply_permutation)
        result = vec;
        
        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+        BOOST_CHECK(vec == result);
    }
    //2 elements, changed
    {
@ -56,7 +56,7 @@ BOOST_AUTO_TEST_CASE(test_apply_permutation)
        result.push_back(2); result.push_back(1);
        
        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+        BOOST_CHECK(vec == result);
    }
    //Multiple elements, no changes
    {
@ -66,7 +66,7 @@ BOOST_AUTO_TEST_CASE(test_apply_permutation)
        result = vec;
        
        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+        BOOST_CHECK(vec == result);
    }
    //Multiple elements, changed
    {
@ -76,7 +76,7 @@ BOOST_AUTO_TEST_CASE(test_apply_permutation)
        result.push_back(5); result.push_back(4); result.push_back(3); result.push_back(2); result.push_back(1);
        
        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+        BOOST_CHECK(vec == result);
    }
    //Just test range interface
    {
@ -86,18 +86,18 @@ BOOST_AUTO_TEST_CASE(test_apply_permutation)
        result = vec;
        
        ba::apply_permutation(vec, order);
-        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+        BOOST_CHECK(vec == result);
    }
 }

-BOOST_AUTO_TEST_CASE(test_apply_reverse_permutation)
+void test_apply_reverse_permutation()
 {
    //Empty
    {
        std::vector<int> vec, order, result;
        
        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+        BOOST_CHECK(vec == result);
    }
    //1 element
    {
@ -107,7 +107,7 @@ BOOST_AUTO_TEST_CASE(test_apply_reverse_permutation)
        result = vec;
        
        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+        BOOST_CHECK(vec == result);
    }
    //2 elements, no changes
    {
@ -117,7 +117,7 @@ BOOST_AUTO_TEST_CASE(test_apply_reverse_permutation)
        result = vec;
        
        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+        BOOST_CHECK(vec == result);
    }
    //2 elements, changed
    {
@ -127,7 +127,7 @@ BOOST_AUTO_TEST_CASE(test_apply_reverse_permutation)
        result.push_back(2); result.push_back(1);
        
        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+        BOOST_CHECK(vec == result);
    }
    //Multiple elements, no changes
    {
@ -137,7 +137,7 @@ BOOST_AUTO_TEST_CASE(test_apply_reverse_permutation)
        result = vec;
        
        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+        BOOST_CHECK(vec == result);
    }
    //Multiple elements, changed
    {
@ -147,7 +147,7 @@ BOOST_AUTO_TEST_CASE(test_apply_reverse_permutation)
        result.push_back(5); result.push_back(4); result.push_back(3); result.push_back(2); result.push_back(1);
        
        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+        BOOST_CHECK(vec == result);
    }
    //Just test range interface
    {
@ -157,6 +157,12 @@ BOOST_AUTO_TEST_CASE(test_apply_reverse_permutation)
        result = vec;
        
        ba::apply_reverse_permutation(vec, order);
-        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+        BOOST_CHECK(vec == result);
    }
 }
+
+BOOST_AUTO_TEST_CASE(test_main)
+{
+    test_apply_permutation();
+    test_apply_reverse_permutation();
+}
Author	SHA1	Message	Date
Marshall Clow	5af3e3b174	Merge bug fixes to master	2018-12-04 09:35:03 -08:00
Marshall Clow	badf1b3f0c	Merge broken links to master. NFC	2018-07-31 22:57:40 -07:00
Marshall Clow	4f9afb0682	Merge for the 1.68.0 beta	2018-07-04 11:27:27 -07:00
Marshall Clow	6d0126df8a	Catch up with the changes; apply_permutation; constexpr, etc	2018-05-01 08:17:06 -07:00
Marshall Clow	daef6d41c5	C++17 algorithms	2017-06-28 20:13:38 -07:00
Marshall Clow	055075aa61	Bug fixes and is_partititioned_XXX for the 1.65.0 release	2017-06-14 18:49:39 -07:00
Rene Rivera	d029402f05	Add, and update, documentation build targets.	2016-10-10 11:24:26 -05:00
Marshall Clow	24d2cceb27	Fix a couple of test failures for the 1.62.0 release	2016-08-17 18:11:47 -07:00
Marshall Clow	c5b41eba46	Merge to master for 1.62.0 release	2016-08-17 13:32:45 -07:00
Marshall Clow	e5ea93bab1	Revert "Merge pull request #14 from nigels-com/merge-hex_lower" This reverts commit `5412438df5`, reversing changes made to `a09963bf93`.	2016-03-07 15:43:55 -08:00
Marshall Clow	5412438df5	Merge pull request #14 from nigels-com/merge-hex_lower Implement algorithm::hex_lower (Trac ticket #7064)	2016-03-07 14:57:34 -08:00
Nigel Stewart	baa6eca18c	Test coverage for algorithm::hex_lower, adapting existing coverage for algorithm::hex	2016-01-31 20:18:22 +10:00
Nigel Stewart	073eb62f64	Another overload of algorithm::hex_lower as lower-case alternative to algorithm::hex	2016-01-31 20:17:23 +10:00
Nigel Stewart	cc1392cae6	Implement algorithm::hex_lower as lower-case alternative to algorithm::hex	2016-01-31 19:11:11 +10:00
Marshall Clow	a09963bf93	Merge from develop; new feature 'power'; doc fixes; remove usage of C++11 versions of the algorithms	2015-03-18 21:31:53 -07:00
Marshall Clow	cf249c090c	Merge from develop: clean up is_permutation; fix clamp interface, and merge fix for bug #9335 as well	2014-03-31 12:03:45 -07:00
Marshall Clow	645be22fa7	Setting merge point for git merges	2014-03-23 14:33:14 -07:00
Stephen Kelly	28b12d7264	Algorithm: Remove obsolete MSVC version checks. [SVN r86024]	2014-03-23 14:30:10 -07:00
Stephen Kelly	4d28d579e3	Remove BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION Process #ifdef...#endif blocks. [SVN r86243]	2014-03-23 14:27:55 -07:00
Stephen Kelly	5adab54486	Remove BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION Process #ifdef...#else...#endif blocks. [SVN r86246]	2014-03-23 14:27:55 -07:00
Marshall Clow	685a76f094	Merge a bunch of minor Boost.Algorithm changes to release [SVN r86757]	2013-11-18 16:52:09 +00:00
Marshall Clow	5988a55b96	Minor merging; removing tabs from source files [SVN r86323]	2013-10-15 15:44:55 +00:00
Marshall Clow	850fc02667	Merge bug fix for #9063 to release [SVN r86218]	2013-10-09 18:09:40 +00:00
Marshall Clow	5279c8f061	Merge minor Boost.Algorithm doc fixes to the release branch [SVN r86200]	2013-10-08 15:31:14 +00:00
Andrey Semashev	8b89b5ba27	Merged changes from trunk. [SVN r85804]	2013-09-20 17:40:42 +00:00
Marshall Clow	ca23b6f4f8	Merge bug fix to Release; Fixes #8546 [SVN r85134]	2013-07-23 16:48:27 +00:00
Marshall Clow	55cb3afefa	Merge test fixup to release [SVN r84825]	2013-06-18 14:48:37 +00:00
Marshall Clow	beeedadba9	Merge doc changes from trunk [SVN r84743]	2013-06-11 16:21:22 +00:00
Marshall Clow	1a70166889	Merge c++14 changes to release [SVN r84415]	2013-05-22 15:10:49 +00:00
Marshall Clow	63da6f5713	Merge Algorithm changes to release; hex code cleanups; gather iterator requirements; copy_while and copy_until interface changes [SVN r83347]	2013-03-07 15:37:08 +00:00
Marshall Clow	2381d0bdac	Merge bug fix to release; Fixes #7989 [SVN r83193]	2013-02-27 23:37:21 +00:00
Marshall Clow	40b5941652	One more failed merge [SVN r83192]	2013-02-27 23:36:16 +00:00
Marshall Clow	00dfda98b2	more merge failures [SVN r83171]	2013-02-26 22:05:42 +00:00
Marshall Clow	52eef989da	Clean up merge failure [SVN r83170]	2013-02-26 22:03:44 +00:00
Marshall Clow	8132864884	Merged boost::algorithm::gather and updated tests for Utility, Algorithm and Utility libraries [SVN r83154]	2013-02-25 18:43:26 +00:00
Marshall Clow	6e098b27aa	Merge Michael Morin's typo fixes for Boost.Algorithm to release; no functionality change. [SVN r82240]	2012-12-28 18:19:25 +00:00
Marshall Clow	60010b4165	Merge bug fix and test to release; Fixes #7784 [SVN r82238]	2012-12-28 17:39:08 +00:00
Marshall Clow	1660dc9d48	merge bug fix for minmax_element to release; Fixes #7752 [SVN r82049]	2012-12-17 16:02:38 +00:00
Marshall Clow	5ae4f848b3	Remove tabs from Boost.Algorithm tests. [SVN r81857]	2012-12-11 16:56:30 +00:00
Marshall Clow	fe3e0bb9c4	merge K-M-P doc updates to release; Fixes #7656 [SVN r81840]	2012-12-10 21:13:08 +00:00
Marshall Clow	311e169376	Merge extra tests for Boost.StringAlgo.Split to release [SVN r81835]	2012-12-10 20:10:12 +00:00
Marshall Clow	3dddfa1930	Merge from trunk; Fixes #7346 [SVN r81832]	2012-12-10 19:23:54 +00:00
Marshall Clow	be6d8f9665	Merge URL fix for boyer-moore; Fixes #7781 [SVN r81825]	2012-12-10 15:40:23 +00:00
Marshall Clow	bced4ed8dd	Merge doc fix for minmax; Fixes #7751 [SVN r81823]	2012-12-10 15:28:36 +00:00
Marshall Clow	1b57e905ab	Merge bug fixes to release; Fixes #7339 [SVN r80808]	2012-10-01 15:31:51 +00:00
Marshall Clow	29bd9f53d9	Merge bug fixes to release; Fixes #7399 Fixes #7400 Fixes #7401 [SVN r80670]	2012-09-23 14:56:41 +00:00
Marshall Clow	6341cfb1a6	Merge doc typo corrections to release; fixes #6595 ; fixes #7182 [SVN r80057]	2012-08-16 05:16:42 +00:00
Marshall Clow	7f4acd6170	Merged typos in comments to release; no functionality; Fixes #7210 [SVN r79929]	2012-08-08 16:30:33 +00:00
Marshall Clow	314f6dcfe0	Merge changes from [79588] to Release; fixes a unhex bug [SVN r79604]	2012-07-19 15:12:33 +00:00
Marshall Clow	167aa6e31c	Get rid of tabs in Boost.Algorithm tests [SVN r79603]	2012-07-19 15:00:27 +00:00
Marshall Clow	d228e91494	Merge Boost.Algorithm changes to release; Fixes #7104 [SVN r79538]	2012-07-15 16:28:35 +00:00
Marshall Clow	9cc573fbd0	Fixed errors in the doxygen comments. Fixes #7083 . [SVN r79285]	2012-07-05 15:30:17 +00:00
Marshall Clow	28a7d3eb4b	Merge doc changes to release; fixes #7073 [SVN r79264]	2012-07-04 16:15:35 +00:00
Daniel James	883cce61a8	Merge algorithm's html redirect. [SVN r78855]	2012-06-07 20:05:17 +00:00
Marshall Clow	96d4708367	Merge Boost.Algorithm inspection report changes to release. No functionality change [SVN r78689]	2012-05-27 15:45:18 +00:00
Marshall Clow	563fe27a59	Merged changes for Boost.Algorithm to release; Fixes #6596 ; Fixes #6689 ; Fixes #3215 ; Fixes #6840 [SVN r78557]	2012-05-23 16:25:48 +00:00
Marshall Clow	76cd99ed53	Merge Boost.Algorithm to release branch [SVN r78025]	2012-04-16 18:54:41 +00:00
Marshall Clow	0f2399fef0	Merge changes to release; fixes #5589 [SVN r76527]	2012-01-15 16:49:25 +00:00
Marshall Clow	044d667e79	Merge changes to release; fixes #3634 [SVN r76522]	2012-01-15 16:05:55 +00:00
Marshall Clow	be9da63894	Merge fix for #4937 to release [SVN r76267]	2012-01-01 21:18:47 +00:00
Marshall Clow	787c94bc53	Merge Change 68161 to release [SVN r76266]	2012-01-01 21:17:02 +00:00
Marshall Clow	e87ce37b34	Merge Change 76213 to release; Fixes #4811 [SVN r76265]	2012-01-01 21:12:58 +00:00
Pavol Droba	199a89a1e9	merged from trunk [SVN r72380]	2011-06-03 21:13:37 +00:00
Pavol Droba	01492a93c6	trunk changes merged [SVN r67922]	2011-01-10 19:36:38 +00:00
Daniel James	50703b8c97	Merge documentation fixes to release. [SVN r66285]	2010-10-30 17:34:45 +00:00
Jürgen Hunold	0f8d556130	Merge r65004 from trunk Fix #4551,#4553,#4575 by removing unused parameter. [SVN r65168]	2010-09-01 16:18:07 +00:00
Pavol Droba	bbd3220a1e	Merging changes from trunk [SVN r63824]	2010-07-10 20:29:03 +00:00
Hartmut Kaiser	9068069106	Spirit: merging from trunk upto rev. 61489 [SVN r63640]	2010-07-04 22:38:38 +00:00
Daniel James	a37af3c81e	Merge documentation fixes. * Use `doc/src/.css` instead of `doc/html/.css`. * Remove wiki and people directories. * Some documentation fixes. * Left out `minimal.css` changes and boostbook changes because of clashes. [SVN r63347]	2010-06-26 12:30:09 +00:00
Steven Watanabe	f5885c6fb0	Merge minmax from the trunk [SVN r62088]	2010-05-18 17:53:36 +00:00
Daniel James	d45bb3545e	Merge some link fixes and release notes. [SVN r61474]	2010-04-21 23:00:35 +00:00
Troy D. Straszheim	d735b9fa1e	rm cmake from the release branch before it goes out broken. Policy dictates that you never commit to release, you commit to trunk and merge to release. [SVN r56941]	2009-10-17 01:10:45 +00:00
Pavol Droba	62ec675581	Merged changes from trunk [SVN r56176]	2009-09-13 19:10:55 +00:00
Troy D. Straszheim	e7cd4da67b	Add basic copyright/license to keep cmake out of the inspection report [SVN r55095]	2009-07-22 21:51:01 +00:00
Steven Watanabe	6076f5a18e	Merge [53520] from the trunk [SVN r53909]	2009-06-14 22:56:08 +00:00
Steven Watanabe	60cd5a0500	Merge [53062] from the trunk [SVN r53270]	2009-05-26 01:17:07 +00:00
Jeremiah Willcock	c33dad924d	Fixed almost all tab and min/max issues found by inspect tool [SVN r53142]	2009-05-20 19:41:20 +00:00
Daniel James	2f2935f07e	Merged revisions 45283,48266 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r45283 \| danieljames \| 2008-05-11 14:49:20 +0100 (Sun, 11 May 2008) \| 1 line Quote href values - our tools don't support unquoted values. ........ r48266 \| danieljames \| 2008-08-20 20:32:23 +0100 (Wed, 20 Aug 2008) \| 1 line Fix the link to the limits documentation. ........ [SVN r51902]	2009-03-22 17:30:02 +00:00
John Maddock	3cbaafc27f	Merge PDF build changes from Trunk. [SVN r51417]	2009-02-23 18:39:32 +00:00
Steven Watanabe	c067b348bf	Merge [51045] from the trunk [SVN r51226]	2009-02-12 18:47:06 +00:00
Troy D. Straszheim	c33935fa1f	merge of cmake build files from trunk per beman [SVN r50756]	2009-01-24 18:57:20 +00:00
Pavol Droba	98a8b08afb	Memory management fixes for is_any_of predicate merged from the trunk [SVN r49172]	2008-10-07 21:59:57 +00:00
Pavol Droba	fc0f3dcffc	Cummulative merge of updates from the main trunk [SVN r46505]	2008-06-19 12:07:24 +00:00
Daniel James	822636418b	Merged revisions 43211,43214-43219,43222-43225,43227-43238,43242,43244-43245,43249-43250,43257-43259,43261,43263,43265,43267-43268,43270-43271,43273,43275-43279,43284-43289,43291,43295,43297-43298,43304-43305,43307,43313,43315,43324,43326-43327,43331,43333,43339-43343,43345,43348,43350,43352-43353,43355-43356,43358,43360,43366-43367,43369-43370,43372-43376,43378-43389,43394,43396-43398,43400-43401,43403-43404,43406-43408,43413-43415,43417-43418,43420,43422-43423 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r43417 \| danieljames \| 2008-02-26 22:04:55 +0000 (Tue, 26 Feb 2008) \| 2 lines Fix a link to Boost.Bimap. ........ r43418 \| danieljames \| 2008-02-26 22:07:25 +0000 (Tue, 26 Feb 2008) \| 2 lines Change another link that's no longer in the repository to link to the website. ........ r43422 \| danieljames \| 2008-02-27 18:51:14 +0000 (Wed, 27 Feb 2008) \| 1 line Fix broken copyright urls. Fixes #1573. ........ r43423 \| danieljames \| 2008-02-27 19:22:01 +0000 (Wed, 27 Feb 2008) \| 1 line Fix incorrect links to copyright of the form 'http:#www.boost.org ........ [SVN r43425]	2008-02-27 20:00:24 +00:00
Daniel James	352e16aade	Merged revisions 43206,43208-43213 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r43206 \| danieljames \| 2008-02-10 09:55:03 +0000 (Sun, 10 Feb 2008) \| 1 line Fix some broken links. ........ r43209 \| danieljames \| 2008-02-10 14:56:22 +0000 (Sun, 10 Feb 2008) \| 1 line Link to people pages on the website, as they've been removed from the download. ........ r43210 \| danieljames \| 2008-02-10 15:02:17 +0000 (Sun, 10 Feb 2008) \| 1 line Point links to the pages that used to be in 'more' to the site. ........ r43212 \| danieljames \| 2008-02-10 16:10:16 +0000 (Sun, 10 Feb 2008) \| 1 line Fix links on the home page as well. ........ r43213 \| danieljames \| 2008-02-10 16:21:22 +0000 (Sun, 10 Feb 2008) \| 1 line Generated documentation which is no longer generated. ........ [SVN r43214]	2008-02-10 16:39:38 +00:00
Beman Dawes	89c76ea1bb	Full merge from trunk at revision 41356 of entire boost-root tree. [SVN r41370]	2007-11-25 18:38:02 +00:00
Beman Dawes	50b5726a6f	Full merge from trunk at revision 41356 of entire boost-root tree. [SVN r41369]	2007-11-25 18:07:19 +00:00
Beman Dawes	d4b95734dd	Starting point for releases [SVN r39706]	2007-10-05 14:25:06 +00:00
nobody	05af96f84c	This commit was manufactured by cvs2svn to create tag 'Version_1_34_1'. [SVN r38286]	2007-07-24 19:28:14 +00:00
Pavol Droba	5bdbb2b308	Documentation for iter_find/iter_split added [SVN r37842]	2007-06-01 13:50:51 +00:00
Pavol Droba	1a02969303	release notes - fix the incorrect functionname spelling [SVN r37533]	2007-04-29 07:04:58 +00:00
Pavol Droba	6309379618	release notes for 1.34 added [SVN r37532]	2007-04-29 07:02:21 +00:00
Pavol Droba	37581bac55	documentation typo fixed [SVN r36843]	2007-01-30 07:59:28 +00:00
Beman Dawes	a71a4ed5b1	Merged copyright and license addition [SVN r35907]	2006-11-07 19:27:00 +00:00
Rene Rivera	c509c3fbad	Remove obsolete Boost.Build v1 files. [SVN r35880]	2006-11-06 17:10:46 +00:00
Pavol Droba	d8683f2498	unused parameters removed [SVN r35753]	2006-10-27 17:37:37 +00:00
Pavol Droba	7c0101aa51	Copyright added to index.html unneeded file removed [SVN r34908]	2006-08-20 20:14:48 +00:00
Pavol Droba	6f3e85528f	License added to the xml documentation files [SVN r34894]	2006-08-16 07:10:48 +00:00
Pavol Droba	8af639b7cf	missing 'using' directives for join_if and join_if_regex added missing #include <boost/algorithm/string/join.hpp> added to string_algo.hpp [SVN r34122]	2006-05-30 19:13:08 +00:00
Pavol Droba	d9bc7e800b	Merged patch from main trunk for borland by Nicola Musatti [SVN r33723]	2006-04-17 17:16:11 +00:00
nobody	b4ed9beb90	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r33417]	2006-03-21 02:26:31 +00:00