Revert "Merge pull request #14 from nigels-com/merge-hex_lower"

This reverts commit 5412438df5, reversing
changes made to a09963bf93.

.travis.yml

@@ -1,193 +0,0 @@
-# Copyright 2016 - 2018 Peter Dimov
-# Copyright 2018 T. Zachary Laine
-# Copyright 2017 - 2019 James E. King III
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-#
-# Generic Travis CI build script for boostorg repositories
-# See: https://github.com/boostorg/boost-ci
-#
-# Instructions for customizing this script for your library:
-#
-# 1. Customize the compilers and language levels you want in the 'jobs'.
-# 2. If you have more than include/, src/, test/, example/, examples/, or
-#    tools/ directories, modify your Travis CI project and add the environment
-#    variable DEPINST.  For example if your build uses code in "bench/" and
-#    "fog/" directories, then set DEPINST to the following:
-#        --include bench --include fog
-# 3. If you want to enable Coverity Scan, you need to provide the environment
-#    variables COVERITY_SCAN_TOKEN and COVERITY_SCAN_NOTIFICATION_EMAIL in
-#    your github settings.
-# 4. Enable pull request builds in your boostorg/<library> account.
-#
-# That's it - the scripts will do everything else for you.
-
-dist: xenial
-language: cpp
-
-env:
-  global:
-  # see: http://www.boost.org/build/doc/html/bbv2/overview/invocation.html#bbv2.overview.invocation.properties
-  # to use the default for a given environment, comment it out; recommend you build debug and release however..
-  # - B2_ADDRESS_MODEL=address-model=64,32
-  # - B2_LINK=link=shared,static
-  # - B2_THREADING=threading=multi,single
-    - B2_VARIANT=variant=release,debug
-
-install:
-  - git clone https://github.com/boostorg/boost-ci.git boost-ci
-  - cp -pr boost-ci/ci boost-ci/.codecov.yml .
-  - source ci/travis/install.sh
-
-addons:
-  apt:
-    packages:
-      - binutils-gold
-      - gdb
-      - libc6-dbg
-
-branches:
-  only:
-    - master
-    - develop
-    - bugfix/*
-    - feature/*
-    - fix/*
-    - pr/*
-
-script:
-  - cd $BOOST_ROOT/libs/$SELF
-  - ci/travis/build.sh
-
-#
-# Default toolsets in Ubuntu
-#
-#       trusty xenial bionic
-#        14.04  16.04  18.04
-#       ------ ------ ------
-# clang    3.4    3.8    6.0
-#   gcc  4.8.2  5.3.1  7.3.0
-#
-
-anchors:
-  clang-38: &clang-38 { apt: { packages: [ "clang-3.8",
-                                           "libstdc++-6-dev" ], sources: [ "llvm-toolchain-xenial-3.8",
-                                                                           "ubuntu-toolchain-r-test"   ] } }
-  clang-4:  &clang-4  { apt: { packages: [ "clang-4.0",
-                                           "libstdc++-6-dev" ], sources: [ "llvm-toolchain-xenial-4.0",
-                                                                           "ubuntu-toolchain-r-test"   ] } }
-  clang-5:  &clang-5  { apt: { packages: [ "clang-5.0",
-                                           "libstdc++-7-dev" ], sources: [ "llvm-toolchain-xenial-5.0",
-                                                                           "ubuntu-toolchain-r-test"   ] } }
-  clang-6:  &clang-6  { apt: { packages: [ "clang-6.0",
-                                           "libc6-dbg",
-                                           "libc++-dev",
-                                           "libstdc++-8-dev" ], sources: [ "llvm-toolchain-xenial-6.0",
-                                                                           "ubuntu-toolchain-r-test"   ] } }
-  clang-7:  &clang-7  { apt: { packages: [ "clang-7",
-                                           "libc6-dbg",
-                                           "libc++-dev",
-                                           "libstdc++-8-dev" ], sources: [ "llvm-toolchain-xenial-7",
-                                                                           "ubuntu-toolchain-r-test"   ] } }
-  clang-8:  &clang-8  { apt: { packages: [ "clang-8",
-                                           "libc6-dbg",
-                                           "libc++-dev",
-                                           "libstdc++-8-dev" ], sources: [ "llvm-toolchain-xenial-8",
-                                                                           "ubuntu-toolchain-r-test"   ] } }
-  gcc-48:   &gcc-48   { apt: { packages: [ "g++-4.8"         ]                                           } }
-  gcc-49:   &gcc-49   { apt: { packages: [ "g++-4.9"         ]                                           } }
-  gcc-5:    &gcc-5    { apt: { packages: [ "g++-5"           ]                                           } }
-  gcc-6:    &gcc-6    { apt: { packages: [ "g++-6"           ], sources: [ "ubuntu-toolchain-r-test"   ] } }
-  gcc-7:    &gcc-7    { apt: { packages: [ "g++-7"           ], sources: [ "ubuntu-toolchain-r-test"   ] } }
-  gcc-8:    &gcc-8    { apt: { packages: [ "g++-8"           ], sources: [ "ubuntu-toolchain-r-test"   ] } }
-
-jobs:
-  allow_failures:
-    - env:
-      - COPY="all the environment settings from your job"
-
-  include:
-    # libstdc++
-    - { os: "linux", env: [ "B2_TOOLSET=gcc-4.8",     "B2_CXXSTD=03,11"    ], addons: *gcc-48    }
-    - { os: "linux", env: [ "B2_TOOLSET=gcc-4.9",     "B2_CXXSTD=03,11"    ], addons: *gcc-49    }
-    - { os: "linux", env: [ "B2_TOOLSET=gcc-5",       "B2_CXXSTD=11"       ], addons: *gcc-5     }
-    - { os: "linux", env: [ "B2_TOOLSET=gcc-6",       "B2_CXXSTD=11,14"    ], addons: *gcc-6     }
-    - { os: "linux", env: [ "B2_TOOLSET=gcc-7",       "B2_CXXSTD=11,14,17" ], addons: *gcc-7     }
-    - { os: "linux", env: [ "B2_TOOLSET=gcc-8",       "B2_CXXSTD=14,17,2a" ], addons: *gcc-8     }
-    - { os: "linux", env: [ "B2_TOOLSET=clang-3.8",   "B2_CXXSTD=03,11,14" ], addons: *clang-38  }
-    - { os: "linux", env: [ "B2_TOOLSET=clang-4.0",   "B2_CXXSTD=11,14"    ], addons: *clang-4   }
-    - { os: "linux", env: [ "B2_TOOLSET=clang-5.0",   "B2_CXXSTD=11,14,17" ], addons: *clang-5   }
-    - { os: "linux", env: [ "B2_TOOLSET=clang-6.0",   "B2_CXXSTD=14,17,2a" ], addons: *clang-6   }
-    - { os: "linux", env: [ "B2_TOOLSET=clang-7",     "B2_CXXSTD=14,17,2a" ], addons: *clang-7   }
-    - { os: "linux", env: [ "B2_TOOLSET=clang-8",     "B2_CXXSTD=14,17,2a" ], addons: *clang-8   }
-
-    # libc++
-    - { os: "linux", env: [ "B2_TOOLSET=clang-6.0",   "B2_CXXSTD=03,11,14,17,2a",
-                            "B2_CXXFLAGS=-stdlib=libc++"                   ], addons: *clang-6   }
-    - { os: "osx"  , env: [ "B2_TOOLSET=clang",       "B2_CXXSTD=03,11,17" ]                     }
-
-    # to enable Intel ICC define INTEL_ICC_SERIAL_NUMBER and the following:
-    # - { os: "linux", env: [ "B2_TOOLSET=intel-linux", "B2_CXXSTD=11,14,17" ], addons: *gcc-7,
-    #     script: cd $BOOST_ROOT/libs/$SELF && ci/travis/intelicc.sh                               }
-
-    - os: linux
-      env:
-        - COMMENT=codecov.io
-        - B2_TOOLSET=03,11,14
-        - B2_TOOLSET=gcc-8
-        - B2_DEFINES="define=BOOST_NO_STRESS_TEST=1"
-      addons: *gcc-8
-      script:
-        - pushd /tmp && git clone https://github.com/linux-test-project/lcov.git && export PATH=/tmp/lcov/bin:$PATH && which lcov && lcov --version && popd
-        - cd $BOOST_ROOT/libs/$SELF
-        - ci/travis/codecov.sh
-
-    - os: linux
-      env:
-        - COMMENT=cppcheck
-      script:
-        - cd $BOOST_ROOT/libs/$SELF
-        - ci/travis/cppcheck.sh
-
-    - os: linux
-      env:
-        - COMMENT=ubsan
-        - B2_VARIANT=variant=debug
-        - B2_TOOLSET=gcc-8
-        - B2_CXXSTD=03,11,14,17,2a
-        - B2_DEFINES="define=BOOST_NO_STRESS_TEST=1"
-        - B2_CXXFLAGS="cxxflags=-fno-omit-frame-pointer cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=all"
-        - B2_LINKFLAGS="linkflags=-fsanitize=undefined linkflags=-fno-sanitize-recover=all linkflags=-fuse-ld=gold"
-        - UBSAN_OPTIONS=print_stacktrace=1
-      addons: *gcc-8
-
-    - os: linux
-      env:
-        - COMMENT=valgrind
-        - B2_TOOLSET=clang-6.0
-        - B2_CXXSTD=03,11,14,17,2a
-        - B2_DEFINES="define=BOOST_NO_STRESS_TEST=1"
-        - B2_VARIANT=variant=debug
-        - B2_TESTFLAGS=testing.launcher=valgrind
-        - VALGRIND_OPTS=--error-exitcode=1
-      addons: *clang-6
-      script:
-        - cd $BOOST_ROOT/libs/$SELF
-        - ci/travis/valgrind.sh
-
-    #################### Jobs to run on pushes to master, develop ###################
-
-    # Coverity Scan
-    - os: linux
-      if: (env(COVERITY_SCAN_NOTIFICATION_EMAIL) IS present) AND (branch IN (develop, master)) AND (type IN (cron, push))
-      env:
-        - COMMENT="Coverity Scan"
-        - B2_TOOLSET=clang
-      script:
-        - cd $BOOST_ROOT/libs/$SELF
-        - ci/travis/coverity.sh
-
-notifications:
-  email:
-    false

CMakeLists.txt

@@ -1,41 +0,0 @@
-# Generated by `boostdep --cmake algorithm`
-# Copyright 2020 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# https://www.boost.org/LICENSE_1_0.txt
-
-cmake_minimum_required(VERSION 3.5...3.16)
-
-project(boost_algorithm VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
-
-add_library(boost_algorithm INTERFACE)
-add_library(Boost::algorithm ALIAS boost_algorithm)
-
-target_include_directories(boost_algorithm INTERFACE include)
-
-target_link_libraries(boost_algorithm
-  INTERFACE
-    Boost::array
-    Boost::assert
-    Boost::bind
-    Boost::concept_check
-    Boost::config
-    Boost::core
-    Boost::exception
-    Boost::function
-    Boost::iterator
-    Boost::mpl
-    Boost::range
-    Boost::regex
-    Boost::static_assert
-    Boost::throw_exception
-    Boost::tuple
-    Boost::type_traits
-    Boost::unordered
-)
-
-if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
-
-  add_subdirectory(test)
-
-endif()
-

Jamfile

@@ -1,11 +0,0 @@
-#  Boost.Algorithm Library Jamfile
-#
-#  Copyright (c) 2018 James E. King III
-#
-#  Use, modification, and distribution are subject to 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)
-
-# please order by name to ease maintenance
-build-project example ;
-build-project test ;

LICENSE

@@ -1,23 +0,0 @@
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

README.md

@@ -1,35 +0,0 @@
-Algorithm, part of collection of the [Boost C++ Libraries](http://github.com/boostorg), is a collection of general purpose algorithms.
-
-### License
-
-Distributed under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
-
-### Properties
-
-* C++03
-* Header-only
-
-### Build Status
-
-Branch          | Travis | Appveyor | Coverity Scan | codecov.io | Deps | Docs | Tests |
-:-------------: | ------ | -------- | ------------- | ---------- | ---- | ---- | ----- |
-[`master`](https://github.com/boostorg/algorithm/tree/master) | [![Build Status](https://travis-ci.org/boostorg/algorithm.svg?branch=master)](https://travis-ci.org/boostorg/algorithm) | [![Build status](https://ci.appveyor.com/api/projects/status/FIXME/branch/master?svg=true)](https://ci.appveyor.com/project/USER/PROJECT/branch/master) | [![Coverity Scan Build Status](https://scan.coverity.com/projects/99999/badge.svg)](https://scan.coverity.com/projects/boostorg-algorithm) | [![codecov](https://codecov.io/gh/boostorg/algorithm/branch/master/graph/badge.svg)](https://codecov.io/gh/boostorg/algorithm/branch/master)| [![Deps](https://img.shields.io/badge/deps-master-brightgreen.svg)](https://pdimov.github.io/boostdep-report/master/algorithm.html) | [![Documentation](https://img.shields.io/badge/docs-master-brightgreen.svg)](http://www.boost.org/doc/libs/master/doc/html/algorithm.html) | [![Enter the Matrix](https://img.shields.io/badge/matrix-master-brightgreen.svg)](http://www.boost.org/development/tests/master/developer/algorithm.html)
-[`develop`](https://github.com/boostorg/algorithm/tree/develop) | [![Build Status](https://travis-ci.org/boostorg/algorithm.svg?branch=develop)](https://travis-ci.org/boostorg/algorithm) | [![Build status](https://ci.appveyor.com/api/projects/status/FIXME/branch/develop?svg=true)](https://ci.appveyor.com/project/USER/PROJECT/branch/develop) | [![Coverity Scan Build Status](https://scan.coverity.com/projects/99999/badge.svg)](https://scan.coverity.com/projects/boostorg-algorithm) | [![codecov](https://codecov.io/gh/boostorg/algorithm/branch/develop/graph/badge.svg)](https://codecov.io/gh/boostorg/algorithm/branch/develop) | [![Deps](https://img.shields.io/badge/deps-develop-brightgreen.svg)](https://pdimov.github.io/boostdep-report/develop/algorithm.html) | [![Documentation](https://img.shields.io/badge/docs-develop-brightgreen.svg)](http://www.boost.org/doc/libs/develop/doc/html/algorithm.html) | [![Enter the Matrix](https://img.shields.io/badge/matrix-develop-brightgreen.svg)](http://www.boost.org/development/tests/develop/developer/algorithm.html)
-
-### Directories
-
-| Name        | Purpose                        |
-| ----------- | ------------------------------ |
-| `doc`       | documentation                  |
-| `example`   | examples                       |
-| `include`   | headers                        |
-| `test`      | unit tests                     |
-
-### More information
-
-* [Ask questions](http://stackoverflow.com/questions/ask?tags=c%2B%2B,boost,boost-algorithm)
-* [Report bugs](https://github.com/boostorg/algorithm/issues): Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
-* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
-* Discussions about the library are held on the [Boost developers mailing list](http://www.boost.org/community/groups.html#main). Be sure to read the [discussion policy](http://www.boost.org/community/policy.html) before posting and add the `[algorithm]` tag at the beginning of the subject line.
-
-

appveyor.yml

@@ -1,130 +0,0 @@
-# Copyright 2016, 2017 Peter Dimov
-# Copyright (C) 2017 - 2019 James E. King III
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-#
-# Generic Appveyor build script for boostorg repositories
-# See: https://github.com/boostorg/boost-ci/
-#
-# Instructions for customizing this script for your library:
-#
-# 1. Customize the compilers and language levels you want.
-# 2. If you have more than include/, src/, test/, example/, examples/,
-#    benchmark/ or tools/ directories, set the environment variable DEPINST.
-#    For example if your build uses code in "bench/" and "fog/" directories:
-#      - DEPINST: --include bench --include fog
-# 3. Enable pull request builds in your boostorg/<library> account.
-#
-# That's it - the script will do everything else for you.
-#
-
-version: 1.0.{build}-{branch}
-
-shallow_clone: true
-
-branches:
-  only:
-    - master
-    - develop
-    - bugfix/*
-    - feature/*
-    - fix/*
-    - pr/*
-
-matrix:
-  # Adding MAYFAIL to any matrix job allows it to fail but the build stays green:
-  allow_failures:
-    - MAYFAIL: true
-
-environment:
-  global:
-    # see: http://www.boost.org/build/doc/html/bbv2/overview/invocation.html#bbv2.overview.invocation.properties
-    # to use the default for a given environment, comment it out; recommend you build debug and release however:
-    # on Windows it is important to exercise all the possibilities, especially shared vs static, however most
-    # libraries that care about this exercise it in their Jamfiles...
-    # B2_ADDRESS_MODEL: address-model=64,32
-    # B2_LINK: link=shared,static
-    # B2_THREADING: threading=multi,single
-    B2_VARIANT: variant=release,debug
-
-  matrix:
-    - FLAVOR: Visual Studio 2017 C++2a Strict
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      B2_ADDRESS_MODEL: address-model=64
-      B2_CXXFLAGS: cxxflags=-permissive-
-      B2_CXXSTD: latest # 2a
-      B2_TOOLSET: msvc-14.1
-
-    - FLAVOR: Visual Studio 2017 C++17
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      B2_ADDRESS_MODEL: address-model=64
-      B2_CXXSTD: 17
-      B2_TOOLSET: msvc-14.1
-
-    - FLAVOR: Visual Studio 2017 C++14 (Default)
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      B2_ADDRESS_MODEL: address-model=64,32
-      B2_TOOLSET: msvc-14.1
-
-    - FLAVOR: Visual Studio 2015 C++14 (Default)
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      B2_ADDRESS_MODEL: address-model=64,32
-      B2_TOOLSET: msvc-14.0
-
-    - FLAVOR: Visual Studio 2010, 2012, 2013
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      B2_TOOLSET: msvc-10.0,msvc-11.0,msvc-12.0
-
-    - FLAVOR: cygwin (32-bit)
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ADDPATH: C:\cygwin\bin;
-      B2_ADDRESS_MODEL: address-model=32
-      B2_CXXSTD: 03,11
-      # https://github.com/boostorg/test/issues/144
-      B2_DEFINES: define=_POSIX_C_SOURCE=200112L
-      B2_THREADING: threadapi=pthread
-      B2_TOOLSET: gcc
-
-    - FLAVOR: cygwin (64-bit)
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ADDPATH: C:\cygwin64\bin;
-      B2_ADDRESS_MODEL: address-model=64
-      B2_CXXSTD: 11,17
-      # https://github.com/boostorg/test/issues/144
-      B2_DEFINES: define=_POSIX_C_SOURCE=200112L define=__USE_ISOC99
-      B2_THREADING: threadapi=pthread
-      B2_TOOLSET: gcc
-
-    - FLAVOR: mingw32
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ARCH: i686
-      B2_ADDRESS_MODEL: address-model=32
-      B2_CXXSTD: 03,11
-      SCRIPT: ci\appveyor\mingw.bat
-
-    - FLAVOR: mingw64
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ARCH: x86_64
-      B2_ADDRESS_MODEL: address-model=64
-      B2_CXXSTD: 11,17
-      B2_DEFINES: define=__USE_ISOC99
-      SCRIPT: ci\appveyor\mingw.bat
-
-install:
-  - set SELF=%APPVEYOR_PROJECT_NAME:-=_%
-  - git clone https://github.com/boostorg/boost-ci.git C:\boost-ci
-  - xcopy /s /e /q /i C:\boost-ci\ci .\ci
-  - ci\appveyor\install.bat
-
-build: off
-
-test_script:
-  - set SELF=%APPVEYOR_PROJECT_NAME:-=_%
-  - PATH=%ADDPATH%%PATH%
-  # The definition of B2_TOOLCXX omits B2_CXXSTD= if it was not defined above
-  - IF NOT DEFINED B2_CXXSTD (SET B2_TOOLCXX=toolset=%B2_TOOLSET%) ELSE (SET B2_TOOLCXX=toolset=%B2_TOOLSET% cxxstd=%B2_CXXSTD%)
-  # Echo the complete build command to the build log
-  - IF NOT DEFINED SCRIPT                         (ECHO b2 libs/%SELF:\=/% %B2_TOOLCXX% %B2_CXXFLAGS% %B2_DEFINES% %B2_THREADING% %B2_ADDRESS_MODEL% %B2_LINK% %B2_THREADING% %B2_VARIANT% -j3)
-  # Now go build...
-  - IF DEFINED SCRIPT (call libs\%SELF%\%SCRIPT%) ELSE (b2 libs/%SELF:\=/% %B2_TOOLCXX% %B2_CXXFLAGS% %B2_DEFINES% %B2_THREADING% %B2_ADDRESS_MODEL% %B2_LINK% %B2_THREADING% %B2_VARIANT% -j3)

doc/Jamfile.v2

@@ -22,7 +22,6 @@ doxygen autodoc
                ../../../boost/algorithm/searching/*.hpp
                ../../../boost/algorithm/cxx11/*.hpp
                ../../../boost/algorithm/cxx14/*.hpp
-               ../../../boost/algorithm/cxx17/*.hpp
         ]
     : 
        <doxygen:param>"PREDEFINED=\"BOOST_ALGORITHM_DOXYGEN=1\""
@@ -41,17 +40,7 @@ boostbook standalone
     <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
   ;
-
-###############################################################################
-alias boostdoc
-    : ../string/doc/string_algo.xml
-    :
-    : <dependency>../string/doc//autodoc
-    : ;
-explicit boostdoc ;
-alias boostrelease : standalone ;
-explicit boostrelease ;

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,233 +55,19 @@ 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]
-
-[section:transform_inclusive_scan transform_inclusive_scan]
-[*[^[link boost.algorithm.transform_inclusive_scan                   transform_inclusive_scan]    ] ]
-Transform each element in a range then combine adjacent elements to create an output range. Inclusive scaning means that the nth input is present in the nth output.
-[endsect:transform_inclusive_scan]
-
-[section:transform_exclusive_scan transform_exclusive_scan]
-[*[^[link boost.algorithm.transform_exclusive_scan                   transform_exclusive_scan]    ] ]
-Transform each element in a range then combine adjacent elements to create an output range. Exclusive scanning means that the nth input is not present in the nth output.
-[endsect:transform_exclusive_scan]
-
-[endsect:CXX17_inner_algorithms]
-
-[endsect:CXX17]
-
-
-[section:Copy Variations on Copy]
-[section:variations_on_copy]
-
-[section:copy_until                copy_until                ]
-[*[^[link header.boost.algorithm.cxx11.copy_if_hpp                   copy_until]                  ] ]
-Copy all the elements from the start of the input range to the output range until the predicate is satisfied
-[endsect:copy_until]
-
-[section:copy_while                copy_while                ]
-[*[^[link header.boost.algorithm.cxx11.copy_if_hpp                   copy_while]                  ] ]
-Copy all the elements from the start of the input range to the output range while the predicate is satisfied
-[endsect:copy_while]
-
-[section:copy_if_until             copy_if_until             ]
-[*[^[link header.boost.algorithm.cxx11.copy_if_hpp                   copy_if_until                ] ]
-Copy all elements that satisfy the element predicate from the start of the input range to the output range until the termination predicate is satisfied
-
-[endsect:copy_if_until]
-
-[section:copy_if_while             copy_if_while             ]
-[*[^[link header.boost.algorithm.cxx11.copy_if_hpp                   copy_if_while                ] ]
-Copy all elements that satisfy the element predicate from the start of the input range to the output range while the termination predicate is satisfied
-
-[endsect:copy_if_while]
-
-[endsect:variations_on_copy]
-[endsect:Copy]
-
+[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]
+[endsect]
 
-[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 indirect_sort.qbk]
-
-[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]
-
-[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_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]

doc/all_of.qbk

@@ -73,7 +73,7 @@ All of the variants of `all_of` and `all_of_equal` take their parameters by valu
 
 [heading Notes]
 
-* The routine `all_of` is also available as part of the C++11 standard.
+* The routine `all_of` is part of the C++11 standard. When compiled using a C++11 implementation, the implementation from the standard library will be used.
 
 * `all_of` and `all_of_equal` both return true for empty ranges, no matter what is passed to test against. When there are no items in the sequence to test, they all satisfy the condition to be tested against.
 

doc/any_of.qbk

@@ -73,7 +73,7 @@ All of the variants of `any_of` and `any_of_equal` take their parameters by valu
 
 [heading Notes]
 
-* The routine `any_of` is also available as part of the C++11 standard.
+* The routine `any_of` is part of the C++11 standard. When compiled using a C++11 implementation, the implementation from the standard library will be used.
 
 * `any_of` and `any_of_equal` both return false for empty ranges, no matter what is passed to test against. 
 

doc/apply_permutation.qbk

@@ -1,96 +0,0 @@
-[/ File apply_permutation.qbk]
-
-[section:apply_permutation apply_permutation]
-
-[/license
-Copyright (c) 2017 Alexander Zaitsev
-
-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 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).
-The routine `apply_reverse_permutation` takes a item sequence and a order sequence. It will reshuffle item sequence according to order sequence. Every value in order sequence means where the item goes to. 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).
-
-Implementations are based on these articles:
-https://devblogs.microsoft.com/oldnewthing/20170102-00/?p=95095
-https://devblogs.microsoft.com/oldnewthing/20170103-00/?p=95105
-https://devblogs.microsoft.com/oldnewthing/20170104-00/?p=95115
-https://devblogs.microsoft.com/oldnewthing/20170109-00/?p=95145
-https://devblogs.microsoft.com/oldnewthing/20170110-00/?p=95155
-https://devblogs.microsoft.com/oldnewthing/20170111-00/?p=95165
-
-The routines come in 2 forms; the first one takes two iterators to define the item range and one iterator to define the beginning of index range. The second form takes range to define the item sequence and range to define index sequence.
-
-
-[heading interface]
-
-There are two versions of algorithms:
-1) takes four iterators.
-2) takes two ranges.
-``
-template<typename RandomAccessIterator1, typename RandomAccessIterator2>
-void apply_permutation(RandomAccessIterator1 item_begin, RandomAccessIterator1 item_end,
-                  RandomAccessIterator2 ind_begin, RandomAccessIterator2 ind_end);
-template<typename Range1, typename Range2>
-void apply_permutation(Range1& item_range, Range2& ind_range);
-template<typename RandomAccessIterator1, typename RandomAccessIterator2>
-void apply_reverse_permutation(RandomAccessIterator1 item_begin, RandomAccessIterator1 item_end,
-                  RandomAccessIterator2 ind_begin, RandomAccessIterator2 ind_end);
-template<typename Range1, typename Range2>
-void apply_reverse_permutation(Range1& item_range, Range2& ind_range);
-``
-
-
-[heading Examples]
-
-Given the containers:
-std::vector<int> emp_vec, emp_order,
-std::vector<int> one{1}, one_order{0},
-std::vector<int> two{1,2}, two_order{1,0},
-std::vector<int> vec{1, 2, 3, 4, 5},
-std::vector<int> order{4, 2, 3, 1, 0}, then
-``
-
-apply_permutation(emp_vec, emp_order))  --> no changes
-apply_reverse_permutation(emp_vec, emp_order))  --> no changes
-apply_permutation(one, one_order)  --> no changes
-apply_reverse_permutation(one, one_order)  --> no changes
-apply_permutation(two, two_order)  --> two:{2,1}
-apply_reverse_permutation(two, two_order)  --> two:{2,1}
-apply_permutation(vec, order)  --> vec:{5, 3, 4, 2, 1}
-apply_reverse_permutation(vec, order)  --> vec:{5, 4, 2, 3, 1}
-``
-
-[heading Iterator Requirements]
-
-`apply_permutation` and 'apply_reverse_permutation' work only on RandomAccess iterators. RandomAccess iterators required both for item and index sequences.
-
-[heading Complexity]
-
-All of the variants of `apply_permutation` and `apply_reverse_permutation` run in ['O(N)] (linear) time.
-More
-
-[heading Exception Safety]
-
-All of the variants of `apply_permutation` and `apply_reverse_permutation` take their parameters by iterators or reference, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
-
-[heading Notes]
-* If ItemSequence and IndexSequence are not equal, behavior is undefined.
-
-* `apply_permutation` and `apply_reverse_permutation` work also on empty sequences.
-
-* Order sequence must be zero-indexed.
-
-* Order sequence gets permuted.
-
-[endsect]
-
-[/ File apply_permutation.qbk
-Copyright 2017 Alexander Zaitsev
-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).
-]

doc/boyer_moore.qbk

@@ -37,7 +37,7 @@ public:
     ~boyer_moore ();
     
     template <typename corpusIter>
-    pair<corpusIter, corpusIter> operator () ( corpusIter corpus_first, corpusIter corpus_last );
+    corpusIter operator () ( corpusIter corpus_first, corpusIter corpus_last );
     };
 ``
 
@@ -45,28 +45,14 @@ and here is the corresponding procedural interface:
 
 ``
 template <typename patIter, typename corpusIter>
-pair<corpusIter, corpusIter> boyer_moore_search ( 
+corpusIter boyer_moore_search ( 
         corpusIter corpus_first, corpusIter corpus_last, 
         patIter pat_first, patIter pat_last );
 ``
 
 Each of the functions is passed two pairs of iterators. The first two define the corpus and the second two define the pattern. Note that the two pairs need not be of the same type, but they do need to "point" at the same type. In other words, `patIter::value_type` and `curpusIter::value_type` need to be the same type.
 
-The return value of the function is a pair of iterators pointing to the position of the pattern in the corpus. If the pattern is empty, it returns at empty range at the start of the corpus (`corpus_first`, `corpus_first`). If the pattern is not found, it returns at empty range at the end of the corpus (`corpus_last`, `corpus_last`).
-
-[heading Compatibility Note]
-
-Earlier versions of this searcher returned only a single iterator.  As explained in [@https://cplusplusmusings.wordpress.com/2016/02/01/sometimes-you-get-things-wrong/], this was a suboptimal interface choice, and has been changed, starting in the 1.62.0 release.  Old code that is expecting a single iterator return value can be updated by replacing the return value of the searcher's `operator ()` with the `.first` field of the pair.
-
-Instead of:
-``
-iterator foo = searcher(a, b);
-``
-
-you now write:
-``
-iterator foo = searcher(a, b).first;
-``
+The return value of the function is an iterator pointing to the start of the pattern in the corpus. If the pattern is not found, it returns the end of the corpus (`corpus_last`).
 
 [heading Performance]
 

doc/boyer_moore_horspool.qbk

@@ -35,7 +35,7 @@ public:
     ~boyer_moore_horspool ();
     
     template <typename corpusIter>
-    pair<corpusIter, corpusIter> operator () ( corpusIter corpus_first, corpusIter corpus_last );
+    corpusIter operator () ( corpusIter corpus_first, corpusIter corpus_last );
     };
 ``
 
@@ -43,28 +43,14 @@ and here is the corresponding procedural interface:
 
 ``
 template <typename patIter, typename corpusIter>
-pair<corpusIter, corpusIter> boyer_moore_horspool_search ( 
+corpusIter boyer_moore_horspool_search ( 
         corpusIter corpus_first, corpusIter corpus_last, 
         patIter pat_first, patIter pat_last );
 ``
 
 Each of the functions is passed two pairs of iterators. The first two define the corpus and the second two define the pattern. Note that the two pairs need not be of the same type, but they do need to "point" at the same type. In other words, `patIter::value_type` and `curpusIter::value_type` need to be the same type.
 
-The return value of the function is a pair of iterators pointing to the position of the pattern in the corpus. If the pattern is empty, it returns at empty range at the start of the corpus (`corpus_first`, `corpus_first`). If the pattern is not found, it returns at empty range at the end of the corpus (`corpus_last`, `corpus_last`).
-
-[heading Compatibility Note]
-
-Earlier versions of this searcher returned only a single iterator.  As explained in [@https://cplusplusmusings.wordpress.com/2016/02/01/sometimes-you-get-things-wrong/], this was a suboptimal interface choice, and has been changed, starting in the 1.62.0 release.  Old code that is expecting a single iterator return value can be updated by replacing the return value of the searcher's `operator ()` with the `.first` field of the pair.
-
-Instead of:
-``
-iterator foo = searcher(a, b);
-``
-
-you now write:
-``
-iterator foo = searcher(a, b).first;
-``
+The return value of the function is an iterator pointing to the start of the pattern in the corpus. If the pattern is not found, it returns the end of the corpus (`corpus_last`).
 
 [heading Performance]
 

doc/clamp-hpp.qbk

@@ -27,11 +27,11 @@ Note: using `clamp` with floating point numbers may give unexpected results if o
 There is also a version that allows the caller to specify a comparison predicate to use instead of `operator <`.
 
 ``
-template<typename T> 
-const T& clamp ( const T& val, const T& lo, const T& hi );
+template<typename V> 
+V clamp ( V val, V lo, V hi );
 
-template<typename T, typename Pred> 
-const T& clamp ( const T& val, const T& lo, const T& hi, Pred p );
+template<typename V, typename Pred> 
+V clamp ( V val, V lo, V hi, Pred p );
 ``
 
 The following code: ``

doc/find_backward.qbk

@@ -1,116 +0,0 @@
-[/ File find_backward.qbk]
-
-[section:find_backward find_backward ]
-
-[/license
-Copyright (c) 2018 T. Zachary Laine
-
-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 'find_backward.hpp' contains variants of the stl algorithm
-`find`. These variants are like `find`, except that the evaluate the elements
-of the given sequence in reverse order.
-
-Consider how finding the last element that is equal to `x` in a range is
-typically done:
-
-    // Assume a valid range if elements delimited by [first, last).
-    while (last-- != first) {
-        if (*last == x) {
-            // Use last here...
-        }
-    }
-
-Raw loops are icky though.  Perhaps we should do a bit of extra work to allow
-the use of `std::find()`:
-
-    auto rfirst = std::make_reverse_iterator(last);
-    auto rlast = std::make_reverse_iterator(first);
-    auto it = std::find(rfirst, rlast, x);
-    // Use it here...
-
-That seems nicer in that there is no raw loop, but it has two major drawbacks.
-First, it requires an unpleasant amount of typing.  Second, it is less
-efficient than forward-iterator `find` , since `std::reverse_iterator` calls
-its base-iterator's `operator--()` in most of its member functions before
-doing the work that the member function requires.
-
-[heading interface]
-
-    template<typename BidiIter, typename T>
-    BidiIter find_backward(BidiIter first, BidiIter last, const T & x);
-
-    template<typename Range, typename T>
-    boost::range_iterator<Range> find_backward(Range & range, const T & x);
-
-These overloads of `find_backward` return an iterator to the last element that
-is equal to `x` in `[first, last)` or `r`, respectively.
-
-    template<typename BidiIter, typename T>
-    BidiIter find_not_backward(BidiIter first, BidiIter last, const T & x);
-
-    template<typename Range, typename T>
-    boost::range_iterator<Range> find_not_backward(Range & range, const T & x);
-
-These overloads of `find_not_backward` return an iterator to the last element
-that is not equal to `x` in `[first, last)` or `r`, respectively.
-
-    template<typename BidiIter, typename Pred>
-    BidiIter find_if_backward(BidiIter first, BidiIter last, Pred p);
-
-    template<typename Range, typename Pred>
-    boost::range_iterator<Range> find_if_backward(Range & range, Pred p);
-
-These overloads of `find_if_backward` return an iterator to the last element
-for which `pred` returns `true` in `[first, last)` or `r`, respectively.
-
-    template<typename BidiIter, typename Pred>
-    BidiIter find_if_not_backward(BidiIter first, BidiIter last, Pred p);
-
-    template<typename Range, typename Pred>
-    boost::range_iterator<Range> find_if_not_backward(Range & range, Pred p);
-
-These overloads of `find_if_not_backward` return an iterator to the last
-element for which `pred` returns `false` in `[first, last)` or `r`,
-respectively.
-
-[heading Examples]
-
-Given the container `c1` containing `{ 2, 1, 2 }`, then
-
-    find_backward        ( c1.begin(), c1.end(), 2                          ) --> --c1.end()
-    find_backward        ( c1.begin(), c1.end(), 3                          ) --> c1.end()
-    find_if_backward     ( c1.begin(), c1.end(), [](int i) {return i == 2;} ) --> --c1.end()
-    find_if_backward     ( c1.begin(), c1.end(), [](int i) {return i == 3;} ) --> c1.end()
-    find_not_backward    ( c1.begin(), c1.end(), 2                          ) --> std::prev(c1.end(), 2)
-    find_not_backward    ( c1.begin(), c1.end(), 1                          ) --> c1.end()
-    find_if_not_backward ( c1.begin(), c1.end(), [](int i) {return i == 2;} ) --> std::prev(c1.end(), 2)
-    find_if_not_backward ( c1.begin(), c1.end(), [](int i) {return i == 1;} ) --> c1.end()
-
-[heading Iterator Requirements]
-
-All variants work on bidirectional iterators.
-
-[heading Complexity]
-
-Linear.
-
-[heading Exception Safety]
-
-All of the variants take their parameters by value and do not depend upon any
-global state. Therefore, all the routines in this file provide the strong
-exception guarantee.
-
-[heading Notes]
-
-All variants are `constexpr` in C++14 or later.
-
-[endsect]
-
-[/ File equal.qbk
-Copyright 2018 T. Zachary Laine
-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).
-]

doc/find_not.qbk

@@ -1,83 +0,0 @@
-[/ File find_not.qbk]
-
-[section:find_not find_not ]
-
-[/license
-Copyright (c) 2018 T. Zachary Laine
-
-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 'find_not.hpp' contains a variants of a the stl algorithm
-`find`. The algorithm finds the first value in the given sequence that is not
-equal to the given value.
-
-Consider this use of `find()`:
-
-    std::vector<int> vec = { 1, 1, 2 };
-    auto it = std::find(vec.begin(), vec.end(), 1);
-
-This gives us the first occurance of `1` in `vec`.  What if we want to find
-the first occurrance of any number besides `1` in `vec`?  We have to write an
-unfortunate amount of code:
-
-    std::vector<int> vec = { 1, 1, 2 };
-    auto it = std::find_if(vec.begin(), vec.end(), [](int i) { return i != 1; });
-
-With `find_not()` the code gets much more terse:
-
-    std::vector<int> vec = { 1, 1, 2 };
-    auto it = find_not(vec.begin(), vec.end(), 1);
-
-The existing `find` variants are: `find()`, `find_if()`, and `find_if_not()`.
-It seems natural to also have `find_not()`, for the very reason that we have
-`find_if_not()` -- to avoid having to write a lambda to wrap the negation of
-the find condition.
-
-[heading interface]
-
-    template<typename InputIter, typename Sentinel, typename T>        
-    InputIter find_not(InputIter first, Sentinel last, const T & x);
-
-    template<typename Range, typename T>
-    boost::range_iterator<Range> find_not(Range & r, const T & x);
-
-These overloads of `find_not` return the first value that is not equal to `x`
-in the sequence `[first, last)` or `r`, respectively.
-
-[heading Examples]
-
-Given the container `c1` containing `{ 0, 1, 2 }`,  then
-
-    find_not ( c1.begin(),     c1.end(),    1 ) --> c1.begin()
-    find_not ( c1.begin(),     c1.end(),    0 ) --> std::next(c1.begin())
-
-[heading Iterator Requirements]
-
-`find_not` works on all iterators except output iterators.
-
-The template parameter `Sentinel` is allowed to be different from `InputIter`,
-or they may be the same.  For an `InputIter` `it` and a `Sentinel` `end`, `it
-== end` and `it != end` must be well-formed expressions.
-
-[heading Complexity]
-
-Linear.
-
-[heading Exception Safety]
-
-`find_not` takes its parameters by value and do not depend upon any global
-state. Therefore, it provides the strong exception guarantee.
-
-[heading Notes]
-
-`constexpr` in C++14 or later.
-
-[endsect]
-
-[/ File equal.qbk
-Copyright 2018 T. Zachary Laine
-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).
-]

doc/indirect_sort.qbk

@@ -1,111 +0,0 @@
-[/ File indirect_sort.qbk]
-
-[section:indirect_sort indirect_sort ]
-
-[/license
-Copyright (c) 2023 Marshall Clow
-
-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)
-]
-
-There are times that you want a sorted version of a sequence, but for some reason you don't want to modify it.  Maybe the elements in the sequence can't be moved/copied, e.g. the sequence is const, or they're just really expensive to move around.   An example of this might be a sequence of records from a database.
-
-That's where indirect sorting comes in.  In a "normal" sort, the elements of the sequence to be sorted are shuffled in place.  In indirect sorting, the elements are unchanged, but the sort algorithm returns a "permutation" of the elements that, when applied, will put the elements in the sequence in a sorted order.
-
-Assume have a sequence `[first, last)` of 1000 items that are expensive to swap:
-```
-	std::sort(first, last);  // ['O(N ln N)] comparisons and ['O(N ln N)] swaps (of the element type).
-```
-
-On the other hand, using indirect sorting:
-```
-	auto perm = indirect_sort(first, last);  // ['O(N lg N)] comparisons and ['O(N lg N)] swaps (of size_t).
-	apply_permutation(first, last, perm.begin(), perm.end()); // ['O(N)] swaps (of the element type)
-```
-
-If the element type is sufficiently expensive to swap, then 10,000 swaps of size_t + 1000 swaps of the element_type could be cheaper than 10,000 swaps of the element_type.
-
-Or maybe you don't need the elements to actually be sorted - you just want to traverse them in a sorted order:
-```
-	auto permutation = indirect_sort(first, last);
-	for (size_t idx: permutation)
-		std::cout << first[idx] << std::endl;
-```
-
-
-Assume that instead of an "array of structures", you have a "struct of arrays".
-```
-struct AType {
-	Type0 key;
-	Type1 value1;
-	Type1 value2;
-	};
-
-std::array<AType, 1000> arrayOfStruct;
-```
-
-versus:
-
-```
-template <size_t N>
-struct AType {
-	std::array<Type0, N> key;
-	std::array<Type1, N> value1;
-	std::array<Type2, N> value2;
-	};
-	
-AType<1000> structOfArrays;
-```
-
-Sorting the first one is easy, because each set of fields (`key`, `value1`, `value2`) are part of the same struct.  But with indirect sorting, the second one is easy to sort as well - just sort the keys, then apply the permutation to the keys and the values:
-```
-	auto perm = indirect_sort(std::begin(structOfArrays.key), std::end(structOfArrays.key));
-	apply_permutation(structOfArrays.key.begin(),    structOfArrays.key.end(),    perm.begin(), perm.end());
-	apply_permutation(structOfArrays.value1.begin(), structOfArrays.value1.end(), perm.begin(), perm.end());
-	apply_permutation(structOfArrays.value2.begin(), structOfArrays.value2.end(), perm.begin(), perm.end());
-```
-
-[heading interface]
-
-The function `indirect_sort` returns a `vector<size_t>` containing the permutation necessary to put the input sequence into a sorted order. One version uses `std::less` to do the comparisons; the other lets the caller pass predicate to do the comparisons. 
-
-There is also a variant called `indirect_stable_sort`; it bears the same relation to `indirect_sort` that `std::stable_sort` does to `std::sort`.
-
-```
-template <typename RAIterator>
-std::vector<size_t> indirect_sort (RAIterator first, RAIterator last);
-
-template <typename RAIterator, typename BinaryPredicate>
-std::vector<size_t> indirect_sort (RAIterator first, RAIterator last, BinaryPredicate pred);
-
-template <typename RAIterator>
-std::vector<size_t> indirect_stable_sort (RAIterator first, RAIterator last);
-
-template <typename RAIterator, typename BinaryPredicate>
-std::vector<size_t> indirect_stable_sort (RAIterator first, RAIterator last, BinaryPredicate pred);
-```
-
-[heading Examples]
-
-[heading Iterator Requirements]
-
-`indirect_sort` requires random-access iterators.
-
-[heading Complexity]
-
-Both of the variants of `indirect_sort` run in ['O(N lg N)] time; they are not more (or less) efficient than `std::sort`. There is an extra layer of indirection on each comparison, but all of the swaps are done on values of type `size_t`
-
-[heading Exception Safety]
-
-[heading Notes]
-
-In numpy, this algorithm is known as `argsort`.
-
-[endsect]
-
-[/ File indirect_sort.qbk
-Copyright 2023 Marshall Clow
-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).
-]

doc/is_palindrome.qbk

@@ -1,98 +0,0 @@
-[/ File is_palindrome.qbk]
-
-[section:is_palindrome is_palindrome]
-
-[/license
-Copyright (c) 2016 Alexander Zaitsev
-
-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 'is_palindrome.hpp' contains six variants of a single algorithm, is_palindrome. 
-The algorithm tests the sequence and returns true if the sequence is a palindrome; i.e, it is identical when traversed either backwards or frontwards.
-
-The routine `is_palindrome` takes a sequence and, optionally, a predicate. It will return true if the predicate returns true for tested elements by algorithm in the sequence. 
-
-The routine come in 6 forms; the first one takes two iterators to define the range. The second form takes two iterators to define the range and a predicate. 
-The third form takes a single range parameter, and uses Boost.Range to traverse it. The fourth form takes a single range parameter ( uses Boost.Range to traverse it) and a predicate.
-The fifth form takes a single C-string and a predicate. The sixth form takes a single C-string.
-
-
-[heading interface]
-
-The function `is_palindrome` returns true if the predicate returns true any tested by algorithm items in the sequence.  
-There are six versions: 
-1) takes two iterators.
-2) takes two iterators and a predicate.
-3) takes a range.
-4) takes a range and a predicate.
-5) takes a C-string and a predicate.
-6) takes a C-string.
-
-``
-template<typename BidirectionalIterator>
-	bool is_palindrome ( BidirectionalIterator begin, BidirectionalIterator end );
-template<typename BidirectionalIterator, typename Predicate>
-	bool is_palindrome ( BidirectionalIterator begin, BidirectionalIterator end, Predicate p );
-template<typename Range> 
-	bool is_palindrome ( const Range &r );
-template<typename Range, typename Predicate> 
-	bool is_palindrome ( const Range &r, Predicate p );
-template<typename Predicate>
-	bool is_palindrome ( const char* str, Predicate p );
-bool is_palindrome(const char* str);
-``
-
-
-[heading Examples]
-
-Given the containers: 
-const std::list<int> empty,
-const std::vector<char> singleElement{'z'},
-int oddNonPalindrome[] = {3,2,2},
-const int oddPalindrome[] = {1,2,3,2,1},
-const int evenPalindrome[] = {1,2,2,1},
-int evenNonPalindrome[] = {1,4,8,8}, then
-``
-
-is_palindrome(empty))  --> true //empty range                                                                       
-is_palindrome(singleElement))  --> true                                                               
-is_palindrome(std::begin(oddNonPalindrome), std::end(oddNonPalindrome))) --> false                    
-is_palindrome(std::begin(evenPalindrome), std::end(evenPalindrome))) --> true                                                                                                                                                                                                            
-is_palindrome(empty.begin(), empty.end(), functorComparator())) --> true //empty range                             
-is_palindrome(std::begin(oddNonPalindrome), std::end(oddNonPalindrome), funcComparator<int>)) --> false
-is_palindrome(std::begin(oddPalindrome), std::end(oddPalindrome)) --> true
-is_palindrome(evenPalindrome, std::equal_to<int>())) --> true
-is_palindrome(std::begin(evenNonPalindrome), std::end(evenNonPalindrome)) --> false
-is_palindrome("a") --> true
-is_palindrome("aba", std::equal_to<char>()) --> true
-``
-
-[heading Iterator Requirements]
-
-`is_palindrome` work on Bidirectional and RandomAccess iterators.
-
-[heading Complexity]
-
-All of the variants of `is_palindrome` run in ['O(N)] (linear) time; that is, they compare against each element in the list once. If any of the comparisons not succeed, the algorithm will terminate immediately, without examining the remaining members of the sequence.
-
-[heading Exception Safety]
-
-All of the variants of `is_palindrome` take their parameters by value, const pointer or const reference, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
-
-[heading Notes]
-
-* `is_palindrome` returns true for empty ranges, const char* null pointers and for single element ranges. 
-
-* If you use version of 'is_palindrome' without custom predicate, 'is_palindrome' uses default 'operator==()' for elements.
-
-* Be careful with using not null pointer 'const char*' without '\0' - if you use it with 'is_palindrome', it's a undefined behaviour.
-
-[endsect]
-
-[/ File is_palindrome.qbk
-Copyright 2016 Alexander Zaitsev
-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).
-]

doc/is_partitioned.qbk

@@ -55,9 +55,9 @@ Both of the variants of `is_partitioned` take their parameters by value or const
 
 [heading Notes]
 
-* The iterator-based version of the routine `is_partitioned` is also available as part of the C++11 standard.
+* The iterator-based version of the routine `is_partitioned` is part of the C++11 standard. When compiled using a C++11 implementation, the implementation from the standard library will be used.
 
-* `is_partitioned` returns true for empty and single-element ranges, no matter what predicate is passed to test against. 
+* `is_partitioned` returns true for empty ranges, no matter what predicate is passed to test against. 
 
 [endsect]
 

doc/is_partitioned_until.qbk

@@ -1,67 +0,0 @@
-[/ File is_partitioned_until.qbk]
-
-[section:is_partitioned_until is_partitioned_until ]
-
-[/license
-Copyright (c) 2017 Alexander Zaitsev
-
-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 'is_partitioned_until.hpp' contains two variants of a single algorithm, `is_partitioned_until`. The algorithm tests to see if a sequence is partitioned according to a predicate; in other words, all the items in the sequence that satisfy the predicate are at the beginning of the sequence.
-
-The routine `is_partitioned_until` takes a sequence and a predicate. It returns the last iterator 'it' in the sequence [begin, end) for which the is_partitioned(begin, it) is true.
-
-`is_partitioned_until` come in two forms; the first one takes two iterators to define the range. The second form takes a single range parameter, and uses Boost.Range to traverse it.
-
-
-[heading interface]
-
-The function `is_partitioned_until` returns the last iterator 'it' in the sequence [begin, end) for which the is_partitioned(begin, it) is true. There are two versions; one takes two iterators, and the other takes a range.
-
-``
-template<typename InputIterator, typename Predicate>
-	InputIterator is_partitioned_until ( InputIterator first, InputIterator last, Predicate p );
-template<typename Range, typename Predicate> 
-	typename boost::range_iterator<const Range>::type is_partitioned_until ( const Range &r, Predicate p );
-``
-
-[heading Examples]
-
-Given the container `c` containing `{ 0, 1, 2, 3, 14, 15 }`, then
-``
-bool isOdd ( int i ) { return i % 2 == 1; }
-bool lessThan10 ( int i ) { return i < 10; }
-
-is_partitioned_until ( c, isOdd ) --> iterator to '1'
-is_partitioned_until ( c, lessThan10 ) --> end
-is_partitioned_until ( c.begin (), c.end (), lessThan10 ) --> end
-is_partitioned_until ( c.begin (), c.begin () + 3, lessThan10 ) --> end
-is_partitioned_until ( c.end (), c.end (), isOdd ) --> end  // empty range
-``
-
-[heading Iterator Requirements]
-
-`is_partitioned_until` works on all iterators except output iterators.
-
-[heading Complexity]
-
-Both of the variants of `is_partitioned_until` run in ['O(N)] (linear) time; that is, they compare against each element in the list once. If the sequence is found to be not partitioned at any point, the routine will terminate immediately, without examining the rest of the elements.
-
-[heading Exception Safety]
-
-Both of the variants of `is_partitioned_until` take their parameters by value or const reference, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
-
-[heading Notes]
-
-* `is_partitioned_until` returns iterator to the end for empty and single-element ranges, no matter what predicate is passed to test against. 
-
-[endsect]
-
-[/ File is_partitioned_until.qbk
-Copyright 2017 Alexander Zaitsev
-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).
-]
-

doc/is_permutation.qbk

@@ -71,7 +71,7 @@ All of the variants of `is_permutation` take their parameters by value, and do n
 
 [heading Notes]
 
-* The three iterator versions of the routine `is_permutation` are also available as part of the C++11 standard.
+* The three iterator versions of the routine `is_permutation` are part of the C++11 standard. When compiled using a C++11 implementation, the implementation from the standard library will be used.
 
 * The four iterator versions of the routine `is_permutation` are part of the proposed C++14 standard. When C++14 standard libraries become available, the implementation should be changed to use the implementation from the standard library (if available).
 

doc/knuth_morris_pratt.qbk

@@ -39,7 +39,7 @@ public:
     ~knuth_morris_pratt ();
     
     template <typename corpusIter>
-    pair<corpusIter, corpusIter> operator () ( corpusIter corpus_first, corpusIter corpus_last );
+    corpusIter operator () ( corpusIter corpus_first, corpusIter corpus_last );
     };
 ``
 
@@ -47,28 +47,15 @@ and here is the corresponding procedural interface:
 
 ``
 template <typename patIter, typename corpusIter>
-pair<corpusIter, corpusIter> knuth_morris_pratt_search ( 
+corpusIter knuth_morris_pratt_search ( 
         corpusIter corpus_first, corpusIter corpus_last, 
         patIter pat_first, patIter pat_last );
 ``
 
 Each of the functions is passed two pairs of iterators. The first two define the corpus and the second two define the pattern. Note that the two pairs need not be of the same type, but they do need to "point" at the same type. In other words, `patIter::value_type` and `curpusIter::value_type` need to be the same type.
 
-The return value of the function is a pair of iterators pointing to the position of the pattern in the corpus. If the pattern is empty, it returns at empty range at the start of the corpus (`corpus_first`, `corpus_first`). If the pattern is not found, it returns at empty range at the end of the corpus (`corpus_last`, `corpus_last`).
+The return value of the function is an iterator pointing to the start of the pattern in the corpus. If the pattern is not found, it returns the end of the corpus (`corpus_last`).
 
-[heading Compatibility Note]
-
-Earlier versions of this searcher returned only a single iterator.  As explained in [@https://cplusplusmusings.wordpress.com/2016/02/01/sometimes-you-get-things-wrong/], this was a suboptimal interface choice, and has been changed, starting in the 1.62.0 release.  Old code that is expecting a single iterator return value can be updated by replacing the return value of the searcher's `operator ()` with the `.first` field of the pair.
-
-Instead of:
-``
-iterator foo = searcher(a, b);
-``
-
-you now write:
-``
-iterator foo = searcher(a, b).first;
-``
 [heading Performance]
 
 The execution time of the Knuth-Morris-Pratt algorithm is linear in the size of the string being searched. Generally the algorithm gets faster as the pattern being searched for becomes longer. Its efficiency derives from the fact that with each unsuccessful attempt to find a match between the search string and the text it is searching, it uses the information gained from that attempt to rule out as many positions of the text as possible where the string cannot match.

doc/none_of.qbk

@@ -74,7 +74,7 @@ All of the variants of `none_of` and `none_of_equal` take their parameters by va
 
 [heading Notes]
 
-* The routine `none_of` is also available as part of the C++11 standard.
+* The routine `none_of` is part of the C++11 standard. When compiled using a C++11 implementation, the implementation from the standard library will be used.
 
 * `none_of` and `none_of_equal` both return true for empty ranges, no matter what is passed to test against. 
 

doc/ordered-hpp.qbk

@@ -15,7 +15,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 The header file `<boost/algorithm/cxx11/is_sorted.hpp>` contains functions for determining if a sequence is ordered.
 
 [heading is_sorted]
-The function `is_sorted(sequence)` determines whether or not a sequence is completely sorted according so some criteria.  If no comparison predicate is specified, then `std::less` is used (i.e, the test is to see if the sequence is non-decreasing)
+The function `is_sorted(sequence)` determines whether or not a sequence is completely sorted according so some criteria.  If no comparison predicate is specified, then std::less_equal is used (i.e, the test is to see if the sequence is non-decreasing)
 
 ``
 namespace boost { namespace algorithm {

doc/partition_point.qbk

@@ -54,7 +54,7 @@ Both of the variants of `partition_point` take their parameters by value or cons
 
 [heading Notes]
 
-* The iterator-based version of the routine `partition_point` is also available as part of the C++11 standard.
+* The iterator-based version of the routine `partition_point` is part of the C++11 standard. When compiled using a C++11 implementation, the implementation from the standard library will be used.
 
 * For empty ranges, the partition point is the end of the range.
 

example/Jamfile.v2

@@ -18,8 +18,5 @@ 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 ;

example/apply_permutation_example.cpp

@@ -1,69 +0,0 @@
-/*
-  Copyright (c) Alexander Zaitsev <zamazan4ik@gmail.com>, 2017
-
-  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)
-
-  See http://www.boost.org/ for latest version.
-*/
-
-#include <vector>
-#include <iostream>
-
-#include <boost/algorithm/apply_permutation.hpp>
-
-
-namespace ba = boost::algorithm;
-
-int main ( int /*argc*/, char * /*argv*/ [] )
-{
-    // WARNING: Example require C++11 or newer compiler
-    {
-        std::cout << "apply_permutation with iterators:\n";
-        std::vector<int> vec{1, 2, 3, 4, 5}, order{4, 2, 3, 1, 0};
-
-        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        for (const auto& x : vec)
-        {
-            std::cout << x << ", ";
-        }
-        std::cout << std::endl;
-    }
-    {
-        std::cout << "apply_reverse_permutation with iterators:\n";
-        std::vector<int> vec{1, 2, 3, 4, 5}, order{4, 2, 3, 1, 0};
-
-        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        for (const auto& x : vec)
-        {
-            std::cout << x << ", ";
-        }
-        std::cout << std::endl;
-    }
-    {
-        std::cout << "apply_reverse_permutation with ranges:\n";
-        std::vector<int> vec{1, 2, 3, 4, 5}, order{4, 2, 3, 1, 0};
-
-        ba::apply_reverse_permutation(vec, order);
-        for (const auto& x : vec)
-        {
-            std::cout << x << ", ";
-        }
-        std::cout << std::endl;
-    }
-    {
-        std::cout << "apply_permutation with ranges:\n";
-        std::vector<int> vec{1, 2, 3, 4, 5}, order{4, 2, 3, 1, 0};
-
-        ba::apply_permutation(vec, order);
-        for (const auto& x : vec)
-        {
-            std::cout << x << ", ";
-        }
-        std::cout << std::endl;
-    }
-
-    return 0;
-}
-

example/is_palindrome_example.cpp

@@ -1,99 +0,0 @@
-/*
-   Copyright (c) Alexander Zaitsev <zamazan4ik@gmail.by>, 2016
-
-   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)
-
-    For more information, see http://www.boost.org
-*/
-
-#include <vector>
-#include <list>
-#include <iterator>
-#include <functional>
-#include <iostream>
-
-#include <boost/algorithm/is_palindrome.hpp>
-
-
-namespace ba = boost::algorithm;
-
-template <typename T>
-bool funcComparator(const T& v1, const T& v2)
-{
-    return v1 == v2;
-}
-
-struct functorComparator
-{
-    template <typename T>
-    bool operator()(const T& v1, const T& v2) const
-    {
-        return v1 == v2;
-    }
-};
-
-
-int main ( int /*argc*/, char * /*argv*/ [] )
-{
-    //You can this algorithm with iterators(minimum Bidirectional)
-    std::vector<int> vec{1,2,1};
-    if(ba::is_palindrome(vec.begin(), vec.end()))
-        std::cout << "This container is palindrome" << std::endl;
-    else
-        std::cout << "This container is not palindrome" << std::endl;
-
-
-    //Of course, you can use const iterators
-    if(ba::is_palindrome(vec.cbegin(), vec.cend()))
-        std::cout << "This container is palindrome" << std::endl;
-    else
-        std::cout << "This container is not palindrome" << std::endl;
-
-
-    //Example with bidirectional iterators
-    std::list<int> list{1,2,1};
-    if(ba::is_palindrome(list.begin(), list.end()))
-        std::cout << "This container is palindrome" << std::endl;
-    else
-        std::cout << "This container is not palindrome" << std::endl;
-
-
-    //You can use custom comparators like functions, functors, lambdas
-    auto lambdaComparator = [](int v1, int v2){ return v1 == v2; };
-    auto objFunc = std::function<bool(int, int)>(lambdaComparator);
-
-    if(ba::is_palindrome(vec.begin(), vec.end(), lambdaComparator))
-        std::cout << "This container is palindrome" << std::endl;
-    else
-        std::cout << "This container is not palindrome" << std::endl;
-
-    if(ba::is_palindrome(vec.begin(), vec.end(), funcComparator<int>))
-        std::cout << "This container is palindrome" << std::endl;
-    else
-        std::cout << "This container is not palindrome" << std::endl;
-
-    if(ba::is_palindrome(vec.begin(), vec.end(), functorComparator()))
-        std::cout << "This container is palindrome" << std::endl;
-    else
-        std::cout << "This container is not palindrome" << std::endl;
-
-    if(ba::is_palindrome(vec.begin(), vec.end(), objFunc))
-        std::cout << "This container is palindrome" << std::endl;
-    else
-        std::cout << "This container is not palindrome" << std::endl;
-
-
-    //You can use ranges
-    if(ba::is_palindrome(vec))
-        std::cout << "This container is palindrome" << std::endl;
-    else
-        std::cout << "This container is not palindrome" << std::endl;
-    
-    //You can use C-strings
-    if(ba::is_palindrome("aba"))
-	std::cout << "This C-string is palindrome" << std::endl;
-    else
-        std::cout << "This C-string is not palindrome" << std::endl;
-    return 0;
-}

example/is_partitioned_until_example.cpp

@@ -1,70 +0,0 @@
-/*
-   Copyright (c) Alexander Zaitsev <zamazan4ik@gmail.by>, 2017
-
-   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)
-
-    For more information, see http://www.boost.org
-*/
-
-#include <vector>
-#include <functional>
-#include <iostream>
-
-#include <boost/algorithm/is_partitioned_until.hpp>
-
-
-namespace ba = boost::algorithm;
-
-bool isOdd(const int v1)
-{
-    return v1 % 2 != 0;
-}
-
-struct isOddComp
-{
-    bool operator()(const int v1) const
-    {
-        return v1 % 2 != 0;
-    }
-};
-
-
-int main ( int /*argc*/, char * /*argv*/ [] )
-{
-    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);
-    if(it1 == good.end())
-    {
-        std::cout << "The sequence is partitioned\n";
-    }
-    else
-    {
-        std::cout << "is_partitioned_until check failed here: " << *it1 << std::endl;
-    }
-
-    //Use custom comparator
-    auto it2 = ba::is_partitioned_until(good.begin(), good.end(), isOddComp());
-    if(it2 == good.end())
-    {
-        std::cout << "The sequence is partitioned\n";
-    }
-    else
-    {
-        std::cout << "is_partitioned_until check failed here: " << *it2 << std::endl;
-    }
-
-    auto it3 = ba::is_partitioned_until(bad, isOdd);
-    if(it3 == bad.end())
-    {
-        std::cout << "The sequence is partitioned\n";
-    }
-    else
-    {
-        std::cout << "is_partitioned_until check failed here: " << *it3 << std::endl;
-    }
-    return 0;
-}

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;

include/boost/algorithm/algorithm.hpp

@@ -17,19 +17,16 @@
 #ifndef BOOST_ALGORITHM_HPP
 #define BOOST_ALGORITHM_HPP
 
-#include <functional> // for plus and multiplies
-
-#include <boost/config.hpp>
-#include <boost/core/enable_if.hpp> // for boost::disable_if
+#include <boost/utility/enable_if.hpp> // for boost::disable_if
 #include <boost/type_traits/is_integral.hpp>
 
 namespace boost { namespace algorithm {
 
 template <typename T>
-BOOST_CXX14_CONSTEXPR T identity_operation ( std::multiplies<T> ) { return T(1); }
+T identity_operation ( std::multiplies<T> ) { return T(1); }
 
 template <typename T>
-BOOST_CXX14_CONSTEXPR T identity_operation ( std::plus<T> ) { return T(0); }
+T identity_operation ( std::plus<T> ) { return T(0); }
 
 
 /// \fn power ( T x, Integer n )
@@ -41,7 +38,7 @@ BOOST_CXX14_CONSTEXPR T identity_operation ( std::plus<T> ) { return T(0); }
 //  \remark Taken from Knuth, The Art of Computer Programming, Volume 2:
 //  Seminumerical Algorithms, Section 4.6.3
 template <typename T, typename Integer>
-BOOST_CXX14_CONSTEXPR typename boost::enable_if<boost::is_integral<Integer>, T>::type
+typename boost::enable_if<boost::is_integral<Integer>, T>::type
 power (T x, Integer n) {
     T y = 1; // Should be "T y{1};" 
     if (n == 0) return y;
@@ -59,7 +56,7 @@ power (T x, Integer n) {
 
 /// \fn power ( T x, Integer n, Operation op )
 /// \return the value "x" raised to the power "n"
-/// using the operation "op".
+/// using the operaton "op".
 /// 
 /// \param x     The value to be exponentiated
 /// \param n     The exponent (must be >= 0)
@@ -68,7 +65,7 @@ power (T x, Integer n) {
 //  \remark Taken from Knuth, The Art of Computer Programming, Volume 2:
 //  Seminumerical Algorithms, Section 4.6.3
 template <typename T, typename Integer, typename Operation>
-BOOST_CXX14_CONSTEXPR typename boost::enable_if<boost::is_integral<Integer>, T>::type
+typename boost::enable_if<boost::is_integral<Integer>, T>::type
 power (T x, Integer n, Operation op) {
     T y = identity_operation(op);
     if (n == 0) return y;

include/boost/algorithm/apply_permutation.hpp

@@ -1,126 +0,0 @@
-/*
-  Copyright (c) Alexander Zaitsev <zamazan4ik@gmail.com>, 2017
-
-  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)
-
-  See http://www.boost.org/ for latest version.
-
-
-  Based on https://blogs.msdn.microsoft.com/oldnewthing/20170104-00/?p=95115
-*/
-
-/// \file  apply_permutation.hpp
-/// \brief Apply permutation to a sequence.
-/// \author Alexander Zaitsev
-
-#ifndef BOOST_ALGORITHM_APPLY_PERMUTATION_HPP
-#define BOOST_ALGORITHM_APPLY_PERMUTATION_HPP
-
-#include <algorithm>
-
-#include <boost/config.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-namespace boost { namespace algorithm
-{
-
-/// \fn apply_permutation ( RandomAccessIterator1 item_begin, RandomAccessIterator1 item_end, RandomAccessIterator2 ind_begin )
-/// \brief Reorder item sequence with index sequence order
-///
-/// \param item_begin    The start of the item sequence
-/// \param item_end		 One past the end of the item sequence
-/// \param ind_begin     The start of the index sequence.
-///
-/// \note Item sequence size should be equal to index size. Otherwise behavior is undefined.
-///       Complexity: O(N).
-template<typename RandomAccessIterator1, typename RandomAccessIterator2>
-void
-apply_permutation(RandomAccessIterator1 item_begin, RandomAccessIterator1 item_end,
-                  RandomAccessIterator2 ind_begin, RandomAccessIterator2 ind_end)
-{
-    typedef typename std::iterator_traits<RandomAccessIterator1>::difference_type Diff;
-    typedef typename std::iterator_traits<RandomAccessIterator2>::difference_type Index;
-    using std::swap;
-    Diff size = std::distance(item_begin, item_end);
-    for (Diff i = 0; i < size; i++)
-    {
-        Diff current = i;
-        while (i != ind_begin[current])
-        {
-            Index next = ind_begin[current];
-            swap(item_begin[current], item_begin[next]);
-            ind_begin[current] = current;
-            current = next;
-        }
-        ind_begin[current] = current;
-    }
-}
-
-/// \fn apply_reverse_permutation ( RandomAccessIterator1 item_begin, RandomAccessIterator1 item_end, RandomAccessIterator2 ind_begin )
-/// \brief Reorder item sequence with index sequence order
-///
-/// \param item_begin    The start of the item sequence
-/// \param item_end		 One past the end of the item sequence
-/// \param ind_begin     The start of the index sequence.
-///
-/// \note Item sequence size should be equal to index size. Otherwise behavior is undefined.
-///       Complexity: O(N).
-template<typename RandomAccessIterator1, typename RandomAccessIterator2>
-void
-apply_reverse_permutation(
-        RandomAccessIterator1 item_begin,
-        RandomAccessIterator1 item_end,
-        RandomAccessIterator2 ind_begin,
-        RandomAccessIterator2 ind_end)
-{
-    typedef typename std::iterator_traits<RandomAccessIterator2>::difference_type Diff;
-    using std::swap;
-    Diff length = std::distance(item_begin, item_end);
-    for (Diff i = 0; i < length; i++)
-    {
-        while (i != ind_begin[i])
-        {
-            Diff next = ind_begin[i];
-            swap(item_begin[i], item_begin[next]);
-            swap(ind_begin[i], ind_begin[next]);
-        }
-    }
-}
-
-/// \fn apply_permutation ( Range1 item_range, Range2 ind_range )
-/// \brief Reorder item sequence with index sequence order
-///
-/// \param item_range    The item sequence
-/// \param ind_range     The index sequence
-///
-/// \note Item sequence size should be equal to index size. Otherwise behavior is undefined.
-///       Complexity: O(N).
-template<typename Range1, typename Range2>
-void
-apply_permutation(Range1& item_range, Range2& ind_range)
-{
-    apply_permutation(boost::begin(item_range), boost::end(item_range),
-                      boost::begin(ind_range), boost::end(ind_range));
-}
-
-/// \fn apply_reverse_permutation ( Range1 item_range, Range2 ind_range )
-/// \brief Reorder item sequence with index sequence order
-///
-/// \param item_range    The item sequence
-/// \param ind_range     The index sequence
-///
-/// \note Item sequence size should be equal to index size. Otherwise behavior is undefined.
-///       Complexity: O(N).
-template<typename Range1, typename Range2>
-void
-apply_reverse_permutation(Range1& item_range, Range2& ind_range)
-{
-    apply_reverse_permutation(boost::begin(item_range), boost::end(item_range),
-                              boost::begin(ind_range), boost::end(ind_range));
-}
-
-}}
-#endif //BOOST_ALGORITHM_APPLY_PERMUTATION_HPP

include/boost/algorithm/clamp.hpp

@@ -23,17 +23,16 @@
 #include <iterator>         //  For std::iterator_traits
 #include <cassert>
 
-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
-#include <boost/type_traits/type_identity.hpp> // for boost::type_identity
-#include <boost/core/enable_if.hpp>            // for boost::disable_if
+#include <boost/mpl/identity.hpp>      // for identity
+#include <boost/utility/enable_if.hpp> // for boost::disable_if
 
 namespace boost { namespace algorithm {
 
 /// \fn clamp ( T const& val, 
-///               typename boost::type_identity<T>::type const & lo, 
-///               typename boost::type_identity<T>::type const & hi, Pred p )
+///               typename boost::mpl::identity<T>::type const & lo, 
+///               typename boost::mpl::identity<T>::type const & hi, Pred p )
 /// \return the value "val" brought into the range [ lo, hi ]
 ///     using the comparison predicate p.
 ///     If p ( val, lo ) return lo.
@@ -47,9 +46,9 @@ namespace boost { namespace algorithm {
 ///                 p ( a, b ) returns a boolean.
 ///
   template<typename T, typename Pred> 
-  BOOST_CXX14_CONSTEXPR T const & clamp ( T const& val, 
-    typename boost::type_identity<T>::type const & lo, 
-    typename boost::type_identity<T>::type const & hi, Pred p )
+  T const & clamp ( T const& val, 
+    typename boost::mpl::identity<T>::type const & lo, 
+    typename boost::mpl::identity<T>::type const & hi, Pred p )
   {
 //    assert ( !p ( hi, lo ));    // Can't assert p ( lo, hi ) b/c they might be equal
     return p ( val, lo ) ? lo : p ( hi, val ) ? hi : val;
@@ -57,8 +56,8 @@ namespace boost { namespace algorithm {
 
 
 /// \fn clamp ( T const& val, 
-///               typename boost::identity<T>::type const & lo, 
-///               typename boost::identity<T>::type const & hi )
+///               typename boost::mpl::identity<T>::type const & lo, 
+///               typename boost::mpl::identity<T>::type const & hi )
 /// \return the value "val" brought into the range [ lo, hi ].
 ///     If the value is less than lo, return lo.
 ///     If the value is greater than "hi", return hi.
@@ -69,11 +68,11 @@ namespace boost { namespace algorithm {
 /// \param hi    The upper bound of the range to be clamped to
 ///
   template<typename T> 
-  BOOST_CXX14_CONSTEXPR T const& clamp ( const T& val, 
-    typename boost::type_identity<T>::type const & lo, 
-    typename boost::type_identity<T>::type const & hi )
+  T const& clamp ( const T& val, 
+    typename boost::mpl::identity<T>::type const & lo, 
+    typename boost::mpl::identity<T>::type const & hi )
   {
-    return boost::algorithm::clamp ( val, lo, hi, std::less<T>());
+    return (clamp) ( val, lo, hi, std::less<T>());
   } 
 
 /// \fn clamp_range ( InputIterator first, InputIterator last, OutputIterator out, 
@@ -88,13 +87,13 @@ namespace boost { namespace algorithm {
 /// \param hi    The upper bound of the range to be clamped to
 ///
   template<typename InputIterator, typename OutputIterator> 
-  BOOST_CXX14_CONSTEXPR OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out,
+  OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out,
     typename std::iterator_traits<InputIterator>::value_type const & lo, 
     typename std::iterator_traits<InputIterator>::value_type const & hi )
   {
   // this could also be written with bind and std::transform
     while ( first != last )
-        *out++ = boost::algorithm::clamp ( *first++, lo, hi );
+        *out++ = clamp ( *first++, lo, hi );
     return out;
   } 
 
@@ -109,12 +108,12 @@ namespace boost { namespace algorithm {
 /// \param hi    The upper bound of the range to be clamped to
 ///
   template<typename Range, typename OutputIterator> 
-  BOOST_CXX14_CONSTEXPR typename boost::disable_if_c<boost::is_same<Range, OutputIterator>::value, OutputIterator>::type
+  typename boost::disable_if_c<boost::is_same<Range, OutputIterator>::value, OutputIterator>::type
   clamp_range ( const Range &r, OutputIterator out,
     typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & lo, 
     typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & hi )
   {
-    return boost::algorithm::clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi );
+    return clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi );
   } 
 
 
@@ -134,13 +133,13 @@ namespace boost { namespace algorithm {
 
 ///
   template<typename InputIterator, typename OutputIterator, typename Pred> 
-  BOOST_CXX14_CONSTEXPR OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out,
+  OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out,
     typename std::iterator_traits<InputIterator>::value_type const & lo, 
     typename std::iterator_traits<InputIterator>::value_type const & hi, Pred p )
   {
   // this could also be written with bind and std::transform
     while ( first != last )
-        *out++ = boost::algorithm::clamp ( *first++, lo, hi, p );
+        *out++ = clamp ( *first++, lo, hi, p );
     return out;
   } 
 
@@ -161,13 +160,13 @@ namespace boost { namespace algorithm {
 //  Disable this template if the first two parameters are the same type;
 //  In that case, the user will get the two iterator version.
   template<typename Range, typename OutputIterator, typename Pred> 
-  BOOST_CXX14_CONSTEXPR typename boost::disable_if_c<boost::is_same<Range, OutputIterator>::value, OutputIterator>::type
+  typename boost::disable_if_c<boost::is_same<Range, OutputIterator>::value, OutputIterator>::type
   clamp_range ( const Range &r, OutputIterator out,
     typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & lo, 
     typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & hi,
     Pred p )
   {
-    return boost::algorithm::clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi, p );
+    return clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi, p );
   } 
 
 

include/boost/algorithm/cxx11/all_of.hpp

@@ -12,7 +12,7 @@
 #ifndef BOOST_ALGORITHM_ALL_OF_HPP
 #define BOOST_ALGORITHM_ALL_OF_HPP
 
-#include <boost/config.hpp>
+#include <algorithm>    // for std::all_of, if available
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
@@ -27,8 +27,10 @@ namespace boost { namespace algorithm {
 /// \param p     A predicate for testing the elements of the sequence
 ///
 /// \note           This function is part of the C++2011 standard library.
+///  We will use the standard one if it is available, 
+///  otherwise we have our own implementation.
 template<typename InputIterator, typename Predicate> 
-BOOST_CXX14_CONSTEXPR bool all_of ( InputIterator first, InputIterator last, Predicate p )
+bool all_of ( InputIterator first, InputIterator last, Predicate p )
 {
     for ( ; first != last; ++first )
         if ( !p(*first)) 
@@ -44,7 +46,7 @@ BOOST_CXX14_CONSTEXPR bool all_of ( InputIterator first, InputIterator last, Pre
 /// \param p    A predicate for testing the elements of the range
 ///
 template<typename Range, typename Predicate> 
-BOOST_CXX14_CONSTEXPR bool all_of ( const Range &r, Predicate p )
+bool all_of ( const Range &r, Predicate p )
 {
     return boost::algorithm::all_of ( boost::begin (r), boost::end (r), p );
 } 
@@ -58,7 +60,7 @@ BOOST_CXX14_CONSTEXPR bool all_of ( const Range &r, Predicate p )
 /// \param val   A value to compare against
 ///
 template<typename InputIterator, typename T> 
-BOOST_CXX14_CONSTEXPR bool all_of_equal ( InputIterator first, InputIterator last, const T &val )
+bool all_of_equal ( InputIterator first, InputIterator last, const T &val )
 {
     for ( ; first != last; ++first )
     if ( val != *first ) 
@@ -74,7 +76,7 @@ BOOST_CXX14_CONSTEXPR bool all_of_equal ( InputIterator first, InputIterator las
 /// \param val  A value to compare against
 ///
 template<typename Range, typename T> 
-BOOST_CXX14_CONSTEXPR bool all_of_equal ( const Range &r, const T &val ) 
+bool all_of_equal ( const Range &r, const T &val ) 
 {
     return boost::algorithm::all_of_equal ( boost::begin (r), boost::end (r), val );
 } 

include/boost/algorithm/cxx11/any_of.hpp

@@ -14,7 +14,7 @@
 #ifndef BOOST_ALGORITHM_ANY_OF_HPP
 #define BOOST_ALGORITHM_ANY_OF_HPP
 
-#include <boost/config.hpp>
+#include <algorithm>    // for std::any_of, if available
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
@@ -29,7 +29,7 @@ namespace boost { namespace algorithm {
 /// \param p     A predicate for testing the elements of the sequence
 ///
 template<typename InputIterator, typename Predicate> 
-BOOST_CXX14_CONSTEXPR bool any_of ( InputIterator first, InputIterator last, Predicate p ) 
+bool any_of ( InputIterator first, InputIterator last, Predicate p ) 
 {
     for ( ; first != last; ++first )
         if ( p(*first)) 
@@ -45,7 +45,7 @@ BOOST_CXX14_CONSTEXPR bool any_of ( InputIterator first, InputIterator last, Pre
 /// \param p    A predicate for testing the elements of the range
 ///
 template<typename Range, typename Predicate> 
-BOOST_CXX14_CONSTEXPR bool any_of ( const Range &r, Predicate p )
+bool any_of ( const Range &r, Predicate p )
 {
     return boost::algorithm::any_of (boost::begin (r), boost::end (r), p);
 } 
@@ -59,7 +59,7 @@ BOOST_CXX14_CONSTEXPR bool any_of ( const Range &r, Predicate p )
 /// \param val   A value to compare against
 ///
 template<typename InputIterator, typename V> 
-BOOST_CXX14_CONSTEXPR bool any_of_equal ( InputIterator first, InputIterator last, const V &val ) 
+bool any_of_equal ( InputIterator first, InputIterator last, const V &val ) 
 {
     for ( ; first != last; ++first )
         if ( val == *first )
@@ -75,7 +75,7 @@ BOOST_CXX14_CONSTEXPR bool any_of_equal ( InputIterator first, InputIterator las
 /// \param val   A value to compare against
 ///
 template<typename Range, typename V> 
-BOOST_CXX14_CONSTEXPR bool any_of_equal ( const Range &r, const V &val ) 
+bool any_of_equal ( const Range &r, const V &val ) 
 {
     return boost::algorithm::any_of_equal (boost::begin (r), boost::end (r), val);
 }

include/boost/algorithm/cxx11/copy_if.hpp

@@ -12,9 +12,7 @@
 #ifndef BOOST_ALGORITHM_COPY_IF_HPP
 #define BOOST_ALGORITHM_COPY_IF_HPP
 
-#include <utility>    // for std::pair, std::make_pair
-
-#include <boost/config.hpp>
+#include <algorithm>    // for std::copy_if, if available
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
@@ -30,8 +28,10 @@ namespace boost { namespace algorithm {
 /// \param result   An output iterator to write the results into
 /// \param p        A predicate for testing the elements of the range
 /// \note           This function is part of the C++2011 standard library.
+///  We will use the standard one if it is available, 
+///  otherwise we have our own implementation.
 template<typename InputIterator, typename OutputIterator, typename Predicate> 
-BOOST_CXX14_CONSTEXPR OutputIterator copy_if ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
+OutputIterator copy_if ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
 {
     for ( ; first != last; ++first )
         if (p(*first))
@@ -49,7 +49,7 @@ BOOST_CXX14_CONSTEXPR OutputIterator copy_if ( InputIterator first, InputIterato
 /// \param p        A predicate for testing the elements of the range
 ///
 template<typename Range, typename OutputIterator, typename Predicate>
-BOOST_CXX14_CONSTEXPR OutputIterator copy_if ( const Range &r, OutputIterator result, Predicate p )
+OutputIterator copy_if ( const Range &r, OutputIterator result, Predicate p )
 {
     return boost::algorithm::copy_if (boost::begin (r), boost::end(r), result, p);
 }
@@ -66,7 +66,7 @@ BOOST_CXX14_CONSTEXPR OutputIterator copy_if ( const Range &r, OutputIterator re
 /// \param p        A predicate for testing the elements of the range
 ///
 template<typename InputIterator, typename OutputIterator, typename Predicate> 
-BOOST_CXX14_CONSTEXPR std::pair<InputIterator, OutputIterator>
+std::pair<InputIterator, OutputIterator>
 copy_while ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
 {
     for ( ; first != last && p(*first); ++first )
@@ -84,7 +84,7 @@ copy_while ( InputIterator first, InputIterator last, OutputIterator result, Pre
 /// \param p        A predicate for testing the elements of the range
 ///
 template<typename Range, typename OutputIterator, typename Predicate>
-BOOST_CXX14_CONSTEXPR std::pair<typename boost::range_iterator<const Range>::type, OutputIterator> 
+std::pair<typename boost::range_iterator<const Range>::type, OutputIterator> 
 copy_while ( const Range &r, OutputIterator result, Predicate p )
 {
     return boost::algorithm::copy_while (boost::begin (r), boost::end(r), result, p);
@@ -102,7 +102,7 @@ copy_while ( const Range &r, OutputIterator result, Predicate p )
 /// \param p        A predicate for testing the elements of the range
 ///
 template<typename InputIterator, typename OutputIterator, typename Predicate> 
-BOOST_CXX14_CONSTEXPR std::pair<InputIterator, OutputIterator>
+std::pair<InputIterator, OutputIterator>
 copy_until ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
 {
     for ( ; first != last && !p(*first); ++first )
@@ -120,92 +120,12 @@ copy_until ( InputIterator first, InputIterator last, OutputIterator result, Pre
 /// \param p        A predicate for testing the elements of the range
 ///
 template<typename Range, typename OutputIterator, typename Predicate>
-BOOST_CXX14_CONSTEXPR std::pair<typename boost::range_iterator<const Range>::type, OutputIterator> 
+std::pair<typename boost::range_iterator<const Range>::type, OutputIterator> 
 copy_until ( const Range &r, OutputIterator result, Predicate p )
 {
     return boost::algorithm::copy_until (boost::begin (r), boost::end(r), result, p);
 }
 
-/// \fn copy_if_while ( InputIterator first, InputIterator last, OutputIterator result, CopyPredicate copy_pred, TerminatePred term_pred )
-/// \brief Copies all the elements from the input range that satisfy the
-/// copy predicate to the output range while the termination predicate is
-/// satisfied.
-/// \return The updated output iterator
-///
-/// \param first     The start of the input sequence
-/// \param last      One past the end of the input sequence
-/// \param result    An output iterator to write the results into
-/// \param copy_pred A predicate for testing whether to the current element
-/// \param term_pred A predicate for testing whether to end the copy operation
-template<typename InputIterator, typename OutputIterator, typename CopyPredicate, typename TerminatePred>
-BOOST_CXX14_CONSTEXPR std::pair<InputIterator, OutputIterator>
-copy_if_while ( InputIterator first, InputIterator last, OutputIterator result, CopyPredicate copy_pred, TerminatePred term_pred)
-{
-    for ( ; first != last && term_pred(*first); ++first ) {
-        if (copy_pred(*first)) {
-            *result++ = *first;
-        }
-    }
-    return std::make_pair(first, result);
-}
-
-/// \fn copy_if_while ( const Range& r, OutputIterator result, CopyPredicate copy_pred, TerminatePred term_pred )
-/// \brief Copies all the elements from the input range that satisfy the
-/// copy predicate to the output range while the termination predicate is
-/// satisfied.
-/// \return The updated output iterator
-///
-/// \param r         The input range
-/// \param result    An output iterator to write the results into
-/// \param copy_pred A predicate for testing whether to the current element
-/// \param term_pred A predicate for testing whether to end the copy operation
-template<typename Range, typename OutputIterator, typename CopyPredicate, typename TerminatePred>
-BOOST_CXX14_CONSTEXPR std::pair<typename boost::range_iterator<const Range>::type, OutputIterator>
-copy_if_while ( const Range& r, OutputIterator result, CopyPredicate copy_pred, TerminatePred term_pred)
-{
-    return boost::algorithm::copy_if_while(boost::begin(r), boost::end(r), result, copy_pred, term_pred);
-}
-
-/// \fn copy_if_until ( InputIterator first, InputIterator last, OutputIterator result, CopyPredicate copy_pred, TerminatePred term_pred )
-/// \brief Copies all the elements from the input range that satisfy the
-/// copy predicate to the output range until the termination predicate is
-/// satisfied.
-/// \return The updated output iterator
-///
-/// \param first     The start of the input sequence
-/// \param last      One past the end of the input sequence
-/// \param result    An output iterator to write the results into
-/// \param copy_pred A predicate for testing whether to the current element
-/// \param term_pred A predicate for testing whether to end the copy operation
-template<typename InputIterator, typename OutputIterator, typename CopyPredicate, typename TerminatePred>
-BOOST_CXX14_CONSTEXPR std::pair<InputIterator, OutputIterator>
-copy_if_until ( InputIterator first, InputIterator last, OutputIterator result, CopyPredicate copy_pred, TerminatePred term_pred)
-{
-    for ( ; first != last && !term_pred(*first); ++first ) {
-        if (copy_pred(*first)) {
-            *result++ = *first;
-        }
-    }
-    return std::make_pair(first, result);
-}
-
-/// \fn copy_if_until ( const Range& r, OutputIterator result, CopyPredicate copy_pred, TerminatePred term_pred )
-/// \brief Copies all the elements from the input range that satisfy the
-/// copy predicate to the output range until the termination predicate is
-/// satisfied.
-/// \return The updated output iterator
-///
-/// \param r         The input range
-/// \param result    An output iterator to write the results into
-/// \param copy_pred A predicate for testing whether to the current element
-/// \param term_pred A predicate for testing whether to end the copy operation
-template<typename Range, typename OutputIterator, typename CopyPredicate, typename TerminatePred>
-BOOST_CXX14_CONSTEXPR std::pair<typename boost::range_iterator<const Range>::type, OutputIterator>
-copy_if_until ( const Range& r, OutputIterator result, CopyPredicate copy_pred, TerminatePred term_pred)
-{
-    return boost::algorithm::copy_if_until(boost::begin(r), boost::end(r), result, copy_pred, term_pred);
-}
-
 }} // namespace boost and algorithm
 
 #endif  // BOOST_ALGORITHM_COPY_IF_HPP

include/boost/algorithm/cxx11/copy_n.hpp

@@ -12,7 +12,7 @@
 #ifndef BOOST_ALGORITHM_COPY_N_HPP
 #define BOOST_ALGORITHM_COPY_N_HPP
 
-#include <boost/config.hpp>
+#include <algorithm>    // for std::copy_n, if available
 
 namespace boost { namespace algorithm {
 
@@ -25,8 +25,10 @@ namespace boost { namespace algorithm {
 /// \param n        The number of elements to copy
 /// \param result   An output iterator to write the results into
 /// \note           This function is part of the C++2011 standard library.
+///  We will use the standard one if it is available, 
+///     otherwise we have our own implementation.
 template <typename InputIterator, typename Size, typename OutputIterator>
-BOOST_CXX14_CONSTEXPR OutputIterator copy_n ( InputIterator first, Size n, OutputIterator result )
+OutputIterator copy_n ( InputIterator first, Size n, OutputIterator result )
 {
     for ( ; n > 0; --n, ++first, ++result )
         *result = *first;

include/boost/algorithm/cxx11/find_if_not.hpp

@@ -12,7 +12,8 @@
 #ifndef BOOST_ALGORITHM_FIND_IF_NOT_HPP
 #define BOOST_ALGORITHM_FIND_IF_NOT_HPP
 
-#include <boost/config.hpp>
+#include <algorithm>    // for std::find_if_not, if it exists
+
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
@@ -26,8 +27,10 @@ namespace boost { namespace algorithm {
 /// \param last     One past the end of the input sequence
 /// \param p        A predicate for testing the elements of the range
 /// \note           This function is part of the C++2011 standard library.
+///  We will use the standard one if it is available, 
+///  otherwise we have our own implementation.
 template<typename InputIterator, typename Predicate> 
-BOOST_CXX14_CONSTEXPR InputIterator find_if_not ( InputIterator first, InputIterator last, Predicate p )
+InputIterator find_if_not ( InputIterator first, InputIterator last, Predicate p )
 {
     for ( ; first != last; ++first )
         if ( !p(*first))
@@ -43,7 +46,7 @@ BOOST_CXX14_CONSTEXPR InputIterator find_if_not ( InputIterator first, InputIter
 /// \param p        A predicate for testing the elements of the range
 ///
 template<typename Range, typename Predicate>
-BOOST_CXX14_CONSTEXPR typename boost::range_iterator<const Range>::type find_if_not ( const Range &r, Predicate p )
+typename boost::range_iterator<const Range>::type find_if_not ( const Range &r, Predicate p )
 {
     return boost::algorithm::find_if_not (boost::begin (r), boost::end(r), p);
 }

include/boost/algorithm/cxx11/iota.hpp

@@ -12,7 +12,8 @@
 #ifndef BOOST_ALGORITHM_IOTA_HPP
 #define BOOST_ALGORITHM_IOTA_HPP
 
-#include <boost/config.hpp>
+#include <numeric>
+
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
@@ -25,8 +26,10 @@ namespace boost { namespace algorithm {
 /// \param last     One past the end of the input sequence
 /// \param value    The initial value of the sequence to be generated
 /// \note           This function is part of the C++2011 standard library.
+///  We will use the standard one if it is available, 
+///  otherwise we have our own implementation.
 template <typename ForwardIterator, typename T>
-BOOST_CXX14_CONSTEXPR void iota ( ForwardIterator first, ForwardIterator last, T value )
+void iota ( ForwardIterator first, ForwardIterator last, T value )
 {
     for ( ; first != last; ++first, ++value )
         *first = value;
@@ -39,7 +42,7 @@ BOOST_CXX14_CONSTEXPR void iota ( ForwardIterator first, ForwardIterator last, T
 /// \param value    The initial value of the sequence to be generated
 ///
 template <typename Range, typename T>
-BOOST_CXX14_CONSTEXPR void iota ( Range &r, T value )
+void iota ( Range &r, T value )
 {
     boost::algorithm::iota (boost::begin(r), boost::end(r), value);
 }
@@ -53,7 +56,7 @@ BOOST_CXX14_CONSTEXPR void iota ( Range &r, T value )
 /// \param n        The number of items to write
 ///
 template <typename OutputIterator, typename T>
-BOOST_CXX14_CONSTEXPR OutputIterator iota_n ( OutputIterator out, T value, std::size_t n )
+OutputIterator iota_n ( OutputIterator out, T value, std::size_t n )
 {
     for ( ; n > 0; --n, ++value )
         *out++ = value;

include/boost/algorithm/cxx11/is_partitioned.hpp

@@ -12,22 +12,24 @@
 #ifndef BOOST_ALGORITHM_IS_PARTITIONED_HPP
 #define BOOST_ALGORITHM_IS_PARTITIONED_HPP
 
-#include <boost/config.hpp>
+#include <algorithm>    // for std::is_partitioned, if available
+
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
 namespace boost { namespace algorithm {
 
 /// \fn is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p )
-/// \brief Tests to see if a sequence is partitioned according to a predicate. 
-///	   In other words, all the items in the sequence that satisfy the predicate are at the beginning of the sequence.
+/// \brief Tests to see if a sequence is partitioned according to a predicate
 /// 
 /// \param first    The start of the input sequence
 /// \param last     One past the end of the input sequence
 /// \param p        The predicate to test the values with
 /// \note           This function is part of the C++2011 standard library.
+///  We will use the standard one if it is available, 
+///  otherwise we have our own implementation.
 template <typename InputIterator, typename UnaryPredicate>
-BOOST_CXX14_CONSTEXPR bool is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p )
+bool is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p )
 {
 //  Run through the part that satisfy the predicate
     for ( ; first != last; ++first )
@@ -41,14 +43,13 @@ BOOST_CXX14_CONSTEXPR bool is_partitioned ( InputIterator first, InputIterator l
 }
 
 /// \fn is_partitioned ( const Range &r, UnaryPredicate p )
-/// \brief Tests to see if a sequence is partitioned according to a predicate. 
-///	   In other words, all the items in the sequence that satisfy the predicate are at the beginning of the sequence.
+/// \brief Generates an increasing sequence of values, and stores them in the input Range.
 /// 
 /// \param r        The input range
 /// \param p        The predicate to test the values with
 ///
 template <typename Range, typename UnaryPredicate>
-BOOST_CXX14_CONSTEXPR bool is_partitioned ( const Range &r, UnaryPredicate p )
+bool is_partitioned ( const Range &r, UnaryPredicate p )
 {
     return boost::algorithm::is_partitioned (boost::begin(r), boost::end(r), p);
 }

include/boost/algorithm/cxx11/is_permutation.hpp

@@ -12,15 +12,14 @@
 #ifndef BOOST_ALGORITHM_IS_PERMUTATION11_HPP
 #define BOOST_ALGORITHM_IS_PERMUTATION11_HPP
 
-#include <algorithm>    // for std::find_if, count_if, mismatch
-#include <utility>      // for std::pair
+#include <algorithm>    // for std::less, tie, mismatch and is_permutation (if available)
+#include <utility>      // for std::make_pair
 #include <functional>   // for std::equal_to
 #include <iterator>
 
-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
-#include <boost/core/enable_if.hpp>
+#include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
 
 namespace boost { namespace algorithm {
@@ -109,6 +108,8 @@ namespace detail {
 /// \param p        The predicate to compare elements with
 ///
 /// \note           This function is part of the C++2011 standard library.
+///  We will use the standard one if it is available,
+///     otherwise we have our own implementation.
 template< class ForwardIterator1, class ForwardIterator2, class BinaryPredicate >
 bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1,
                       ForwardIterator2 first2, BinaryPredicate p )
@@ -134,6 +135,8 @@ bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1,
 /// \param last2    One past the end of the input sequence
 /// \param first2   The start of the second sequence
 /// \note           This function is part of the C++2011 standard library.
+///  We will use the standard one if it is available,
+///     otherwise we have our own implementation.
 template< class ForwardIterator1, class ForwardIterator2 >
 bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2 )
 {

include/boost/algorithm/cxx11/is_sorted.hpp

@@ -13,16 +13,16 @@
 #ifndef BOOST_ALGORITHM_ORDERED_HPP
 #define BOOST_ALGORITHM_ORDERED_HPP
 
+#include <algorithm>
 #include <functional>
 #include <iterator>
 
-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
-#include <boost/core/enable_if.hpp>
+#include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/type_identity.hpp> // for boost::type_identity
+#include <boost/mpl/identity.hpp>
 
 namespace boost { namespace algorithm {
 
@@ -35,7 +35,7 @@ namespace boost { namespace algorithm {
 /// \param p     A binary predicate that returns true if two elements are ordered.
 ///
     template <typename ForwardIterator, typename Pred>
-    BOOST_CXX14_CONSTEXPR ForwardIterator is_sorted_until ( ForwardIterator first, ForwardIterator last, Pred p )
+    ForwardIterator is_sorted_until ( ForwardIterator first, ForwardIterator last, Pred p )
     {
         if ( first == last ) return last;  // the empty sequence is ordered
         ForwardIterator next = first;
@@ -55,7 +55,7 @@ namespace boost { namespace algorithm {
 /// \param last  One past the end of the sequence
 ///
     template <typename ForwardIterator>
-    BOOST_CXX14_CONSTEXPR ForwardIterator is_sorted_until ( ForwardIterator first, ForwardIterator last )
+    ForwardIterator is_sorted_until ( ForwardIterator first, ForwardIterator last )
     {
         typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
         return boost::algorithm::is_sorted_until ( first, last, std::less<value_type>());
@@ -70,7 +70,7 @@ namespace boost { namespace algorithm {
 /// \param p     A binary predicate that returns true if two elements are ordered.
 ///
     template <typename ForwardIterator, typename Pred>
-    BOOST_CXX14_CONSTEXPR bool is_sorted ( ForwardIterator first, ForwardIterator last, Pred p )
+    bool is_sorted ( ForwardIterator first, ForwardIterator last, Pred p )
     {
         return boost::algorithm::is_sorted_until (first, last, p) == last;
     }
@@ -82,7 +82,7 @@ namespace boost { namespace algorithm {
 /// \param last  One past the end of the sequence
 ///
     template <typename ForwardIterator>
-    BOOST_CXX14_CONSTEXPR bool is_sorted ( ForwardIterator first, ForwardIterator last )
+    bool is_sorted ( ForwardIterator first, ForwardIterator last )
     {
         return boost::algorithm::is_sorted_until (first, last) == last;
     }
@@ -99,7 +99,7 @@ namespace boost { namespace algorithm {
 /// \param p     A binary predicate that returns true if two elements are ordered.
 ///
     template <typename R, typename Pred>
-    BOOST_CXX14_CONSTEXPR typename boost::lazy_disable_if_c<
+    typename boost::lazy_disable_if_c<
         boost::is_same<R, Pred>::value, 
         typename boost::range_iterator<const R> 
     >::type is_sorted_until ( const R &range, Pred p )
@@ -114,7 +114,7 @@ namespace boost { namespace algorithm {
 /// \param range The range to be tested.
 ///
     template <typename R>
-    BOOST_CXX14_CONSTEXPR typename boost::range_iterator<const R>::type is_sorted_until ( const R &range )
+    typename boost::range_iterator<const R>::type is_sorted_until ( const R &range )
     {
         return boost::algorithm::is_sorted_until ( boost::begin ( range ), boost::end ( range ));
     }
@@ -127,7 +127,7 @@ namespace boost { namespace algorithm {
 /// \param p     A binary predicate that returns true if two elements are ordered.
 ///
     template <typename R, typename Pred>
-    BOOST_CXX14_CONSTEXPR typename boost::lazy_disable_if_c< boost::is_same<R, Pred>::value, boost::type_identity<bool> >::type
+    typename boost::lazy_disable_if_c< boost::is_same<R, Pred>::value, boost::mpl::identity<bool> >::type
     is_sorted ( const R &range, Pred p )
     {
         return boost::algorithm::is_sorted ( boost::begin ( range ), boost::end ( range ), p );
@@ -140,7 +140,7 @@ namespace boost { namespace algorithm {
 /// \param range The range to be tested.
 ///
     template <typename R>
-    BOOST_CXX14_CONSTEXPR bool is_sorted ( const R &range )
+    bool is_sorted ( const R &range )
     {
         return boost::algorithm::is_sorted ( boost::begin ( range ), boost::end ( range ));
     }
@@ -160,7 +160,7 @@ namespace boost { namespace algorithm {
 /// \note This function will return true for sequences that contain items that compare
 ///     equal. If that is not what you intended, you should use is_strictly_increasing instead.
     template <typename ForwardIterator>
-    BOOST_CXX14_CONSTEXPR bool is_increasing ( ForwardIterator first, ForwardIterator last )
+    bool is_increasing ( ForwardIterator first, ForwardIterator last )
     {
         typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
         return boost::algorithm::is_sorted (first, last, std::less<value_type>());
@@ -176,7 +176,7 @@ namespace boost { namespace algorithm {
 /// \note This function will return true for sequences that contain items that compare
 ///     equal. If that is not what you intended, you should use is_strictly_increasing instead.
     template <typename R>
-    BOOST_CXX14_CONSTEXPR bool is_increasing ( const R &range )
+    bool is_increasing ( const R &range )
     {
         return is_increasing ( boost::begin ( range ), boost::end ( range ));
     }
@@ -193,7 +193,7 @@ namespace boost { namespace algorithm {
 /// \note This function will return true for sequences that contain items that compare
 ///     equal. If that is not what you intended, you should use is_strictly_decreasing instead.
     template <typename ForwardIterator>
-    BOOST_CXX14_CONSTEXPR bool is_decreasing ( ForwardIterator first, ForwardIterator last )
+    bool is_decreasing ( ForwardIterator first, ForwardIterator last )
     {
         typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
         return boost::algorithm::is_sorted (first, last, std::greater<value_type>());
@@ -208,7 +208,7 @@ namespace boost { namespace algorithm {
 /// \note This function will return true for sequences that contain items that compare
 ///     equal. If that is not what you intended, you should use is_strictly_decreasing instead.
     template <typename R>
-    BOOST_CXX14_CONSTEXPR bool is_decreasing ( const R &range )
+    bool is_decreasing ( const R &range )
     {
         return is_decreasing ( boost::begin ( range ), boost::end ( range ));
     }
@@ -225,7 +225,7 @@ namespace boost { namespace algorithm {
 /// \note This function will return false for sequences that contain items that compare
 ///     equal. If that is not what you intended, you should use is_increasing instead.
     template <typename ForwardIterator>
-    BOOST_CXX14_CONSTEXPR bool is_strictly_increasing ( ForwardIterator first, ForwardIterator last )
+    bool is_strictly_increasing ( ForwardIterator first, ForwardIterator last )
     {
         typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
         return boost::algorithm::is_sorted (first, last, std::less_equal<value_type>());
@@ -240,7 +240,7 @@ namespace boost { namespace algorithm {
 /// \note This function will return false for sequences that contain items that compare
 ///     equal. If that is not what you intended, you should use is_increasing instead.
     template <typename R>
-    BOOST_CXX14_CONSTEXPR bool is_strictly_increasing ( const R &range )
+    bool is_strictly_increasing ( const R &range )
     {
         return is_strictly_increasing ( boost::begin ( range ), boost::end ( range ));
     }
@@ -256,7 +256,7 @@ namespace boost { namespace algorithm {
 /// \note This function will return false for sequences that contain items that compare
 ///     equal. If that is not what you intended, you should use is_decreasing instead.
     template <typename ForwardIterator>
-    BOOST_CXX14_CONSTEXPR bool is_strictly_decreasing ( ForwardIterator first, ForwardIterator last )
+    bool is_strictly_decreasing ( ForwardIterator first, ForwardIterator last )
     {
         typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
         return boost::algorithm::is_sorted (first, last, std::greater_equal<value_type>());
@@ -271,7 +271,7 @@ namespace boost { namespace algorithm {
 /// \note This function will return false for sequences that contain items that compare
 ///     equal. If that is not what you intended, you should use is_decreasing instead.
     template <typename R>
-    BOOST_CXX14_CONSTEXPR bool is_strictly_decreasing ( const R &range )
+    bool is_strictly_decreasing ( const R &range )
     {
         return is_strictly_decreasing ( boost::begin ( range ), boost::end ( range ));
     }

include/boost/algorithm/cxx11/none_of.hpp

@@ -12,7 +12,7 @@
 #ifndef BOOST_ALGORITHM_NONE_OF_HPP
 #define BOOST_ALGORITHM_NONE_OF_HPP
 
-#include <boost/config.hpp>
+#include <algorithm>    // for std::none_of, if available
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
@@ -27,11 +27,11 @@ namespace boost { namespace algorithm {
 /// \param p     A predicate for testing the elements of the sequence
 ///
 template<typename InputIterator, typename Predicate> 
-BOOST_CXX14_CONSTEXPR bool none_of ( InputIterator first, InputIterator last, Predicate p )
+bool none_of ( InputIterator first, InputIterator last, Predicate p )
 {
-    for ( ; first != last; ++first )
-        if ( p(*first)) 
-            return false;
+for ( ; first != last; ++first )
+    if ( p(*first)) 
+        return false;
     return true;
 } 
 
@@ -43,7 +43,7 @@ BOOST_CXX14_CONSTEXPR bool none_of ( InputIterator first, InputIterator last, Pr
 /// \param p     A predicate for testing the elements of the range
 ///
 template<typename Range, typename Predicate> 
-BOOST_CXX14_CONSTEXPR bool none_of ( const Range &r, Predicate p )
+bool none_of ( const Range &r, Predicate p )
 {
     return boost::algorithm::none_of (boost::begin (r), boost::end (r), p );
 } 
@@ -57,7 +57,7 @@ BOOST_CXX14_CONSTEXPR bool none_of ( const Range &r, Predicate p )
 /// \param val   A value to compare against
 ///
 template<typename InputIterator, typename V> 
-BOOST_CXX14_CONSTEXPR bool none_of_equal ( InputIterator first, InputIterator last, const V &val ) 
+bool none_of_equal ( InputIterator first, InputIterator last, const V &val ) 
 {
     for ( ; first != last; ++first )
         if ( val == *first )
@@ -73,7 +73,7 @@ BOOST_CXX14_CONSTEXPR bool none_of_equal ( InputIterator first, InputIterator la
 /// \param val   A value to compare against
 ///
 template<typename Range, typename V> 
-BOOST_CXX14_CONSTEXPR bool none_of_equal ( const Range &r, const V & val ) 
+bool none_of_equal ( const Range &r, const V & val ) 
 {
     return boost::algorithm::none_of_equal (boost::begin (r), boost::end (r), val);
 } 

include/boost/algorithm/cxx11/one_of.hpp

@@ -12,12 +12,11 @@
 #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 <algorithm>            // for std::find and std::find_if
 #include <boost/algorithm/cxx11/none_of.hpp>
 
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
 
 namespace boost { namespace algorithm {
 
@@ -29,16 +28,12 @@ namespace boost { namespace algorithm {
 /// \param p     A predicate for testing the elements of the sequence
 ///
 template<typename InputIterator, typename Predicate> 
-BOOST_CXX14_CONSTEXPR bool one_of ( InputIterator first, InputIterator last, Predicate p )
+bool one_of ( InputIterator first, InputIterator last, Predicate p )
 {
-//  find_if
-    for (; first != last; ++first)
-        if (p(*first))
-            break;
-
-    if (first == last)
+    InputIterator i = std::find_if (first, last, p);
+    if (i == last)
         return false;    // Didn't occur at all
-    return boost::algorithm::none_of (++first, last, p);
+    return boost::algorithm::none_of (++i, last, p);
 }
 
 /// \fn one_of ( const Range &r, Predicate p )
@@ -48,7 +43,7 @@ BOOST_CXX14_CONSTEXPR bool one_of ( InputIterator first, InputIterator last, Pre
 /// \param p    A predicate for testing the elements of the range
 ///
 template<typename Range, typename Predicate> 
-BOOST_CXX14_CONSTEXPR bool one_of ( const Range &r, Predicate p )
+bool one_of ( const Range &r, Predicate p ) 
 {
     return boost::algorithm::one_of ( boost::begin (r), boost::end (r), p );
 }
@@ -62,16 +57,12 @@ BOOST_CXX14_CONSTEXPR bool one_of ( const Range &r, Predicate p )
 /// \param val      A value to compare against
 ///
 template<typename InputIterator, typename V> 
-BOOST_CXX14_CONSTEXPR bool one_of_equal ( InputIterator first, InputIterator last, const V &val )
+bool one_of_equal ( InputIterator first, InputIterator last, const V &val )
 {
-//  find
-    for (; first != last; ++first)
-        if (*first == val)
-            break;
-
-    if (first == last)
+    InputIterator i = std::find (first, last, val); // find first occurrence of 'val'
+    if (i == last)
         return false;                    // Didn't occur at all
-    return boost::algorithm::none_of_equal (++first, last, val);
+    return boost::algorithm::none_of_equal (++i, last, val);
 }
 
 /// \fn one_of_equal ( const Range &r, const V &val )
@@ -81,7 +72,7 @@ BOOST_CXX14_CONSTEXPR bool one_of_equal ( InputIterator first, InputIterator las
 /// \param val  A value to compare against
 ///
 template<typename Range, typename V> 
-BOOST_CXX14_CONSTEXPR bool one_of_equal ( const Range &r, const V &val )
+bool one_of_equal ( const Range &r, const V &val )
 {
     return boost::algorithm::one_of_equal ( boost::begin (r), boost::end (r), val );
 } 

include/boost/algorithm/cxx11/partition_copy.hpp

@@ -12,9 +12,9 @@
 #ifndef BOOST_ALGORITHM_PARTITION_COPY_HPP
 #define BOOST_ALGORITHM_PARTITION_COPY_HPP
 
-#include <utility>  // for std::pair
+#include <algorithm>    // for std::partition_copy, if available
+#include <utility>  // for make_pair
 
-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
@@ -34,9 +34,11 @@ namespace boost { namespace algorithm {
 /// \param p         A predicate for dividing the elements of the input sequence.
 ///
 /// \note            This function is part of the C++2011 standard library.
+///  We will use the standard one if it is available, 
+///  otherwise we have our own implementation.
 template <typename InputIterator, 
         typename OutputIterator1, typename OutputIterator2, typename UnaryPredicate>
-BOOST_CXX14_CONSTEXPR std::pair<OutputIterator1, OutputIterator2>
+std::pair<OutputIterator1, OutputIterator2>
 partition_copy ( InputIterator first, InputIterator last,
         OutputIterator1 out_true, OutputIterator2 out_false, UnaryPredicate p )
 {
@@ -58,7 +60,7 @@ partition_copy ( InputIterator first, InputIterator last,
 ///
 template <typename Range, typename OutputIterator1, typename OutputIterator2, 
             typename UnaryPredicate>
-BOOST_CXX14_CONSTEXPR std::pair<OutputIterator1, OutputIterator2>
+std::pair<OutputIterator1, OutputIterator2>
 partition_copy ( const Range &r, OutputIterator1 out_true, OutputIterator2 out_false, 
                                 UnaryPredicate p )
 {

include/boost/algorithm/cxx11/partition_point.hpp

@@ -12,9 +12,8 @@
 #ifndef BOOST_ALGORITHM_PARTITION_POINT_HPP
 #define BOOST_ALGORITHM_PARTITION_POINT_HPP
 
-#include <iterator>    // for std::distance, advance
+#include <algorithm>    // for std::partition_point, if available
 
-#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
@@ -28,6 +27,8 @@ namespace boost { namespace algorithm {
 /// \param last     One past the end of the input sequence
 /// \param p        The predicate to test the values with
 /// \note           This function is part of the C++2011 standard library.
+///  We will use the standard one if it is available, 
+///  otherwise we have our own implementation.
 template <typename ForwardIterator, typename Predicate>
 ForwardIterator partition_point ( ForwardIterator first, ForwardIterator last, Predicate p )
 {

include/boost/algorithm/cxx14/equal.hpp

@@ -12,21 +12,19 @@
 #ifndef BOOST_ALGORITHM_EQUAL_HPP
 #define BOOST_ALGORITHM_EQUAL_HPP
 
-#include <iterator>
-
-#include <boost/config.hpp>
+#include <algorithm>    // for std::equal
+#include <functional>   // for std::equal_to
 
 namespace boost { namespace algorithm {
 
 namespace detail {
 
     template <class T1, class T2>
-    struct eq {
-        BOOST_CONSTEXPR bool operator () ( const T1& v1, const T2& v2 ) const { return v1 == v2 ;}
+    struct eq : public std::binary_function<T1, T2, bool> {
+        bool operator () ( const T1& v1, const T2& v2 ) const { return v1 == v2 ;}
         };
     
     template <class RandomAccessIterator1, class RandomAccessIterator2, class BinaryPredicate>
-    BOOST_CXX14_CONSTEXPR
     bool equal ( RandomAccessIterator1 first1, RandomAccessIterator1 last1, 
                  RandomAccessIterator2 first2, RandomAccessIterator2 last2, BinaryPredicate pred,
                  std::random_access_iterator_tag, std::random_access_iterator_tag )
@@ -34,16 +32,11 @@ namespace detail {
     //  Random-access iterators let is check the sizes in constant time
         if ( std::distance ( first1, last1 ) != std::distance ( first2, last2 ))
             return false;
-
-    //  std::equal
-        for (; first1 != last1; ++first1, ++first2)
-            if (!pred(*first1, *first2))
-                return false;
-        return true;
+    // If we know that the sequences are the same size, the original version is fine
+        return std::equal ( first1, last1, first2, pred );
     }
 
     template <class InputIterator1, class InputIterator2, class BinaryPredicate>
-    BOOST_CXX14_CONSTEXPR
     bool equal ( InputIterator1 first1, InputIterator1 last1, 
                  InputIterator2 first2, InputIterator2 last2, BinaryPredicate pred,
                  std::input_iterator_tag, std::input_iterator_tag )
@@ -67,7 +60,6 @@ namespace detail {
 /// \param last2     One past the end of the second range.
 /// \param pred      A predicate for comparing the elements of the ranges
 template <class InputIterator1, class InputIterator2, class BinaryPredicate>
-BOOST_CXX14_CONSTEXPR
 bool equal ( InputIterator1 first1, InputIterator1 last1, 
              InputIterator2 first2, InputIterator2 last2, BinaryPredicate pred )
 {
@@ -86,7 +78,6 @@ bool equal ( InputIterator1 first1, InputIterator1 last1,
 /// \param first2    The start of the second range.
 /// \param last2     One past the end of the second range.
 template <class InputIterator1, class InputIterator2>
-BOOST_CXX14_CONSTEXPR
 bool equal ( InputIterator1 first1, InputIterator1 last1, 
              InputIterator2 first2, InputIterator2 last2 )
 {

include/boost/algorithm/cxx14/is_permutation.hpp

@@ -12,11 +12,11 @@
 #ifndef BOOST_ALGORITHM_IS_PERMUTATION14_HPP
 #define BOOST_ALGORITHM_IS_PERMUTATION14_HPP
 
-#include <utility>      // for std::pair
+#include <algorithm>    // for std::less, tie, mismatch and is_permutation (if available)
+#include <utility>      // for std::make_pair
 #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>
 
@@ -31,6 +31,8 @@ namespace boost { namespace algorithm {
 /// \param first2   The start of the second sequence
 /// \param last1    One past the end of the second sequence
 /// \note           This function is part of the C++2014 standard library.
+///  We will use the standard one if it is available,
+///     otherwise we have our own implementation.
 template< class ForwardIterator1, class ForwardIterator2 >
 bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1, 
                       ForwardIterator2 first2, ForwardIterator2 last2 )
@@ -60,6 +62,8 @@ bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1,
 /// \param pred     The predicate to compare elements with
 ///
 /// \note           This function is part of the C++2014 standard library.
+///  We will use the standard one if it is available,
+///     otherwise we have our own implementation.
 template< class ForwardIterator1, class ForwardIterator2, class BinaryPredicate >
 bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1,
                       ForwardIterator2 first2, ForwardIterator2 last2, 

include/boost/algorithm/cxx14/mismatch.hpp

@@ -2,7 +2,7 @@
    Copyright (c) Marshall Clow 2008-2012.
 
    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)
 */
 
 /// \file  mismatch.hpp
@@ -12,10 +12,9 @@
 #ifndef BOOST_ALGORITHM_MISMATCH_HPP
 #define BOOST_ALGORITHM_MISMATCH_HPP
 
+#include <algorithm>    // for std::mismatch
 #include <utility>      // for std::pair
 
-#include <boost/config.hpp>
-
 namespace boost { namespace algorithm {
 
 /// \fn mismatch ( InputIterator1 first1, InputIterator1 last1, 
@@ -29,7 +28,7 @@ namespace boost { namespace algorithm {
 /// \param last2     One past the end of the second range.
 /// \param pred      A predicate for comparing the elements of the ranges
 template <class InputIterator1, class InputIterator2, class BinaryPredicate>
-BOOST_CXX14_CONSTEXPR std::pair<InputIterator1, InputIterator2> mismatch (
+std::pair<InputIterator1, InputIterator2> mismatch (
                     InputIterator1 first1, InputIterator1 last1,
                     InputIterator2 first2, InputIterator2 last2,
                     BinaryPredicate pred )
@@ -49,7 +48,7 @@ BOOST_CXX14_CONSTEXPR std::pair<InputIterator1, InputIterator2> mismatch (
 /// \param first2    The start of the second range.
 /// \param last2     One past the end of the second range.
 template <class InputIterator1, class InputIterator2>
-BOOST_CXX14_CONSTEXPR std::pair<InputIterator1, InputIterator2> mismatch (
+std::pair<InputIterator1, InputIterator2> mismatch (
                     InputIterator1 first1, InputIterator1 last1,
                     InputIterator2 first2, InputIterator2 last2 )
 {

include/boost/algorithm/cxx17/exclusive_scan.hpp

@@ -1,53 +0,0 @@
-/*
-   Copyright (c) Marshall Clow 2017.
-
-   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  exclusive_scan.hpp
-/// \brief ???
-/// \author Marshall Clow
-
-#ifndef BOOST_ALGORITHM_EXCLUSIVE_SCAN_HPP
-#define BOOST_ALGORITHM_EXCLUSIVE_SCAN_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>
-
-namespace boost { namespace algorithm {
-
-template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
-OutputIterator exclusive_scan(InputIterator first, InputIterator last,
-                              OutputIterator result, T init, BinaryOperation bOp)
-{
-    if (first != last)
-    {
-        T saved = init;
-        do
-        {
-            init = bOp(init, *first);
-            *result = saved;
-            saved = init;
-            ++result;
-        } while (++first != last);
-    }
-    return result;
-}
-
-template<class InputIterator, class OutputIterator, class T>
-OutputIterator exclusive_scan(InputIterator first, InputIterator last,
-                              OutputIterator result, T init)
-{
-	typedef typename std::iterator_traits<InputIterator>::value_type VT;
-    return boost::algorithm::exclusive_scan(first, last, result, init, std::plus<VT>());
-}
-
-}} // namespace boost and algorithm
-
-#endif // BOOST_ALGORITHM_EXCLUSIVE_SCAN_HPP

include/boost/algorithm/cxx17/for_each_n.hpp

@@ -1,39 +0,0 @@
-/*
-   Copyright (c) Marshall Clow 2017.
-
-   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  for_each_n.hpp
-/// \brief Apply a functor to the elements of a sequence
-/// \author Marshall Clow
-
-#ifndef BOOST_ALGORITHM_FOR_EACH_N_HPP
-#define BOOST_ALGORITHM_FOR_EACH_N_HPP
-
-#include <utility>      // for std::pair
-
-#include <boost/config.hpp>
-
-namespace boost { namespace algorithm {
-
-/// \fn for_each_n(InputIterator first, Size n, Function f);
-/// \return first + n
-///
-/// \param first    The start of the first range.
-/// \param n        One past the end of the first range.
-/// \param f        A functor to apply to the elements of the sequence
-/// \note           If f returns a result, the result is ignored.
-template<class InputIterator, class Size, class Function>
-InputIterator for_each_n(InputIterator first, Size n, Function f)
-{
-    for ( ; n > 0; --n, ++first )
-        f(*first);
-
-    return first;
-}
-
-}} // namespace boost and algorithm
-
-#endif // BOOST_ALGORITHM_FOR_EACH_N_HPP

include/boost/algorithm/cxx17/inclusive_scan.hpp

@@ -1,61 +0,0 @@
-/*
-   Copyright (c) Marshall Clow 2017.
-
-   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  transform_reduce.hpp
-/// \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
-
-#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>
-
-namespace boost { namespace algorithm {
-
-template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
-OutputIterator inclusive_scan(InputIterator first, InputIterator last,
-                              OutputIterator result, BinaryOperation bOp, T init)
-{
-    for (; first != last; ++first, (void) ++result) {
-        init = bOp(init, *first);
-        *result = init;
-        }
-    return result;
-}
-
-
-template<class InputIterator, class OutputIterator, class BinaryOperation>
-OutputIterator inclusive_scan(InputIterator first, InputIterator last,
-                              OutputIterator result, BinaryOperation bOp)
-{
-    if (first != last) {
-        typename std::iterator_traits<InputIterator>::value_type init = *first;
-        *result++ = init;
-        if (++first != last)
-            return boost::algorithm::inclusive_scan(first, last, result, bOp, init);
-        }
-
-    return result;
-}
-
-template<class InputIterator, class OutputIterator>
-OutputIterator inclusive_scan(InputIterator first, InputIterator last,
-                   OutputIterator result)
-{
-    typedef typename std::iterator_traits<InputIterator>::value_type VT;
-    return boost::algorithm::inclusive_scan(first, last, result, std::plus<VT>());
-}
-
-}} // namespace boost and algorithm
-
-#endif // BOOST_ALGORITHM_INCLUSIVE_SCAN_HPP

include/boost/algorithm/cxx17/reduce.hpp

@@ -1,73 +0,0 @@
-/*
-   Copyright (c) Marshall Clow 2017.
-
-   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  reduce.hpp
-/// \brief Combine the elements of a sequence into a single value
-/// \author Marshall Clow
-
-#ifndef BOOST_ALGORITHM_REDUCE_HPP
-#define BOOST_ALGORITHM_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>
-
-namespace boost { namespace algorithm {
-
-template<class InputIterator, class T, class BinaryOperation>
-T reduce(InputIterator first, InputIterator last, T init, BinaryOperation bOp)
-{
-    ;
-    for (; first != last; ++first)
-        init = bOp(init, *first);
-    return init;
-}
-
-template<class InputIterator, class T>
-T reduce(InputIterator first, InputIterator last, T init)
-{
-	typedef typename std::iterator_traits<InputIterator>::value_type VT;
-    return boost::algorithm::reduce(first, last, init, std::plus<VT>());
-}
-
-template<class InputIterator>
-typename std::iterator_traits<InputIterator>::value_type
-reduce(InputIterator first, InputIterator last)
-{
-    return boost::algorithm::reduce(first, last,
-       typename std::iterator_traits<InputIterator>::value_type());
-}
-
-template<class Range>
-typename boost::range_value<Range>::type
-reduce(const Range &r)
-{
-    return boost::algorithm::reduce(boost::begin(r), boost::end(r));
-}
-
-//	Not sure that this won't be ambiguous (1)
-template<class Range, class T>
-T reduce(const Range &r, T init)
-{
-    return boost::algorithm::reduce(boost::begin (r), boost::end (r), init);
-}
-
-
-//	Not sure that this won't be ambiguous (2)
-template<class Range, class T, class BinaryOperation>
-T reduce(const Range &r, T init, BinaryOperation bOp)
-{
-    return boost::algorithm::reduce(boost::begin(r), boost::end(r), init, bOp);
-}
-
-}} // namespace boost and algorithm
-
-#endif // BOOST_ALGORITHM_REDUCE_HPP

include/boost/algorithm/cxx17/transform_exclusive_scan.hpp

@@ -1,62 +0,0 @@
-/*
-   Copyright (c) Marshall Clow 2017.
-
-   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  transform_exclusive_scan.hpp
-/// \brief ????
-/// \author Marshall Clow
-
-#ifndef BOOST_ALGORITHM_TRANSFORM_EXCLUSIVE_SCAN_HPP
-#define BOOST_ALGORITHM_TRANSFORM_EXCLUSIVE_SCAN_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>
-
-namespace boost { namespace algorithm {
-
-/// \fn transform_exclusive_scan ( InputIterator first, InputIterator last, OutputIterator result, BinaryOperation bOp, UnaryOperation uOp, T init )
-/// \brief Transforms elements from the input range with uOp and then combines
-/// those transformed elements with bOp such that the n-1th element and the nth
-/// element are combined. Exclusivity means that the nth element is not
-/// included in the nth combination.
-/// \return The updated output iterator
-///
-/// \param first  The start of the input sequence
-/// \param last   The end of the input sequence
-/// \param result The output iterator to write the results into
-/// \param bOp    The operation for combining transformed input elements
-/// \param uOp    The operation for transforming input elements
-/// \param init   The initial value
-///
-/// \note This function is part of the C++17 standard library
-template<class InputIterator, class OutputIterator, class T,
-         class BinaryOperation, class UnaryOperation>
-OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last,
-                                        OutputIterator result, T init,
-                                        BinaryOperation bOp, UnaryOperation uOp)
-{
-    if (first != last)
-    {
-        T saved = init;
-        do
-        {
-            init = bOp(init, uOp(*first));
-            *result = saved;
-            saved = init;
-            ++result;
-        } while (++first != last);
-    }
-    return result;
-}
-
-}} // namespace boost and algorithm
-
-#endif // BOOST_ALGORITHM_TRANSFORM_EXCLUSIVE_SCAN_HPP

include/boost/algorithm/cxx17/transform_inclusive_scan.hpp

@@ -1,89 +0,0 @@
-/*
-   Copyright (c) Marshall Clow 2017.
-
-   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  transform_reduce.hpp
-/// \brief Combine the (transformed) elements of a sequence (or two) into a single value.
-/// \author Marshall Clow
-
-#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>
-
-namespace boost { namespace algorithm {
-
-/// \fn transform_inclusive_scan ( InputIterator first, InputIterator last, OutputIterator result, BinaryOperation bOp, UnaryOperation uOp, T init )
-/// \brief Transforms elements from the input range with uOp and then combines
-/// those transformed elements with bOp such that the n-1th element and the nth
-/// element are combined. Inclusivity means that the nth element is included in
-/// the nth combination.
-/// \return The updated output iterator
-///
-/// \param first  The start of the input sequence
-/// \param last   The end of the input sequence
-/// \param result The output iterator to write the results into
-/// \param bOp    The operation for combining transformed input elements
-/// \param uOp    The operation for transforming input elements
-/// \param init   The initial value
-///
-/// \note This function is part of the C++17 standard library
-template<class InputIterator, class OutputIterator,
-         class BinaryOperation, class UnaryOperation, class T>
-OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
-                                        OutputIterator result,
-                                        BinaryOperation bOp, UnaryOperation uOp,
-                                        T init)
-{
-    for (; first != last; ++first, (void) ++result) {
-        init = bOp(init, uOp(*first));
-        *result = init;
-        }
-
-    return result;
-}
-
-/// \fn transform_inclusive_scan ( InputIterator first, InputIterator last, OutputIterator result, BinaryOperation bOp, UnaryOperation uOp, T init )
-/// \brief Transforms elements from the input range with uOp and then combines
-/// those transformed elements with bOp such that the n-1th element and the nth
-/// element are combined. Inclusivity means that the nth element is included in
-/// the nth combination. The first value will be used as the init.
-/// \return The updated output iterator
-///
-/// \param first  The start of the input sequence
-/// \param last   The end of the input sequence
-/// \param result The output iterator to write the results into
-/// \param bOp    The operation for combining transformed input elements
-/// \param uOp    The operation for transforming input elements
-///
-/// \note This function is part of the C++17 standard library
-template<class InputIterator, class OutputIterator,
-         class BinaryOperation, class UnaryOperation>
-OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
-                                        OutputIterator result,
-                                        BinaryOperation bOp, UnaryOperation uOp)
-{
-    if (first != last) {
-        typename std::iterator_traits<InputIterator>::value_type init = uOp(*first);
-        *result++ = init;
-        if (++first != last)
-            return boost::algorithm::transform_inclusive_scan
-                                              (first, last, result, bOp, uOp, init);
-        }
-
-    return result;
-}
-
-
-}} // namespace boost and algorithm
-
-#endif // BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP

include/boost/algorithm/cxx17/transform_reduce.hpp

@@ -1,56 +0,0 @@
-/*
-   Copyright (c) Marshall Clow 2017.
-
-   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  transform_reduce.hpp
-/// \brief Combine the (transformed) elements of a sequence (or two) into a single value.
-/// \author Marshall Clow
-
-#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>
-
-namespace boost { namespace algorithm {
-
-template<class InputIterator1, class InputIterator2, class T,
-         class BinaryOperation1, class BinaryOperation2>
-T transform_reduce(InputIterator1 first1, InputIterator1 last1,
-                   InputIterator2 first2, T init,
-                 BinaryOperation1 bOp1, BinaryOperation2 bOp2)
-{
-    for (; first1 != last1; ++first1, (void) ++first2)
-        init = bOp1(init, bOp2(*first1, *first2));
-    return init;
-}
-
-template<class InputIterator, class T,
-         class BinaryOperation, class UnaryOperation>
-T transform_reduce(InputIterator first, InputIterator last,
-                   T init, BinaryOperation bOp, UnaryOperation uOp)
-{
-    for (; first != last; ++first)
-        init = bOp(init, uOp(*first));
-    return init;
-}
-
-template<class InputIterator1, class InputIterator2, class T>
-T transform_reduce(InputIterator1 first1, InputIterator1 last1,
-                   InputIterator2 first2, T init)
-{
-    return boost::algorithm::transform_reduce(first1, last1, first2, init,
-                            std::plus<T>(), std::multiplies<T>());
-}
-
-}} // namespace boost and algorithm
-
-#endif // BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP

include/boost/algorithm/find_backward.hpp

@@ -1,96 +0,0 @@
-/*
-   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)
-*/
-#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>
-
-namespace boost { namespace algorithm {
-
-template<typename BidiIter, typename T>
-BOOST_CXX14_CONSTEXPR
-BidiIter find_backward(BidiIter first, BidiIter last, const T & x)
-{
-    BidiIter it = last;
-    while (it != first) {
-        if (*--it == x)
-            return it;
-    }
-    return last;
-}
-
-template<typename Range, typename T>
-BOOST_CXX14_CONSTEXPR
-typename boost::range_iterator<Range>::type find_backward(Range & range, const T & x)
-{
-    return ::boost::algorithm::find_backward(boost::begin(range), boost::end(range), x);
-}
-
-template<typename BidiIter, typename T>
-BOOST_CXX14_CONSTEXPR
-BidiIter find_not_backward(BidiIter first, BidiIter last, const T & x)
-{
-    BidiIter it = last;
-    while (it != first) {
-        if (*--it != x)
-            return it;
-    }
-    return last;
-}
-
-template<typename Range, typename T>
-BOOST_CXX14_CONSTEXPR
-typename boost::range_iterator<Range>::type find_not_backward(Range & range, const T & x)
-{
-    return ::boost::algorithm::find_not_backward(boost::begin(range), boost::end(range), x);
-}
-
-template<typename BidiIter, typename Pred>
-BOOST_CXX14_CONSTEXPR
-BidiIter find_if_backward(BidiIter first, BidiIter last, Pred p)
-{
-    BidiIter it = last;
-    while (it != first) {
-        if (p(*--it))
-            return it;
-    }
-    return last;
-}
-
-template<typename Range, typename Pred>
-BOOST_CXX14_CONSTEXPR
-typename boost::range_iterator<Range>::type find_if_backward(Range & range, Pred p)
-{
-    return ::boost::algorithm::find_if_backward(boost::begin(range), boost::end(range), p);
-}
-
-template<typename BidiIter, typename Pred>
-BOOST_CXX14_CONSTEXPR
-BidiIter find_if_not_backward(BidiIter first, BidiIter last, Pred p)
-{
-    BidiIter it = last;
-    while (it != first) {
-        if (!p(*--it))
-            return it;
-    }
-    return last;
-}
-
-template<typename Range, typename Pred>
-BOOST_CXX14_CONSTEXPR
-typename boost::range_iterator<Range>::type find_if_not_backward(Range & range, Pred p)
-{
-    return ::boost::algorithm::find_if_not_backward(boost::begin(range), boost::end(range), p);
-}
-
-}} // namespace boost and algorithm
-
-#endif // BOOST_ALGORITHM_FIND_BACKWARD_HPP

include/boost/algorithm/find_not.hpp

@@ -1,38 +0,0 @@
-/*
-   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)
-*/
-#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>
-
-namespace boost { namespace algorithm {
-
-template<typename InputIter, typename Sentinel, typename T>        
-BOOST_CXX14_CONSTEXPR
-InputIter find_not(InputIter first, Sentinel last, const T & x)
-{
-    for (; first != last; ++first) {
-        if (*first != x)
-            break;
-    }
-    return first;
-}
-
-template<typename Range, typename T>
-BOOST_CXX14_CONSTEXPR
-typename boost::range_iterator<Range>::type find_not(Range & r, const T & x)
-{
-    return ::boost::algorithm::find_not(boost::begin(r), boost::end(r), x);
-}
-
-}} // namespace boost and algorithm
-
-#endif // BOOST_ALGORITHM_FIND_NOT_HPP

include/boost/algorithm/gather.hpp

@@ -1,4 +1,4 @@
-/*
+/* 
     Copyright 2008 Adobe Systems Incorporated
 
    Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -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
-std::pair<BidirectionalIterator, BidirectionalIterator> gather
+    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 )));
@@ -106,11 +103,11 @@ template <
     typename BidirectionalRange,    //
     typename Pred>                  // Pred models UnaryPredicate
 std::pair<
-    typename boost::range_iterator<BidirectionalRange>::type,
-    typename boost::range_iterator<BidirectionalRange>::type>
+    typename boost::range_iterator<const BidirectionalRange>::type,
+    typename boost::range_iterator<const BidirectionalRange>::type>
 gather (
-    BidirectionalRange &range,
-    typename boost::range_iterator<BidirectionalRange>::type pivot,
+    const BidirectionalRange &range,
+    typename boost::range_iterator<const BidirectionalRange>::type pivot,
     Pred pred )
 {
     return boost::algorithm::gather ( boost::begin ( range ), boost::end ( range ), pivot, pred );

include/boost/algorithm/hex.hpp

@@ -1,9 +1,9 @@
-/*
+/* 
    Copyright (c) Marshall Clow 2011-2012.
 
    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)
-
+   
    Thanks to Nevin for his comments/help.
 */
 
@@ -13,7 +13,7 @@
 */
 
 /// \file  hex.hpp
-/// \brief Convert sequence of integral types into a sequence of hexadecimal
+/// \brief Convert sequence of integral types into a sequence of hexadecimal 
 ///     characters and back. Based on the MySQL functions HEX and UNHEX
 /// \author Marshall Clow
 
@@ -23,46 +23,43 @@
 #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>
-#include <boost/exception/info.hpp>
-#include <boost/throw_exception.hpp>
+#include <boost/exception/all.hpp>
 
-#include <boost/core/enable_if.hpp>
+#include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_integral.hpp>
 
 
 namespace boost { namespace algorithm {
 
-/*!
-    \struct hex_decode_error
-    \brief  Base exception class for all hex decoding errors
+/*! 
+    \struct hex_decode_error 
+    \brief  Base exception class for all hex decoding errors 
 */ /*!
-    \struct non_hex_input
+    \struct non_hex_input    
     \brief  Thrown when a non-hex value (0-9, A-F) encountered when decoding.
                 Contains the offending character
-*/ /*!
-    \struct not_enough_input
+*/ /*!    
+    \struct not_enough_input 
     \brief  Thrown when the input sequence unexpectedly ends
-
+    
 */
-struct BOOST_SYMBOL_VISIBLE hex_decode_error : virtual boost::exception, virtual std::exception {};
-struct BOOST_SYMBOL_VISIBLE not_enough_input : virtual hex_decode_error {};
-struct BOOST_SYMBOL_VISIBLE non_hex_input    : virtual hex_decode_error {};
+struct hex_decode_error : virtual boost::exception, virtual std::exception {};
+struct not_enough_input : virtual hex_decode_error {};
+struct non_hex_input    : virtual hex_decode_error {};
 typedef boost::error_info<struct bad_char_,char> bad_char;
 
 namespace detail {
 /// \cond DOXYGEN_HIDE
 
     template <typename T, typename OutputIterator>
-    OutputIterator encode_one ( T val, OutputIterator out, const char * hexDigits ) {
+    OutputIterator encode_one ( T val, OutputIterator out ) {
         const std::size_t num_hex_digits =  2 * sizeof ( T );
         char res [ num_hex_digits ];
         char  *p = res + num_hex_digits;
         for ( std::size_t i = 0; i < num_hex_digits; ++i, val >>= 4 )
-            *--p = hexDigits [ val & 0x0F ];
+            *--p = "0123456789ABCDEF" [ val & 0x0F ];
         return std::copy ( res, res + num_hex_digits, out );
         }
 
@@ -74,7 +71,7 @@ namespace detail {
         else if ( c >= 'A' && c <= 'F' ) retval = c - 'A' + 10;
         else if ( c >= 'a' && c <= 'f' ) retval = c - 'a' + 10;
         else BOOST_THROW_EXCEPTION (non_hex_input() << bad_char (c));
-        return static_cast<char>(retval);
+        return retval;
         }
 
 //  My own iterator_traits class.
@@ -109,12 +106,12 @@ namespace detail {
         typedef T value_type;
     };
 
-    template <typename Iterator>
+    template <typename Iterator> 
     bool iter_end ( Iterator current, Iterator last ) { return current == last; }
-
+  
     template <typename T>
     bool ptr_end ( const T* ptr, const T* /*end*/ ) { return *ptr == '\0'; }
-
+  
 //  What can we assume here about the inputs?
 //      is std::iterator_traits<InputIterator>::value_type always 'char' ?
 //  Could it be wchar_t, say? Does it matter?
@@ -127,11 +124,11 @@ namespace detail {
 
     //  Need to make sure that we get can read that many chars here.
         for ( std::size_t i = 0; i < 2 * sizeof ( T ); ++i, ++first ) {
-            if ( pred ( first, last ))
+            if ( pred ( first, last )) 
                 BOOST_THROW_EXCEPTION (not_enough_input ());
             res = ( 16 * res ) + hex_char_to_int (*first);
             }
-
+        
         *out = res;
         return ++out;
         }
@@ -141,7 +138,7 @@ namespace detail {
 
 /// \fn hex ( InputIterator first, InputIterator last, OutputIterator out )
 /// \brief   Converts a sequence of integral types into a hexadecimal sequence of characters.
-///
+/// 
 /// \param first    The start of the input sequence
 /// \param last     One past the end of the input sequence
 /// \param out      An output iterator to the results into
@@ -151,31 +148,14 @@ template <typename InputIterator, typename OutputIterator>
 typename boost::enable_if<boost::is_integral<typename detail::hex_iterator_traits<InputIterator>::value_type>, OutputIterator>::type
 hex ( InputIterator first, InputIterator last, OutputIterator out ) {
     for ( ; first != last; ++first )
-        out = detail::encode_one ( *first, out, "0123456789ABCDEF" );
+        out = detail::encode_one ( *first, out );
     return out;
     }
-
-
-/// \fn hex_lower ( InputIterator first, InputIterator last, OutputIterator out )
-/// \brief   Converts a sequence of integral types into a lower case hexadecimal sequence of characters.
-///
-/// \param first    The start of the input sequence
-/// \param last     One past the end of the input sequence
-/// \param out      An output iterator to the results into
-/// \return         The updated output iterator
-/// \note           Based on the MySQL function of the same name
-template <typename InputIterator, typename OutputIterator>
-typename boost::enable_if<boost::is_integral<typename detail::hex_iterator_traits<InputIterator>::value_type>, OutputIterator>::type
-hex_lower ( InputIterator first, InputIterator last, OutputIterator out ) {
-    for ( ; first != last; ++first )
-        out = detail::encode_one ( *first, out, "0123456789abcdef" );
-    return out;
-    }
-
+    
 
 /// \fn hex ( const T *ptr, OutputIterator out )
 /// \brief   Converts a sequence of integral types into a hexadecimal sequence of characters.
-///
+/// 
 /// \param ptr      A pointer to a 0-terminated sequence of data.
 /// \param out      An output iterator to the results into
 /// \return         The updated output iterator
@@ -184,30 +164,13 @@ template <typename T, typename OutputIterator>
 typename boost::enable_if<boost::is_integral<T>, OutputIterator>::type
 hex ( const T *ptr, OutputIterator out ) {
     while ( *ptr )
-        out = detail::encode_one ( *ptr++, out, "0123456789ABCDEF" );
+        out = detail::encode_one ( *ptr++, out );
     return out;
     }
 
-
-/// \fn hex_lower ( const T *ptr, OutputIterator out )
-/// \brief   Converts a sequence of integral types into a lower case hexadecimal sequence of characters.
-///
-/// \param ptr      A pointer to a 0-terminated sequence of data.
-/// \param out      An output iterator to the results into
-/// \return         The updated output iterator
-/// \note           Based on the MySQL function of the same name
-template <typename T, typename OutputIterator>
-typename boost::enable_if<boost::is_integral<T>, OutputIterator>::type
-hex_lower ( const T *ptr, OutputIterator out ) {
-    while ( *ptr )
-        out = detail::encode_one ( *ptr++, out, "0123456789abcdef" );
-    return out;
-    }
-
-
 /// \fn hex ( const Range &r, OutputIterator out )
 /// \brief   Converts a sequence of integral types into a hexadecimal sequence of characters.
-///
+/// 
 /// \param r        The input range
 /// \param out      An output iterator to the results into
 /// \return         The updated output iterator
@@ -219,23 +182,9 @@ hex ( const Range &r, OutputIterator out ) {
 }
 
 
-/// \fn hex_lower ( const Range &r, OutputIterator out )
-/// \brief   Converts a sequence of integral types into a lower case hexadecimal sequence of characters.
-///
-/// \param r        The input range
-/// \param out      An output iterator to the results into
-/// \return         The updated output iterator
-/// \note           Based on the MySQL function of the same name
-template <typename Range, typename OutputIterator>
-typename boost::enable_if<boost::is_integral<typename detail::hex_iterator_traits<typename Range::iterator>::value_type>, OutputIterator>::type
-hex_lower ( const Range &r, OutputIterator out ) {
-    return hex_lower (boost::begin(r), boost::end(r), out);
-}
-
-
 /// \fn unhex ( InputIterator first, InputIterator last, OutputIterator out )
 /// \brief   Converts a sequence of hexadecimal characters into a sequence of integers.
-///
+/// 
 /// \param first    The start of the input sequence
 /// \param last     One past the end of the input sequence
 /// \param out      An output iterator to the results into
@@ -251,7 +200,7 @@ OutputIterator unhex ( InputIterator first, InputIterator last, OutputIterator o
 
 /// \fn unhex ( const T *ptr, OutputIterator out )
 /// \brief   Converts a sequence of hexadecimal characters into a sequence of integers.
-///
+/// 
 /// \param ptr      A pointer to a null-terminated input sequence.
 /// \param out      An output iterator to the results into
 /// \return         The updated output iterator
@@ -269,7 +218,7 @@ OutputIterator unhex ( const T *ptr, OutputIterator out ) {
 
 /// \fn OutputIterator unhex ( const Range &r, OutputIterator out )
 /// \brief   Converts a sequence of hexadecimal characters into a sequence of integers.
-///
+/// 
 /// \param r        The input range
 /// \param out      An output iterator to the results into
 /// \return         The updated output iterator
@@ -282,7 +231,7 @@ OutputIterator unhex ( const Range &r, OutputIterator out ) {
 
 /// \fn String hex ( const String &input )
 /// \brief   Converts a sequence of integral types into a hexadecimal sequence of characters.
-///
+/// 
 /// \param input    A container to be converted
 /// \return         A container with the encoded text
 template<typename String>
@@ -293,24 +242,9 @@ String hex ( const String &input ) {
     return output;
     }
 
-
-/// \fn String hex_lower ( const String &input )
-/// \brief   Converts a sequence of integral types into a lower case hexadecimal sequence of characters.
-///
-/// \param input    A container to be converted
-/// \return         A container with the encoded text
-template<typename String>
-String hex_lower ( const String &input ) {
-    String output;
-    output.reserve (input.size () * (2 * sizeof (typename String::value_type)));
-    (void) hex_lower (input, std::back_inserter (output));
-    return output;
-    }
-
-
 /// \fn String unhex ( const String &input )
 /// \brief   Converts a sequence of hexadecimal characters into a sequence of characters.
-///
+/// 
 /// \param input    A container to be converted
 /// \return         A container with the decoded text
 template<typename String>

include/boost/algorithm/indirect_sort.hpp

@@ -1,207 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2023.
-
-   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 indirect_sort.hpp
-/// \brief indirect sorting algorithms
-/// \author Marshall Clow
-///
-
-#ifndef BOOST_ALGORITHM_INDIRECT_SORT
-#define BOOST_ALGORITHM_INDIRECT_SORT
-
-#include <algorithm>        // for std::sort (and others)
-#include <functional>       // for std::less
-#include <vector>           // for std::vector
-
-#include <boost/algorithm/cxx11/iota.hpp>
-
-namespace boost { namespace algorithm {
-
-typedef std::vector<size_t> Permutation;
-
-namespace detail {
-
-	template <class Predicate, class Iter>
-	struct indirect_predicate {
-		indirect_predicate (Predicate pred, Iter iter)
-		: pred_(pred), iter_(iter) {}
-	
-		bool operator ()(size_t a, size_t b) const {
-			 return pred_(iter_[a], iter_[b]);
-		}
-		
-		Predicate pred_;
-		Iter      iter_;
-	};
-
-	// Initialize a permutation of size 'size'. [ 0, 1, 2, ... size-1 ]
-	// Note: it would be nice to use 'iota' here, but that call writes over
-	// existing elements - not append them.  I don't want to initialize
-	// the elements of the permutation to zero, and then immediately
-	// overwrite them.
-	void init_permutation (Permutation &p, size_t size) {
-		p.reserve(size);
-		boost::algorithm::iota_n(
-		                    std::back_insert_iterator<Permutation>(p), size_t(0), size);
-	}
-}
-
-                    // ===== sort =====
-
-/// \fn indirect_sort (RAIterator first, RAIterator last, Predicate pred)
-/// \returns a permutation of the elements in the range [first, last)
-///     such that when the permutation is applied to the sequence,
-///     the result is ordered as if 'std::sort(first, last, pred)'
-//      was called on the sequence.
-///
-/// \param first  The start of the input sequence
-/// \param last   The end of the input sequence
-/// \param pred   The predicate to compare elements with
-///
-template <typename RAIterator, typename Pred>
-Permutation indirect_sort (RAIterator first, RAIterator last, Pred pred) {
-
-	Permutation ret;
-	detail::init_permutation(ret, std::distance(first, last));
-	std::sort(ret.begin(), ret.end(), 
-	                  detail::indirect_predicate<Pred, RAIterator>(pred, first));
-	return ret;
-}
-
-/// \fn indirect_sort (RAIterator first, RAIterator last)
-/// \returns a permutation of the elements in the range [first, last)
-///     such that when the permutation is applied to the sequence,
-///     the result is ordered as if 'std::sort(first, last)'
-//      was called on the sequence.
-///
-/// \param first  The start of the input sequence
-/// \param last   The end of the input sequence
-///
-template <typename RAIterator>
-Permutation indirect_sort (RAIterator first, RAIterator last) {
-    return indirect_sort(first, last, 
-                    std::less<typename std::iterator_traits<RAIterator>::value_type>());
-}
-
-                    // ===== stable_sort =====
-
-/// \fn indirect_stable_sort (RAIterator first, RAIterator last, Predicate pred)
-/// \returns a permutation of the elements in the range [first, last)
-///     such that when the permutation is applied to the sequence,
-///     the result is ordered as if 'std::stable_sort(first, last, pred)'
-//      was called on the sequence.
-///
-/// \param first  The start of the input sequence
-/// \param last   The end of the input sequence
-/// \param pred   The predicate to compare elements with
-///
-template <typename RAIterator, typename Pred>
-Permutation indirect_stable_sort (RAIterator first, RAIterator last, Pred pred) {
-	Permutation ret;
-	detail::init_permutation(ret, std::distance(first, last));
-	std::stable_sort(ret.begin(), ret.end(), 
-	                  detail::indirect_predicate<Pred, RAIterator>(pred, first));
-	return ret;
-}
-
-/// \fn indirect_stable_sort (RAIterator first, RAIterator last)
-/// \returns a permutation of the elements in the range [first, last)
-///     such that when the permutation is applied to the sequence,
-///     the result is ordered as if 'std::stable_sort(first, last)'
-//      was called on the sequence.
-///
-/// \param first  The start of the input sequence
-/// \param last   The end of the input sequence
-///
-template <typename RAIterator>
-Permutation indirect_stable_sort (RAIterator first, RAIterator last) {
-    return indirect_stable_sort(first, last, 
-                    std::less<typename std::iterator_traits<RAIterator>::value_type>());
-}
-
-                    // ===== partial_sort =====
-
-/// \fn indirect_partial_sort (RAIterator first, RAIterator middle, RAIterator last, Predicate pred)
-/// \returns a permutation of the elements in the range [first, last)
-///     such that when the permutation is applied to the sequence,
-///     the result is ordered as if 'std::partial_sort(first, middle, last, pred)'
-//      was called on the sequence.
-///
-/// \param first  The start of the input sequence
-/// \param middle The end of the range to be sorted
-/// \param last   The end of the input sequence
-/// \param pred   The predicate to compare elements with
-///
-template <typename RAIterator, typename Pred>
-Permutation indirect_partial_sort (RAIterator first, RAIterator middle, 
-                                   RAIterator last, Pred pred) {
-	Permutation ret;
-	detail::init_permutation(ret, std::distance(first, last));
-	std::partial_sort(ret.begin(), ret.begin() + std::distance(first, middle), ret.end(), 
-	                  detail::indirect_predicate<Pred, RAIterator>(pred, first));
-	return ret;
-}
-
-/// \fn indirect_partial_sort (RAIterator first, RAIterator middle, RAIterator last)
-/// \returns a permutation of the elements in the range [first, last)
-///     such that when the permutation is applied to the sequence,
-///     the result is ordered as if 'std::partial_sort(first, middle, last)'
-//      was called on the sequence.
-///
-/// \param first  The start of the input sequence
-/// \param middle The end of the range to be sorted
-/// \param last   The end of the input sequence
-///
-template <typename RAIterator>
-Permutation indirect_partial_sort (RAIterator first, RAIterator middle, RAIterator last) {
-    return indirect_partial_sort(first, middle, last, 
-                    std::less<typename std::iterator_traits<RAIterator>::value_type>());
-}
-
-                    // ===== nth_element =====
-
-/// \fn indirect_nth_element (RAIterator first, RAIterator nth, RAIterator last, Predicate p)
-/// \returns a permutation of the elements in the range [first, last)
-///     such that when the permutation is applied to the sequence,
-///     the result is ordered as if 'std::nth_element(first, nth, last, p)'
-//      was called on the sequence.
-///
-/// \param first  The start of the input sequence
-/// \param nth    The sort partition point in the input sequence
-/// \param last   The end of the input sequence
-/// \param pred   The predicate to compare elements with
-///
-template <typename RAIterator, typename Pred>
-Permutation indirect_nth_element (RAIterator first, RAIterator nth,
-                                  RAIterator last, Pred pred) {
-	Permutation ret;
-	detail::init_permutation(ret, std::distance(first, last));
-	std::nth_element(ret.begin(), ret.begin() + std::distance(first, nth), ret.end(), 
-	                  detail::indirect_predicate<Pred, RAIterator>(pred, first));
-	return ret;
-}
-
-/// \fn indirect_nth_element (RAIterator first, RAIterator nth, RAIterator last)
-/// \returns a permutation of the elements in the range [first, last)
-///     such that when the permutation is applied to the sequence,
-///     the result is ordered as if 'std::nth_element(first, nth, last)'
-//      was called on the sequence.
-///
-/// \param first  The start of the input sequence
-/// \param nth    The sort partition point in the input sequence
-/// \param last   The end of the input sequence
-///
-template <typename RAIterator>
-Permutation indirect_nth_element (RAIterator first, RAIterator nth, RAIterator last) {
-    return indirect_nth_element(first, nth, last, 
-                    std::less<typename std::iterator_traits<RAIterator>::value_type>());
-}
-
-}}
-
-#endif // BOOST_ALGORITHM_INDIRECT_SORT

include/boost/algorithm/is_clamped.hpp

@@ -1,72 +0,0 @@
-/* 
-   Copyright (c) Ivan Matek, Marshall Clow 2021.
-
-   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 is_clamped.hpp
-/// \brief IsClamped algorithm
-/// \authors Ivan Matek, Marshall Clow
-///
-
-#ifndef BOOST_ALGORITHM_IS_CLAMPED_HPP
-#define BOOST_ALGORITHM_IS_CLAMPED_HPP
-
-#include <functional>       //  for std::less
-#include <cassert>
-
-#include <boost/type_traits/type_identity.hpp> // for boost::type_identity
-
-namespace boost { namespace algorithm {
-
-/// \fn is_clamped ( T const& val,
-///               typename boost::type_identity<T>::type const & lo,
-///               typename boost::type_identity<T>::type const & hi, Pred p )
-/// \returns true if value "val" is in the range [ lo, hi ]
-///     using the comparison predicate p.
-///     If p ( val, lo ) return false.
-///     If p ( hi, val ) return false.
-///     Otherwise, returns true.
-///
-/// \param val   The value to be checked
-/// \param lo    The lower bound of the range
-/// \param hi    The upper bound of the range
-/// \param p     A predicate to use to compare the values.
-///                 p ( a, b ) returns a boolean.
-///
-  template <typename T, typename Pred>
-  BOOST_CXX14_CONSTEXPR bool is_clamped(
-      T const& val, typename boost::type_identity<T>::type const& lo,
-      typename boost::type_identity<T>::type const& hi, Pred p) {
-    //    assert ( !p ( hi, lo ));    // Can't assert p ( lo, hi ) b/c they
-    //    might be equal
-    return p(val, lo) ? false : p(hi, val) ? false : true;
-  }
-  
-/// \fn is_clamped ( T const& val,
-///               typename boost::type_identity<T>::type const & lo,
-///               typename boost::type_identity<T>::type const & hi)
-/// \returns true if value "val" is in the range [ lo, hi ]
-///     using operator < for comparison.
-///     If the value is less than lo, return false.
-///     If the value is greater than hi, return false.
-///     Otherwise, returns true.
-///
-/// \param val   The value to be checked
-/// \param lo    The lower bound of the range
-/// \param hi    The upper bound of the range
-///
-  
-  template<typename T> 
-  BOOST_CXX14_CONSTEXPR bool is_clamped ( const T& val,
-    typename boost::type_identity<T>::type const & lo,
-    typename boost::type_identity<T>::type const & hi )
-  {
-    return boost::algorithm::is_clamped ( val, lo, hi, std::less<T>());
-  } 
-
-}}
-
-#endif // BOOST_ALGORITHM_CLAMP_HPP

include/boost/algorithm/is_palindrome.hpp

@@ -1,141 +0,0 @@
-/*
-  Copyright (c) Alexander Zaitsev <zamazan4ik@gmail.com>, 2016
-
-  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)
-
-  See http://www.boost.org/ for latest version.
-*/
-
-/// \file  is_palindrome.hpp
-/// \brief Checks the input sequence on palindrome.
-/// \author Alexander Zaitsev
-
-#ifndef BOOST_ALGORITHM_IS_PALINDROME_HPP
-#define BOOST_ALGORITHM_IS_PALINDROME_HPP
-
-#include <iterator>
-#include <functional>
-#include <cstring>
-
-#include <boost/config.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-namespace boost {  namespace algorithm {
-
-/// \fn is_palindrome ( BidirectionalIterator begin, BidirectionalIterator end, Predicate p )
-/// \return true if the entire sequence is palindrome
-///
-/// \param begin    The start of the input sequence
-/// \param end		One past the end of the input sequence
-/// \param p        A predicate used to compare the values.
-///
-/// \note This function will return true for empty sequences and for palindromes.
-///     For other sequences function will return false.
-///     Complexity: O(N).
-template <typename BidirectionalIterator, typename Predicate>
-bool is_palindrome(BidirectionalIterator begin, BidirectionalIterator end, Predicate p)
-{
-    if(begin == end)
-    {
-        return true;
-    }
-
-    --end;
-    while(begin != end)
-    {
-        if(!p(*begin, *end))
-        {
-            return false;
-        }
-        ++begin;
-        if(begin == end)
-        {
-            break;
-        }
-        --end;
-    }
-    return true;
-}
-
-/// \fn is_palindrome ( BidirectionalIterator begin, BidirectionalIterator end )
-/// \return true if the entire sequence is palindrome
-///
-/// \param begin    The start of the input sequence
-/// \param end	    One past the end of the input sequence
-///
-/// \note This function will return true for empty sequences and for palindromes.
-///     For other sequences function will return false.
-///     Complexity: O(N).
-template <typename BidirectionalIterator>
-bool is_palindrome(BidirectionalIterator begin, BidirectionalIterator end)
-{
-    return is_palindrome(begin, end,
-                         std::equal_to<typename std::iterator_traits<BidirectionalIterator>::value_type> ());
-}
-
-/// \fn is_palindrome ( const R& range )
-/// \return true if the entire sequence is palindrome
-///
-/// \param range The range to be tested.
-///
-/// \note This function will return true for empty sequences and for palindromes.
-///     For other sequences function will return false.
-///     Complexity: O(N).
-template <typename R>
-bool is_palindrome(const R& range)
-{
-    return is_palindrome(boost::begin(range), boost::end(range));
-}
-
-/// \fn is_palindrome ( const R& range, Predicate p )
-/// \return true if the entire sequence is palindrome
-///
-/// \param range The range to be tested.
-/// \param p     A predicate used to compare the values.
-///
-/// \note This function will return true for empty sequences and for palindromes.
-///     For other sequences function will return false.
-///     Complexity: O(N).
-template <typename R, typename Predicate>
-bool is_palindrome(const R& range, Predicate p)
-{
-    return is_palindrome(boost::begin(range), boost::end(range), p);
-}
-
-/// \fn is_palindrome ( const char* str )
-/// \return true if the entire sequence is palindrome
-///
-/// \param str C-string to be tested.
-///
-/// \note This function will return true for empty sequences and for palindromes.
-///     For other sequences function will return false.
-///     Complexity: O(N).
-inline bool is_palindrome(const char* str)
-{
-    if(!str)
-	    return true;
-    return is_palindrome(str, str + strlen(str));
-}
-
-/// \fn is_palindrome ( const char* str, Predicate p )
-/// \return true if the entire sequence is palindrome
-///
-/// \param str C-string to be tested.
-/// \param p   A predicate used to compare the values.
-///
-/// \note This function will return true for empty sequences and for palindromes.
-///     For other sequences function will return false.
-///     Complexity: O(N).
-template<typename Predicate>
-bool is_palindrome(const char* str, Predicate p)
-{
-    if(!str)
-	    return true;
-    return is_palindrome(str, str + strlen(str), p);
-}
-}}
-
-#endif // BOOST_ALGORITHM_IS_PALINDROME_HPP

include/boost/algorithm/is_partitioned_until.hpp

@@ -1,64 +0,0 @@
-/*
-   Copyright (c) Alexander Zaitsev <zamazan4ik@gmail.by>, 2017.
-
-   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  is_partitioned_until.hpp
-/// \brief Tell if a sequence is partitioned
-/// \author Alexander Zaitsev
-
-#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>
-
-namespace boost { namespace algorithm {
-
-/// \fn is_partitioned_until ( InputIterator first, InputIterator last, UnaryPredicate p )
-/// \brief Tests to see if a sequence is partitioned according to a predicate. 
-///	   In other words, all the items in the sequence that satisfy the predicate are at the beginning of the sequence.
-///
-/// \param first    The start of the input sequence
-/// \param last     One past the end of the input sequence
-/// \param p        The predicate to test the values with
-///
-/// \note Returns the first iterator 'it' in the sequence [first, last) for which is_partitioned(first, it, p) is false.
-///     Returns last if the entire sequence is partitioned.
-///     Complexity: O(N).
-template <typename InputIterator, typename UnaryPredicate>
-InputIterator is_partitioned_until ( InputIterator first, InputIterator last, UnaryPredicate p )
-{
-//  Run through the part that satisfy the predicate
-    for ( ; first != last; ++first )
-        if ( !p (*first))
-            break;
-//  Now the part that does not satisfy the predicate
-    for ( ; first != last; ++first )
-        if ( p (*first))
-            return first;
-    return last;
-}
-
-/// \fn is_partitioned_until ( const Range &r, UnaryPredicate p )
-/// \brief Tests to see if a sequence is partitioned according to a predicate. 
-///	   In other words, all the items in the sequence that satisfy the predicate are at the beginning of the sequence.
-///
-/// \param r        The input range
-/// \param p        The predicate to test the values with
-///
-/// \note Returns the first iterator 'it' in the sequence [first, last) for which is_partitioned(first, it, p) is false.
-///     Returns last if the entire sequence is partitioned.
-///     Complexity: O(N).
-template <typename Range, typename UnaryPredicate>
-typename boost::range_iterator<const Range>::type is_partitioned_until ( const Range &r, UnaryPredicate p )
-{
-    return boost::algorithm::is_partitioned_until (boost::begin(r), boost::end(r), p);
-}
-
-}}
-
-#endif  // BOOST_ALGORITHM_IS_PARTITIONED_UNTIL_HPP

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>
 

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

include/boost/algorithm/searching/boyer_moore.hpp

@@ -12,14 +12,13 @@
 
 #include <iterator>     // for std::iterator_traits
 
-#include <boost/config.hpp>
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
 
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
-#include <boost/core/enable_if.hpp>
+#include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
 
 #include <boost/algorithm/searching/detail/bm_traits.hpp>
@@ -76,27 +75,25 @@ Requirements:
         /// \param corpus_last  One past the end of the data to search
         ///
         template <typename corpusIter>
-        std::pair<corpusIter, corpusIter>
-        operator () ( corpusIter corpus_first, corpusIter corpus_last ) const {
+        corpusIter operator () ( corpusIter corpus_first, corpusIter corpus_last ) const {
             BOOST_STATIC_ASSERT (( boost::is_same<
                                     typename std::iterator_traits<patIter>::value_type, 
                                     typename std::iterator_traits<corpusIter>::value_type>::value ));
 
-            if ( corpus_first == corpus_last ) return std::make_pair(corpus_last, corpus_last);   // if nothing to search, we didn't find it!
-            if (    pat_first ==    pat_last ) return std::make_pair(corpus_first, corpus_first); // empty pattern matches at start
+            if ( corpus_first == corpus_last ) return corpus_last;  // if nothing to search, we didn't find it!
+            if (    pat_first ==    pat_last ) return corpus_first; // empty pattern matches at start
 
             const difference_type k_corpus_length  = std::distance ( corpus_first, corpus_last );
         //  If the pattern is larger than the corpus, we can't find it!
             if ( k_corpus_length < k_pattern_length ) 
-                return std::make_pair(corpus_last, corpus_last);
+                return corpus_last;
 
         //  Do the search 
-            return this->do_search ( corpus_first, corpus_last );
+            return this->do_search   ( corpus_first, corpus_last );
             }
             
         template <typename Range>
-        std::pair<typename boost::range_iterator<Range>::type, typename boost::range_iterator<Range>::type>
-        operator () ( Range &r ) const {
+        typename boost::range_iterator<Range>::type operator () ( Range &r ) const {
             return (*this) (boost::begin(r), boost::end(r));
             }
 
@@ -115,8 +112,7 @@ Requirements:
         /// \param p            A predicate used for the search comparisons.
         ///
         template <typename corpusIter>
-        std::pair<corpusIter, corpusIter>
-        do_search ( corpusIter corpus_first, corpusIter corpus_last ) const {
+        corpusIter do_search ( corpusIter corpus_first, corpusIter corpus_last ) const {
         /*  ---- Do the matching ---- */
             corpusIter curPos = corpus_first;
             const corpusIter lastPos = corpus_last - k_pattern_length;
@@ -130,7 +126,7 @@ Requirements:
                     j--;
                 //  We matched - we're done!
                     if ( j == 0 )
-                        return std::make_pair(curPos, curPos + k_pattern_length);
+                        return curPos;
                     }
                 
             //  Since we didn't match, figure out how far to skip forward
@@ -142,7 +138,7 @@ Requirements:
                     curPos += suffix_ [ j ];
                 }
         
-            return std::make_pair(corpus_last, corpus_last);     // We didn't find anything
+            return corpus_last;     // We didn't find anything
             }
 
 
@@ -153,8 +149,8 @@ Requirements:
         
 
         template<typename Iter, typename Container>
-        void compute_bm_prefix ( Iter first, Iter last, Container &prefix ) {
-            const std::size_t count = std::distance ( first, last );
+        void compute_bm_prefix ( Iter pat_first, Iter pat_last, Container &prefix ) {
+            const std::size_t count = std::distance ( pat_first, pat_last );
             BOOST_ASSERT ( count > 0 );
             BOOST_ASSERT ( prefix.size () == count );
                             
@@ -162,26 +158,26 @@ Requirements:
             std::size_t k = 0;
             for ( std::size_t i = 1; i < count; ++i ) {
                 BOOST_ASSERT ( k < count );
-                while ( k > 0 && ( first[k] != first[i] )) {
+                while ( k > 0 && ( pat_first[k] != pat_first[i] )) {
                     BOOST_ASSERT ( k < count );
                     k = prefix [ k - 1 ];
                     }
                     
-                if ( first[k] == first[i] )
+                if ( pat_first[k] == pat_first[i] )
                     k++;
                 prefix [ i ] = k;
                 }
             }
 
-        void build_suffix_table ( patIter first, patIter last ) {
-            const std::size_t count = (std::size_t) std::distance ( first, last );
+        void build_suffix_table ( patIter pat_first, patIter pat_last ) {
+            const std::size_t count = (std::size_t) std::distance ( pat_first, pat_last );
             
             if ( count > 0 ) {  // empty pattern
                 std::vector<typename std::iterator_traits<patIter>::value_type> reversed(count);
-                (void) std::reverse_copy ( first, last, reversed.begin ());
+                (void) std::reverse_copy ( pat_first, pat_last, reversed.begin ());
                 
                 std::vector<difference_type> prefix (count);
-                compute_bm_prefix ( first, last, prefix );
+                compute_bm_prefix ( pat_first, pat_last, prefix );
         
                 std::vector<difference_type> prefix_reversed (count);
                 compute_bm_prefix ( reversed.begin (), reversed.end (), prefix_reversed );
@@ -215,7 +211,7 @@ Requirements:
 /// \param pat_last     One past the end of the data to search for
 ///
     template <typename patIter, typename corpusIter>
-    std::pair<corpusIter, corpusIter> boyer_moore_search ( 
+    corpusIter boyer_moore_search ( 
                   corpusIter corpus_first, corpusIter corpus_last, 
                   patIter pat_first, patIter pat_last )
     {
@@ -224,7 +220,7 @@ Requirements:
     }
 
     template <typename PatternRange, typename corpusIter>
-    std::pair<corpusIter, corpusIter> boyer_moore_search ( 
+    corpusIter boyer_moore_search ( 
         corpusIter corpus_first, corpusIter corpus_last, const PatternRange &pattern )
     {
         typedef typename boost::range_iterator<const PatternRange>::type pattern_iterator;
@@ -233,9 +229,8 @@ Requirements:
     }
     
     template <typename patIter, typename CorpusRange>
-    typename boost::disable_if_c<
-        boost::is_same<CorpusRange, patIter>::value, 
-        std::pair<typename boost::range_iterator<CorpusRange>::type, typename boost::range_iterator<CorpusRange>::type> >
+    typename boost::lazy_disable_if_c<
+        boost::is_same<CorpusRange, patIter>::value, typename boost::range_iterator<CorpusRange> >
     ::type
     boyer_moore_search ( CorpusRange &corpus, patIter pat_first, patIter pat_last )
     {
@@ -244,7 +239,7 @@ Requirements:
     }
     
     template <typename PatternRange, typename CorpusRange>
-    std::pair<typename boost::range_iterator<CorpusRange>::type, typename boost::range_iterator<CorpusRange>::type>
+    typename boost::range_iterator<CorpusRange>::type
     boyer_moore_search ( CorpusRange &corpus, const PatternRange &pattern )
     {
         typedef typename boost::range_iterator<const PatternRange>::type pattern_iterator;

include/boost/algorithm/searching/boyer_moore_horspool.hpp

@@ -12,14 +12,13 @@
 
 #include <iterator>     // for std::iterator_traits
 
-#include <boost/config.hpp>
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
 
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
-#include <boost/core/enable_if.hpp>
+#include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
 
 #include <boost/algorithm/searching/detail/bm_traits.hpp>
@@ -65,34 +64,33 @@ http://www-igm.univ-mlv.fr/%7Elecroq/string/node18.html
             
         ~boyer_moore_horspool () {}
         
-        /// \fn operator ( corpusIter corpus_first, corpusIter corpus_last)
+        /// \fn operator ( corpusIter corpus_first, corpusIter corpus_last, Pred p )
         /// \brief Searches the corpus for the pattern that was passed into the constructor
         /// 
         /// \param corpus_first The start of the data to search (Random Access Iterator)
         /// \param corpus_last  One past the end of the data to search
+        /// \param p            A predicate used for the search comparisons.
         ///
         template <typename corpusIter>
-        std::pair<corpusIter, corpusIter>
-        operator () ( corpusIter corpus_first, corpusIter corpus_last ) const {
+        corpusIter operator () ( corpusIter corpus_first, corpusIter corpus_last ) const {
             BOOST_STATIC_ASSERT (( boost::is_same<
                 typename std::iterator_traits<patIter>::value_type, 
                 typename std::iterator_traits<corpusIter>::value_type>::value ));
 
-            if ( corpus_first == corpus_last ) return std::make_pair(corpus_last, corpus_last);   // if nothing to search, we didn't find it!
-            if (    pat_first ==    pat_last ) return std::make_pair(corpus_first, corpus_first); // empty pattern matches at start
+            if ( corpus_first == corpus_last ) return corpus_last;  // if nothing to search, we didn't find it!
+            if (    pat_first ==    pat_last ) return corpus_first; // empty pattern matches at start
 
             const difference_type k_corpus_length  = std::distance ( corpus_first, corpus_last );
         //  If the pattern is larger than the corpus, we can't find it!
             if ( k_corpus_length < k_pattern_length )
-                return std::make_pair(corpus_last, corpus_last);
+                return corpus_last;
     
         //  Do the search 
             return this->do_search ( corpus_first, corpus_last );
             }
             
         template <typename Range>
-        std::pair<typename boost::range_iterator<Range>::type, typename boost::range_iterator<Range>::type>
-        operator () ( Range &r ) const {
+        typename boost::range_iterator<Range>::type operator () ( Range &r ) const {
             return (*this) (boost::begin(r), boost::end(r));
             }
 
@@ -110,8 +108,7 @@ http://www-igm.univ-mlv.fr/%7Elecroq/string/node18.html
         /// \param k_corpus_length The length of the corpus to search
         ///
         template <typename corpusIter>
-        std::pair<corpusIter, corpusIter>
-        do_search ( corpusIter corpus_first, corpusIter corpus_last ) const {
+        corpusIter do_search ( corpusIter corpus_first, corpusIter corpus_last ) const {
             corpusIter curPos = corpus_first;
             const corpusIter lastPos = corpus_last - k_pattern_length;
             while ( curPos <= lastPos ) {
@@ -120,14 +117,14 @@ http://www-igm.univ-mlv.fr/%7Elecroq/string/node18.html
                 while ( pat_first [j] == curPos [j] ) {
                 //  We matched - we're done!
                     if ( j == 0 )
-                        return std::make_pair(curPos, curPos + k_pattern_length);
+                        return curPos;
                     j--;
                     }
         
                 curPos += skip_ [ curPos [ k_pattern_length - 1 ]];
                 }
             
-            return std::make_pair(corpus_last, corpus_last);
+            return corpus_last;
             }
 // \endcond
         };
@@ -145,7 +142,7 @@ http://www-igm.univ-mlv.fr/%7Elecroq/string/node18.html
 /// \param pat_last     One past the end of the data to search for
 ///
     template <typename patIter, typename corpusIter>
-    std::pair<corpusIter, corpusIter> boyer_moore_horspool_search ( 
+    corpusIter boyer_moore_horspool_search ( 
                   corpusIter corpus_first, corpusIter corpus_last, 
                   patIter pat_first, patIter pat_last )
     {
@@ -154,7 +151,7 @@ http://www-igm.univ-mlv.fr/%7Elecroq/string/node18.html
     }
 
     template <typename PatternRange, typename corpusIter>
-    std::pair<corpusIter, corpusIter> boyer_moore_horspool_search ( 
+    corpusIter boyer_moore_horspool_search ( 
         corpusIter corpus_first, corpusIter corpus_last, const PatternRange &pattern )
     {
         typedef typename boost::range_iterator<const PatternRange>::type pattern_iterator;
@@ -163,9 +160,8 @@ http://www-igm.univ-mlv.fr/%7Elecroq/string/node18.html
     }
     
     template <typename patIter, typename CorpusRange>
-    typename boost::disable_if_c<
-        boost::is_same<CorpusRange, patIter>::value, 
-        std::pair<typename boost::range_iterator<CorpusRange>::type, typename boost::range_iterator<CorpusRange>::type> >
+    typename boost::lazy_disable_if_c<
+        boost::is_same<CorpusRange, patIter>::value, typename boost::range_iterator<CorpusRange> >
     ::type
     boyer_moore_horspool_search ( CorpusRange &corpus, patIter pat_first, patIter pat_last )
     {
@@ -174,7 +170,7 @@ http://www-igm.univ-mlv.fr/%7Elecroq/string/node18.html
     }
     
     template <typename PatternRange, typename CorpusRange>
-    std::pair<typename boost::range_iterator<CorpusRange>::type, typename boost::range_iterator<CorpusRange>::type>
+    typename boost::range_iterator<CorpusRange>::type
     boyer_moore_horspool_search ( CorpusRange &corpus, const PatternRange &pattern )
     {
         typedef typename boost::range_iterator<const PatternRange>::type pattern_iterator;

include/boost/algorithm/searching/detail/bm_traits.hpp

@@ -79,7 +79,7 @@ namespace boost { namespace algorithm { namespace detail {
         skip_map skip_;
         const value_type k_default_value;
     public:
-        skip_table ( std::size_t /*patSize*/, value_type default_value ) : k_default_value ( default_value ) {
+        skip_table ( std::size_t patSize, value_type default_value ) : k_default_value ( default_value ) {
             std::fill_n ( skip_.begin(), skip_.size(), default_value );
             }
         

include/boost/algorithm/searching/knuth_morris_pratt.hpp

@@ -13,14 +13,13 @@
 #include <vector>
 #include <iterator>     // for std::iterator_traits
 
-#include <boost/config.hpp>
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
 
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
-#include <boost/core/enable_if.hpp>
+#include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
 
 #include <boost/algorithm/searching/detail/debugging.hpp>
@@ -70,26 +69,23 @@ namespace boost { namespace algorithm {
         /// \param p            A predicate used for the search comparisons.
         ///
         template <typename corpusIter>
-        std::pair<corpusIter, corpusIter>
-        operator () ( corpusIter corpus_first, corpusIter corpus_last ) const {
+        corpusIter operator () ( corpusIter corpus_first, corpusIter corpus_last ) const {
             BOOST_STATIC_ASSERT (( boost::is_same<
                 typename std::iterator_traits<patIter>::value_type, 
                 typename std::iterator_traits<corpusIter>::value_type>::value ));
-
-            if ( corpus_first == corpus_last ) return std::make_pair(corpus_last, corpus_last);   // if nothing to search, we didn't find it!
-            if (    pat_first ==    pat_last ) return std::make_pair(corpus_first, corpus_first); // empty pattern matches at start
+            if ( corpus_first == corpus_last ) return corpus_last;  // if nothing to search, we didn't find it!
+            if ( pat_first == pat_last )       return corpus_first; // empty pattern matches at start
 
             const difference_type k_corpus_length = std::distance ( corpus_first, corpus_last );
         //  If the pattern is larger than the corpus, we can't find it!
             if ( k_corpus_length < k_pattern_length ) 
-                return std::make_pair(corpus_last, corpus_last);
+                return corpus_last;
 
-            return do_search ( corpus_first, corpus_last, k_corpus_length );
+            return do_search   ( corpus_first, corpus_last, k_corpus_length );
             }
     
         template <typename Range>
-        std::pair<typename boost::range_iterator<Range>::type, typename boost::range_iterator<Range>::type>
-        operator () ( Range &r ) const {
+        typename boost::range_iterator<Range>::type operator () ( Range &r ) const {
             return (*this) (boost::begin(r), boost::end(r));
             }
 
@@ -107,8 +103,7 @@ namespace boost { namespace algorithm {
         /// \param p            A predicate used for the search comparisons.
         ///
         template <typename corpusIter>
-        std::pair<corpusIter, corpusIter>
-        do_search ( corpusIter corpus_first, corpusIter corpus_last, 
+        corpusIter do_search ( corpusIter corpus_first, corpusIter corpus_last, 
                                                 difference_type k_corpus_length ) const {
             difference_type match_start = 0;  // position in the corpus that we're matching
             
@@ -140,7 +135,7 @@ namespace boost { namespace algorithm {
             while ( match_start <= last_match ) {
                 while ( pat_first [ idx ] == corpus_first [ match_start + idx ] ) {
                     if ( ++idx == k_pattern_length )
-                        return std::make_pair(corpus_first + match_start, corpus_first + match_start + k_pattern_length);
+                        return corpus_first + match_start;
                     }
             //  Figure out where to start searching again
            //   assert ( idx - skip_ [ idx ] > 0 ); // we're always moving forward
@@ -151,14 +146,14 @@ namespace boost { namespace algorithm {
 #endif
                 
         //  We didn't find anything
-            return std::make_pair(corpus_last, corpus_last);
+            return corpus_last;
             }
     
 
         void preKmp ( patIter first, patIter last ) {
-           const difference_type count = std::distance ( first, last );
+           const /*std::size_t*/ int count = std::distance ( first, last );
         
-           difference_type i, j;
+           int i, j;
         
            i = 0;
            j = skip_[0] = -1;
@@ -178,7 +173,7 @@ namespace boost { namespace algorithm {
         void init_skip_table ( patIter first, patIter last ) {
             const difference_type count = std::distance ( first, last );
     
-            difference_type j;
+            int j;
             skip_ [ 0 ] = -1;
             for ( int i = 1; i <= count; ++i ) {
                 j = skip_ [ i - 1 ];
@@ -207,7 +202,7 @@ namespace boost { namespace algorithm {
 /// \param pat_last     One past the end of the data to search for
 ///
     template <typename patIter, typename corpusIter>
-    std::pair<corpusIter, corpusIter> knuth_morris_pratt_search ( 
+    corpusIter knuth_morris_pratt_search ( 
                   corpusIter corpus_first, corpusIter corpus_last, 
                   patIter pat_first, patIter pat_last )
     {
@@ -216,7 +211,7 @@ namespace boost { namespace algorithm {
     }
 
     template <typename PatternRange, typename corpusIter>
-    std::pair<corpusIter, corpusIter> knuth_morris_pratt_search ( 
+    corpusIter knuth_morris_pratt_search ( 
         corpusIter corpus_first, corpusIter corpus_last, const PatternRange &pattern )
     {
         typedef typename boost::range_iterator<const PatternRange>::type pattern_iterator;
@@ -225,9 +220,8 @@ namespace boost { namespace algorithm {
     }
     
     template <typename patIter, typename CorpusRange>
-    typename boost::disable_if_c<
-        boost::is_same<CorpusRange, patIter>::value, 
-        std::pair<typename boost::range_iterator<CorpusRange>::type, typename boost::range_iterator<CorpusRange>::type> >
+    typename boost::lazy_disable_if_c<
+        boost::is_same<CorpusRange, patIter>::value, typename boost::range_iterator<CorpusRange> >
     ::type
     knuth_morris_pratt_search ( CorpusRange &corpus, patIter pat_first, patIter pat_last )
     {
@@ -236,7 +230,7 @@ namespace boost { namespace algorithm {
     }
     
     template <typename PatternRange, typename CorpusRange>
-    std::pair<typename boost::range_iterator<CorpusRange>::type, typename boost::range_iterator<CorpusRange>::type>
+    typename boost::range_iterator<CorpusRange>::type
     knuth_morris_pratt_search ( CorpusRange &corpus, const PatternRange &pattern )
     {
         typedef typename boost::range_iterator<const PatternRange>::type pattern_iterator;

include/boost/algorithm/sort_subrange.hpp

@@ -1,110 +0,0 @@
-/* 
-   Copyright (c) Marshall Clow 2008-2012.
-
-   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)
-
- Revision history:
-   28 Sep 2015 mtc First version
-   
-*/
-
-/// \file sort_subrange.hpp
-/// \brief Sort a subrange
-/// \author Marshall Clow
-///
-/// Suggested by Sean Parent in his CppCon 2015 keynote
-
-#ifndef BOOST_ALGORITHM_SORT_SUBRANGE_HPP
-#define BOOST_ALGORITHM_SORT_SUBRANGE_HPP
-
-#include <functional>       // For std::less
-#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>
-
-namespace boost { namespace algorithm {
-
-/// \fn sort_subrange ( T const& val, 
-///               Iterator first,     Iterator last, 
-///               Iterator sub_first, Iterator sub_last, 
-///               Pred p )
-/// \brief Sort the subrange [sub_first, sub_last) that is inside
-///     the range [first, last) as if you had sorted the entire range.
-/// 
-/// \param first       The start of the larger range
-/// \param last        The end of the larger range
-/// \param sub_first   The start of the sub range
-/// \param sub_last    The end of the sub range
-/// \param p           A predicate to use to compare the values.
-///                        p ( a, b ) returns a boolean.
-///
-  template<typename Iterator, typename Pred> 
-  void sort_subrange (
-  	Iterator first,     Iterator last, 
-  	Iterator sub_first, Iterator sub_last,
-  	Pred p)
-  {
-  	if (sub_first == sub_last) return; // the empty sub-range is already sorted.
-  	
-  	if (sub_first != first) { // sub-range is at the start, don't need to partition
-  		(void) std::nth_element(first, sub_first, last, p);
-  		++sub_first;
-  		}
-  	std::partial_sort(sub_first, sub_last, last, p);
-  }
-
-
-
-  template<typename Iterator> 
-  void sort_subrange (Iterator first, Iterator last, Iterator sub_first, Iterator sub_last)
-  {
-  	typedef typename std::iterator_traits<Iterator>::value_type value_type;
-  	return sort_subrange(first, last, sub_first, sub_last, std::less<value_type>());
-  }
-
-/// range versions?
-
-
-/// \fn partition_subrange ( T const& val, 
-///               Iterator first,     Iterator last, 
-///               Iterator sub_first, Iterator sub_last, 
-///               Pred p )
-/// \brief Gather the elements of the subrange [sub_first, sub_last) that is 
-///     inside the range [first, last) as if you had sorted the entire range.
-/// 
-/// \param first       The start of the larger range
-/// \param last        The end of the larger range
-/// \param sub_first   The start of the sub range
-/// \param sub_last    The end of the sub range
-/// \param p           A predicate to use to compare the values.
-///                        p ( a, b ) returns a boolean.
-///
-  template<typename Iterator, typename Pred> 
-  void partition_subrange (
-  	Iterator first,     Iterator last, 
-  	Iterator sub_first, Iterator sub_last,
-  	Pred p)
-  {
-  	if (sub_first != first) {
-  		(void) std::nth_element(first, sub_first, last, p);
-  		++sub_first;
-  		}
-  	
-  	if (sub_last != last)
-  		(void) std::nth_element(sub_first, sub_last, last, p);
-  }
-
-  template<typename Iterator> 
-  void partition_subrange (Iterator first, Iterator last, Iterator sub_first, Iterator sub_last)
-  {
-  	typedef typename std::iterator_traits<Iterator>::value_type value_type;
-  	return partition_subrange(first, last, sub_first, sub_last, std::less<value_type>());
-  }
-
-}}
-
-#endif // BOOST_ALGORITHM_SORT_SUBRANGE_HPP

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);

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 {
@@ -33,17 +30,15 @@ namespace boost {
 
             // a tolower functor
             template<typename CharT>
-            struct to_lowerF
+            struct to_lowerF : public std::unary_function<CharT, CharT>
             {
-                typedef CharT argument_type;
-                typedef CharT result_type;
                 // Constructor
                 to_lowerF( const std::locale& Loc ) : m_Loc( &Loc ) {}
 
                 // 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 );
@@ -55,17 +50,15 @@ namespace boost {
 
             // a toupper functor
             template<typename CharT>
-            struct to_upperF
+            struct to_upperF : public std::unary_function<CharT, CharT>
             {
-                typedef CharT argument_type;
-                typedef CharT result_type;
                 // Constructor
                 to_upperF( const std::locale& Loc ) : m_Loc( &Loc ) {}
 
                 // 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 );

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
                     {

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 {

include/boost/algorithm/string/detail/find_iterator.hpp

@@ -40,18 +40,10 @@ namespace boost {
             // Protected construction/destruction
 
                 // Default constructor
-                BOOST_DEFAULTED_FUNCTION(find_iterator_base(), {})
-
+                find_iterator_base() {};
                 // Copy construction
-                BOOST_DEFAULTED_FUNCTION(find_iterator_base( const find_iterator_base& Other ), :
+                find_iterator_base( const find_iterator_base& Other ) :
                     m_Finder(Other.m_Finder) {}
-                )
-
-                // Assignment
-                BOOST_DEFAULTED_FUNCTION(find_iterator_base& operator=( const find_iterator_base& Other ), {
-                    m_Finder = Other.m_Finder;
-                    return *this;
-                })
                 
                 // Constructor
                 template<typename FinderT>
@@ -59,7 +51,7 @@ namespace boost {
                     m_Finder(Finder) {}
 
                 // Destructor
-                BOOST_DEFAULTED_FUNCTION(~find_iterator_base(), {})
+                ~find_iterator_base() {}
 
                 // Find operation
                 match_type do_find( 

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() );
             }

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&)
                 {

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() );
             }

include/boost/algorithm/string/detail/util.hpp

@@ -89,10 +89,9 @@ namespace boost {
             template< 
                 typename SeqT, 
                 typename IteratorT=BOOST_STRING_TYPENAME SeqT::const_iterator >
-            struct copy_iterator_rangeF
+            struct copy_iterator_rangeF : 
+                public std::unary_function< iterator_range<IteratorT>, SeqT >
             {
-                typedef iterator_range<IteratorT> argument_type;
-                typedef SeqT result_type;
                 SeqT operator()( const iterator_range<IteratorT>& Range ) const
                 {
                     return copy_range<SeqT>(Range);

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

include/boost/algorithm/string/find_iterator.hpp

@@ -74,7 +74,7 @@ namespace boost {
 
                 \post eof()==true
             */
-            BOOST_DEFAULTED_FUNCTION(find_iterator(), {})
+            find_iterator() {}
 
             //! Copy constructor
             /*!
@@ -85,18 +85,6 @@ namespace boost {
                 m_Match(Other.m_Match),
                 m_End(Other.m_End) {}
 
-            //! Copy assignment
-            /*!
-                Assigns a copy of the find_iterator
-            */
-            BOOST_DEFAULTED_FUNCTION(find_iterator& operator=( const find_iterator& Other ), {
-                if (this == &Other) return *this;
-                this->base_type::operator=(Other);
-                m_Match = Other.m_Match;
-                m_End = Other.m_End;
-                return *this;
-            })
-
             //! Constructor
             /*!
                 Construct new find_iterator for a given finder
@@ -260,20 +248,6 @@ namespace boost {
                 m_bEof(Other.m_bEof)
             {}
 
-            //! Assignment operator
-            /*!
-                Assigns a copy of the split_iterator
-            */
-            BOOST_DEFAULTED_FUNCTION(split_iterator& operator=( const split_iterator& Other ), {
-                if (this == &Other) return *this;
-                this->base_type::operator=(Other);
-                m_Match = Other.m_Match;
-                m_Next = Other.m_Next;
-                m_End = Other.m_End;
-                m_bEof = Other.m_bEof;
-                return *this;
-            })
-
             //! Constructor
             /*!
                 Construct new split_iterator for a given finder

include/boost/algorithm/string/finder.hpp

@@ -43,6 +43,7 @@ namespace boost {
             The result is given as an \c iterator_range delimiting the match.
 
             \param Search A substring to be searched for.
+            \param Comp An element comparison predicate
             \return An instance of the \c first_finder object
         */
         template<typename RangeT>
@@ -83,6 +84,7 @@ namespace boost {
             The result is given as an \c iterator_range delimiting the match.
 
             \param Search A substring to be searched for.
+            \param Comp An element comparison predicate
             \return An instance of the \c last_finder object
         */
         template<typename RangeT>
@@ -122,6 +124,7 @@ namespace boost {
 
             \param Search A substring to be searched for.
             \param Nth An index of the match to be find
+            \param Comp An element comparison predicate
             \return An instance of the \c nth_finder object
         */
         template<typename RangeT>
@@ -227,6 +230,7 @@ namespace boost {
 
             \param Begin Beginning of the range
             \param End End of the range
+            \param Range The range.
             \return An instance of the \c range_finger object
         */
         template< typename ForwardIteratorT >

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>

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((

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( 

include/boost/algorithm/string/replace.hpp

@@ -401,6 +401,7 @@ namespace boost {
             \param Search A substring to be searched for 
             \param Format A substitute string
             \param Loc A locale used for case insensitive comparison
+            \return A reference to the modified input
         */
         template<typename SequenceT, typename Range1T, typename Range2T>
         inline void ireplace_last( 
@@ -642,6 +643,7 @@ namespace boost {
             \param Input An input string
             \param Search A substring to be searched for 
             \param Format A substitute string
+            \return A reference to the modified input
         */
         template<typename SequenceT, typename Range1T, typename Range2T>
         inline void replace_all( 

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 )
         {

meta/libraries.json

@@ -11,8 +11,7 @@
         ],
         "maintainers": [
             "Marshall Clow <marshall -at- idio.com>"
-        ],
-        "cxxstd": "03"
+        ]
     },
     {
         "key": "algorithm/minmax",
@@ -27,8 +26,7 @@
         ],
         "maintainers": [
             "Marshall Clow <marshall -at- idio.com>"
-        ],
-        "cxxstd": "03"
+        ]
     },
     {
         "key": "algorithm/string",
@@ -44,7 +42,6 @@
         ],
         "maintainers": [
             "Marshall Clow <marshall -at- idio.com>"
-        ],
-        "cxxstd": "03"
+        ]
     }
 ]

minmax/doc/minmax_synopsis.html

@@ -24,7 +24,7 @@ namespace boost {
   tuple<T const&, T const&> >
   minmax(const T& a, const T& 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);

minmax/example/minmax_ex.cpp

@@ -8,7 +8,6 @@
 #include <cstdlib>
 #include <cassert>
 #include <iostream>
-#include <iterator>
 
 #include <boost/algorithm/minmax.hpp>
 #include <boost/algorithm/minmax_element.hpp>

minmax/fuzzing/minmax_element.fuzz.cpp

@@ -1,81 +0,0 @@
-//  (C) Copyright Marshall Clow 2018
-//  Use, modification and distribution are subject to 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)
-
-#include <iterator> // for std::distance
-#include <cassert>  // for assert
-
-#include <boost/algorithm/minmax_element.hpp>
-#include <boost/algorithm/cxx11/none_of.hpp>
-
-//	Fuzzing tests for:
-//
-//		template <class ForwardIterator>
-//		std::pair<ForwardIterator,ForwardIterator>
-//		minmax_element(ForwardIterator first, ForwardIterator last);
-//
-//		template <class ForwardIterator, class BinaryPredicate>
-//		std::pair<ForwardIterator,ForwardIterator>
-//		minmax_element(ForwardIterator first, ForwardIterator last,
-//	               		BinaryPredicate comp);
-
-
-bool greater(uint8_t lhs, uint8_t rhs) { return lhs > rhs; }
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t sz) {
-	typedef std::pair<const uint8_t *, const uint8_t *> result_t;
-	if (sz == 0) return 0; // we need at least one element
-	
-	{
-//	Find the min and max
-	result_t result = boost::minmax_element(data, data + sz);
-
-//	The iterators have to be in the sequence - and not at the end!
-	assert(std::distance(data, result.first)  < sz);
-	assert(std::distance(data, result.second) < sz);
-	
-//	the minimum element can't be bigger than the max element
-	uint8_t min_value = *result.first;
-	uint8_t max_value = *result.second;
-	
-	assert(min_value <= max_value);
-
-//	None of the elements in the sequence can be less than the min, nor greater than the max
-	for (size_t i = 0; i < sz; ++i) {
-		assert(min_value <= data[i]);
-		assert(data[i] <= max_value);
-		}
-
-//	We returned the first min element, and the first max element
-	assert(boost::algorithm::none_of_equal(data, result.first,  min_value));
-	assert(boost::algorithm::none_of_equal(data, result.second, max_value));
-	}
-	
-	{
-//	Find the min and max
-	result_t result = boost::minmax_element(data, data + sz, greater);
-
-//	The iterators have to be in the sequence - and not at the end!
-	assert(std::distance(data, result.first)  < sz);
-	assert(std::distance(data, result.second) < sz);
-
-//	the minimum element can't be bigger than the max element
-	uint8_t min_value = *result.first;
-	uint8_t max_value = *result.second;
-	
-	assert (!greater(max_value, min_value));
-
-//	None of the elements in the sequence can be less than the min, nor greater than the max
-	for (size_t i = 0; i < sz; ++i) {
-		assert(!greater(data[i], min_value));
-		assert(!greater(max_value, data[i]));
-		}
-
-//	We returned the first min element, and the first max element
-	assert(boost::algorithm::none_of_equal(data, result.first,  min_value));
-	assert(boost::algorithm::none_of_equal(data, result.second, max_value));
-	}
-
-  return 0;
-}

minmax/fuzzing/minmax_element_variants.fuzz.cpp

@@ -1,141 +0,0 @@
-//  (C) Copyright Marshall Clow 2018
-//  Use, modification and distribution are subject to 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)
-
-#include <iterator> // for std::distance
-#include <cassert>  // for assert
-
-#include <boost/algorithm/minmax_element.hpp>
-#include <boost/algorithm/cxx11/none_of.hpp>
-
-//	Fuzzing tests for:
-//
-//		template <class ForwardIterator>
-//		std::pair<ForwardIterator,ForwardIterator>
-//		first_min_first_max_element(ForwardIterator first, ForwardIterator last);
-//
-//		template <class ForwardIterator, class BinaryPredicate>
-//		std::pair<ForwardIterator,ForwardIterator>
-//		first_min_first_max_element(ForwardIterator first, ForwardIterator last,
-//	               		BinaryPredicate comp);
-//
-//	identical signatures for:
-//		first_min_last_max_element
-//		last_min_first_max_element
-//		last_min_last_max_element
-
-bool greater(uint8_t lhs, uint8_t rhs) { return lhs > rhs; }
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t sz) {
-	typedef std::pair<const uint8_t *, const uint8_t *> result_t;
-	const uint8_t * const dend = data + sz;
-	if (sz == 0) return 0; // we need at least one element
-	
-	{
-//	Find the min and max
-	result_t resultff = boost::first_min_first_max_element(data, dend);
-	result_t resultfl = boost::first_min_last_max_element (data, dend);
-	result_t resultlf = boost::last_min_first_max_element (data, dend);
-	result_t resultll = boost::last_min_last_max_element  (data, dend);
-
-//	The iterators have to be in the sequence - and not at the end!
-	assert(std::distance(data, resultff.first)  < sz);
-	assert(std::distance(data, resultff.second) < sz);
-	assert(std::distance(data, resultfl.first)  < sz);
-	assert(std::distance(data, resultfl.second) < sz);
-	assert(std::distance(data, resultlf.first)  < sz);
-	assert(std::distance(data, resultlf.second) < sz);
-	assert(std::distance(data, resultll.first)  < sz);
-	assert(std::distance(data, resultll.second) < sz);
-	
-//	the minimum element can't be bigger than the max element
-
-//	Did we find the same min value and max value?
-	uint8_t min_value = *resultff.first;
-	uint8_t max_value = *resultff.second;
-	assert(min_value <= max_value);
-
-//	Each variant should have found the same min/max values
-	assert(*resultff.first  == min_value);
-	assert(*resultfl.first  == min_value);
-	assert(*resultlf.first  == min_value);
-	assert(*resultll.first  == min_value);
-
-	assert(*resultff.second == max_value);
-	assert(*resultfl.second == max_value);
-	assert(*resultlf.second == max_value);
-	assert(*resultll.second == max_value);
-
-//	None of the elements in the sequence can be less than the min, nor greater than the max
-	for (size_t i = 0; i < sz; ++i) {
-		assert(min_value <= data[i]);
-		assert(data[i] <= max_value);
-		}
-
-//	Make sure we returned the "right" first and last element
-	assert(boost::algorithm::none_of_equal(data, resultff.first,     min_value));
-	assert(boost::algorithm::none_of_equal(data, resultfl.first,     min_value));
-	assert(boost::algorithm::none_of_equal(resultlf.first + 1, dend, min_value));
-	assert(boost::algorithm::none_of_equal(resultll.first + 1, dend, min_value));
-
-	assert(boost::algorithm::none_of_equal(data, resultff.second,     max_value));
-	assert(boost::algorithm::none_of_equal(resultfl.second + 1, dend, max_value));
-	assert(boost::algorithm::none_of_equal(data, resultlf.second,     max_value));
-	assert(boost::algorithm::none_of_equal(resultll.second + 1, dend, max_value));
-	}
-	
-	{
-//	Find the min and max
-	result_t resultff = boost::first_min_first_max_element(data, dend, greater);
-	result_t resultfl = boost::first_min_last_max_element (data, dend, greater);
-	result_t resultlf = boost::last_min_first_max_element (data, dend, greater);
-	result_t resultll = boost::last_min_last_max_element  (data, dend, greater);
-
-//	The iterators have to be in the sequence - and not at the end!
-	assert(std::distance(data, resultff.first)  < sz);
-	assert(std::distance(data, resultff.second) < sz);
-	assert(std::distance(data, resultfl.first)  < sz);
-	assert(std::distance(data, resultfl.second) < sz);
-	assert(std::distance(data, resultlf.first)  < sz);
-	assert(std::distance(data, resultlf.second) < sz);
-	assert(std::distance(data, resultll.first)  < sz);
-	assert(std::distance(data, resultll.second) < sz);
-
-//	the minimum element can't be bigger than the max element
-	uint8_t min_value = *resultff.first;
-	uint8_t max_value = *resultff.second;
-	
-	assert (!greater(max_value, min_value));
-
-//	Each variant should have found the same min/max values
-	assert(*resultff.first  == min_value);
-	assert(*resultfl.first  == min_value);
-	assert(*resultlf.first  == min_value);
-	assert(*resultll.first  == min_value);
-
-	assert(*resultff.second == max_value);
-	assert(*resultfl.second == max_value);
-	assert(*resultlf.second == max_value);
-	assert(*resultll.second == max_value);
-
-//	None of the elements in the sequence can be less than the min, nor greater than the max
-	for (size_t i = 0; i < sz; ++i) {
-		assert(!greater(data[i], min_value));
-		assert(!greater(max_value, data[i]));
-		}
-
-//	We returned the first min element, and the first max element
-	assert(boost::algorithm::none_of_equal(data, resultff.first,     min_value));
-	assert(boost::algorithm::none_of_equal(data, resultfl.first,     min_value));
-	assert(boost::algorithm::none_of_equal(resultlf.first + 1, dend, min_value));
-	assert(boost::algorithm::none_of_equal(resultll.first + 1, dend, min_value));
-
-	assert(boost::algorithm::none_of_equal(data, resultff.second,     max_value));
-	assert(boost::algorithm::none_of_equal(resultfl.second + 1, dend, max_value));
-	assert(boost::algorithm::none_of_equal(data, resultlf.second,     max_value));
-	assert(boost::algorithm::none_of_equal(resultll.second + 1, dend, max_value));
-	}
-
-  return 0;
-}

minmax/index.html

@@ -95,7 +95,7 @@ namespace boost {
   tuple<T const&, T const&>
   minmax(const T& a, const T& 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

minmax/test/Jamfile.v2

@@ -15,7 +15,7 @@ alias unit_test_framework
     ;        
 
 {
-  test-suite algorithm/minmax
+  test-suite algorithm/minmax:
    : [ run minmax_element_test.cpp unit_test_framework
        : : : : minmax_element ]
      [ run minmax_test.cpp unit_test_framework

minmax/test/minmax_element_test.cpp

@@ -20,19 +20,6 @@
 #define BOOST_TEST_MAIN
 #include <boost/test/unit_test.hpp>
 
-#if (__cplusplus >= 201103L) || defined(BOOST_NO_CXX98_RANDOM_SHUFFLE)
-#include <random>
-
-std::default_random_engine gen;
-template<typename RandomIt>
-void do_shuffle(RandomIt first, RandomIt last)
-{ std::shuffle(first, last, gen); }
-#else
-template<typename RandomIt>
-void do_shuffle(RandomIt first, RandomIt last)
-{ std::random_shuffle(first, last); }
-#endif
-
 class custom {
   int m_x;
   friend bool operator<(custom const& x, custom const& y);
@@ -130,7 +117,7 @@ void test_minmax(CIterator first, CIterator last, int n)
 
   CHECK_EQUAL_ITERATORS( min, std::min_element(first, last), first );
   CHECK_EQUAL_ITERATORS( max, std::max_element(first, last), first );
-
+  
   // second version, comp function object (keeps a counter!)
   lc.reset();
   tie( boost::minmax_element(first, last, lc), min, max );
@@ -196,7 +183,7 @@ void test_minmax(CIterator first, CIterator last, int n)
 
 template <class Container, class Iterator, class Value>
 void test_container(Iterator first, Iterator last, int n,
-                    Container* /* dummy */ = 0
+                    Container* dummy = 0
                     BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Value) )
 {
   Container c(first, last);
@@ -236,7 +223,7 @@ void test(int n BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Value))
   test_range(first, last, n);
 
   // Populate test vector with random values
-  do_shuffle(first, last);
+  std::random_shuffle(first, last);
   test_range(first, last, n);
 }
 

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>)

string/doc/usage.xml

@@ -265,7 +265,7 @@
         <title>Find Iterator</title>
 
         <para>
-            An extension to find algorithms is the Find Iterator. Instead of searching for just a one part of a string, 
+            An extension to find algorithms it the Find Iterator. Instead of searching for just a one part of a string, 
             the find iterator allows us to iterate over the substrings matching the specified criteria.
             This facility is using the <link linkend="string_algo.finder_concept">Finder</link> to incrementally
             search the string. 

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;

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 );
             }
         }