Merge bug fixes to master for 1.71

Use forwarding references in string/split.hpp

.travis.yml

@@ -0,0 +1,171 @@
+# Copyright 2016, 2017, 2018 Peter Dimov
+# 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://boost.org/LICENSE_1_0.txt)
+
+language: cpp
+
+sudo: false
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=11
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=11
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=11
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=11,14,1z CXXSTD_DIALECT=cxxstd-dialect=gnu
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11
+
+    - os: linux
+      compiler: clang++-libc++
+      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=11,14,1z
+      addons:
+        apt:
+          packages:
+            - libc++-dev
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z
+      osx_image: xcode9.1
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z
+      osx_image: xcode9
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z
+      osx_image: xcode8.3
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z
+      osx_image: xcode8
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z
+      osx_image: xcode7.3
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z
+      osx_image: xcode6.4
+
+install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - cd ..
+  - git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init libs/predef
+  - git submodule update --init libs/core
+  - git submodule update --init libs/detail
+  - git submodule update --init libs/range
+  - git submodule update --init libs/assert
+  - git submodule update --init libs/array
+  - git submodule update --init libs/type_traits
+  - git submodule update --init libs/static_assert
+  - git submodule update --init libs/iterator
+  - git submodule update --init libs/preprocessor
+  - git submodule update --init libs/mpl
+  - git submodule update --init libs/smart_ptr
+  - git submodule update --init libs/callable_traits
+  - git submodule update --init libs/type_index
+  - git submodule update --init libs/exception
+  - git submodule update --init libs/throw_exception
+  - git submodule update --init libs/utility
+  - git submodule update --init libs/bind
+  - git submodule update --init libs/ratio
+  - git submodule update --init libs/function
+  - git submodule update --init libs/integer
+  - git submodule update --init libs/numeric
+  - git submodule update --init libs/move
+  - git submodule update --init libs/container_hash
+  - git submodule update --init libs/io
+  - git submodule update --init libs/concept_check
+  - git submodule update --init libs/test
+  - git submodule update --init libs/timer
+  - git submodule update --init libs/chrono
+  - git submodule update --init libs/system
+  - cp -r $TRAVIS_BUILD_DIR/* libs/algorithm
+  - ./bootstrap.sh
+  - ./b2 headers
+ 
+script:
+  - |-
+    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - ./b2 -j3 libs/algorithm/test toolset=$TOOLSET cxxstd=$CXXSTD $CXXSTD_DIALECT

appveyor.yml

@@ -0,0 +1,93 @@
+# Copyright 2016 Peter Dimov
+# 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)
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+
+platform:
+  - x64
+
+environment:
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      ARGS: --toolset=msvc-14.1 address-model=64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      ARGS: --toolset=msvc-14.1 address-model=32
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      ARGS: --toolset=msvc-14.1 address-model=64 cxxflags=-std:c++latest cxxflags=-permissive-
+    - ARGS: --toolset=msvc-9.0  address-model=32
+    - ARGS: --toolset=msvc-10.0 address-model=32
+    - ARGS: --toolset=msvc-11.0 address-model=32
+    - ARGS: --toolset=msvc-12.0 address-model=32
+    - ARGS: --toolset=msvc-14.0 address-model=32
+    - ARGS: --toolset=msvc-12.0 address-model=64
+    - ARGS: --toolset=msvc-14.0 address-model=64
+    - ARGS: --toolset=msvc-14.0 address-model=64 cxxflags=-std:c++latest
+    - ARGS: --toolset=gcc address-model=64 
+      CXXSTD: 03,11,14,1z
+      PATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH%
+    - ARGS: --toolset=gcc address-model=64
+      CXXSTD: 03,11,14,1z
+      PATH: C:\mingw-w64\x86_64-7.2.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH%
+    - ARGS: --toolset=gcc address-model=32 linkflags=-Wl,-allow-multiple-definition
+      CXXSTD: 03,11,14,1z
+      PATH: C:\MinGW\bin;%PATH%
+    - ARGS: --toolset=gcc address-model=64
+      CXXSTD: 03,11,14,1z
+      PATH: C:\cygwin64\bin;%PATH%
+    - ARGS: --toolset=gcc address-model=32
+      CXXSTD: 03,11,14,1z
+      PATH: C:\cygwin\bin;%PATH%
+
+install:
+  - cd ..
+  - git clone -b %APPVEYOR_REPO_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\algorithm
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init libs/predef
+  - git submodule update --init libs/core
+  - git submodule update --init libs/detail
+  - git submodule update --init libs/range
+  - git submodule update --init libs/assert
+  - git submodule update --init libs/array
+  - git submodule update --init libs/type_traits
+  - git submodule update --init libs/static_assert
+  - git submodule update --init libs/iterator
+  - git submodule update --init libs/preprocessor
+  - git submodule update --init libs/mpl
+  - git submodule update --init libs/smart_ptr
+  - git submodule update --init libs/callable_traits
+  - git submodule update --init libs/type_index
+  - git submodule update --init libs/exception
+  - git submodule update --init libs/throw_exception
+  - git submodule update --init libs/utility
+  - git submodule update --init libs/bind
+  - git submodule update --init libs/ratio
+  - git submodule update --init libs/function
+  - git submodule update --init libs/integer
+  - git submodule update --init libs/numeric
+  - git submodule update --init libs/move
+  - git submodule update --init libs/container_hash
+  - git submodule update --init libs/io
+  - git submodule update --init libs/concept_check
+  - git submodule update --init libs/test
+  - git submodule update --init libs/timer
+  - git submodule update --init libs/chrono
+  - git submodule update --init libs/system
+  - bootstrap
+  - b2 headers
+  
+build: off
+
+test_script:
+  - cd libs\config\test
+  - ..\..\..\b2 -j3 %ARGS% cxxstd=%CXXSTD%

doc/algorithm.qbk

@@ -64,10 +64,13 @@ Thanks to all the people who have reviewed this library and made suggestions for
 
 [section:Misc Other Algorithms]
 [include clamp-hpp.qbk]
+[include find_not.qbk]
+[include find_backward.qbk]
 [include gather.qbk]
 [include hex.qbk]
 [include is_palindrome.qbk]
 [include is_partitioned_until.qbk]
+[include apply_permutation.qbk]
 [endsect]
 
 

doc/apply_permutation.qbk

@@ -0,0 +1,96 @@
+[/ 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 'apply_permutation.hpp' contains two algorithms, apply_permutation and apply_reverse_permutation. Also there are range-based versions. 
+The algorithms transform the item sequence according to index sequence order.
+
+The routine `apply_permutation` takes a item sequence and a order sequence. It reshuffles item sequence according to order sequence. Every value in order sequence means where the item comes from. Order sequence needs to be exactly a permutation of the sequence [0, 1, ... , N], where N is the biggest index in the item sequence (zero-indexed).
+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://blogs.msdn.microsoft.com/oldnewthing/20170102-00/?p=95095
+https://blogs.msdn.microsoft.com/oldnewthing/20170103-00/?p=95105
+https://blogs.msdn.microsoft.com/oldnewthing/20170104-00/?p=95115
+https://blogs.msdn.microsoft.com/oldnewthing/20170109-00/?p=95145
+https://blogs.msdn.microsoft.com/oldnewthing/20170110-00/?p=95155
+https://blogs.msdn.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/find_backward.qbk

@@ -0,0 +1,116 @@
+[/ 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

@@ -0,0 +1,83 @@
+[/ 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/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_equal 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` is used (i.e, the test is to see if the sequence is non-decreasing)
 
 ``
 namespace boost { namespace algorithm {

example/Jamfile.v2

@@ -22,4 +22,4 @@ exe clamp_example   : clamp_example.cpp ;
 exe search_example  : search_example.cpp ;
 exe is_palindrome_example  : is_palindrome_example.cpp;
 exe is_partitioned_until_example  : is_partitioned_until_example.cpp;
-
+exe apply_permutation_example  : apply_permutation_example.cpp;

example/apply_permutation_example.cpp

@@ -0,0 +1,69 @@
+/*
+  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;
+}
+

include/boost/algorithm/algorithm.hpp

@@ -25,10 +25,10 @@
 namespace boost { namespace algorithm {
 
 template <typename T>
-T identity_operation ( std::multiplies<T> ) { return T(1); }
+BOOST_CXX14_CONSTEXPR T identity_operation ( std::multiplies<T> ) { return T(1); }
 
 template <typename T>
-T identity_operation ( std::plus<T> ) { return T(0); }
+BOOST_CXX14_CONSTEXPR T identity_operation ( std::plus<T> ) { return T(0); }
 
 
 /// \fn power ( T x, Integer n )
@@ -40,7 +40,7 @@ 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>
-typename boost::enable_if<boost::is_integral<Integer>, T>::type
+BOOST_CXX14_CONSTEXPR 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;
@@ -67,7 +67,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>
-typename boost::enable_if<boost::is_integral<Integer>, T>::type
+BOOST_CXX14_CONSTEXPR 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

@@ -0,0 +1,126 @@
+/*
+  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 <type_traits>
+
+#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

@@ -46,7 +46,7 @@ namespace boost { namespace algorithm {
 ///                 p ( a, b ) returns a boolean.
 ///
   template<typename T, typename Pred> 
-  T const & clamp ( T const& val, 
+  BOOST_CXX14_CONSTEXPR T const & clamp ( T const& val, 
     typename boost::mpl::identity<T>::type const & lo, 
     typename boost::mpl::identity<T>::type const & hi, Pred p )
   {
@@ -68,11 +68,11 @@ namespace boost { namespace algorithm {
 /// \param hi    The upper bound of the range to be clamped to
 ///
   template<typename T> 
-  T const& clamp ( const T& val, 
+  BOOST_CXX14_CONSTEXPR T const& clamp ( const T& val, 
     typename boost::mpl::identity<T>::type const & lo, 
     typename boost::mpl::identity<T>::type const & hi )
   {
-    return (clamp) ( val, lo, hi, std::less<T>());
+    return boost::algorithm::clamp ( val, lo, hi, std::less<T>());
   } 
 
 /// \fn clamp_range ( InputIterator first, InputIterator last, OutputIterator out, 
@@ -87,13 +87,13 @@ namespace boost { namespace algorithm {
 /// \param hi    The upper bound of the range to be clamped to
 ///
   template<typename InputIterator, typename OutputIterator> 
-  OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out,
+  BOOST_CXX14_CONSTEXPR 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++ = clamp ( *first++, lo, hi );
+        *out++ = boost::algorithm::clamp ( *first++, lo, hi );
     return out;
   } 
 
@@ -108,12 +108,12 @@ namespace boost { namespace algorithm {
 /// \param hi    The upper bound of the range to be clamped to
 ///
   template<typename Range, typename OutputIterator> 
-  typename boost::disable_if_c<boost::is_same<Range, OutputIterator>::value, OutputIterator>::type
+  BOOST_CXX14_CONSTEXPR 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 clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi );
+    return boost::algorithm::clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi );
   } 
 
 
@@ -133,13 +133,13 @@ namespace boost { namespace algorithm {
 
 ///
   template<typename InputIterator, typename OutputIterator, typename Pred> 
-  OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out,
+  BOOST_CXX14_CONSTEXPR 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++ = clamp ( *first++, lo, hi, p );
+        *out++ = boost::algorithm::clamp ( *first++, lo, hi, p );
     return out;
   } 
 
@@ -160,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> 
-  typename boost::disable_if_c<boost::is_same<Range, OutputIterator>::value, OutputIterator>::type
+  BOOST_CXX14_CONSTEXPR 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 clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi, p );
+    return boost::algorithm::clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi, p );
   } 
 
 

include/boost/algorithm/cxx11/all_of.hpp

@@ -27,7 +27,7 @@ namespace boost { namespace algorithm {
 ///
 /// \note           This function is part of the C++2011 standard library.
 template<typename InputIterator, typename Predicate> 
-bool all_of ( InputIterator first, InputIterator last, Predicate p )
+BOOST_CXX14_CONSTEXPR bool all_of ( InputIterator first, InputIterator last, Predicate p )
 {
     for ( ; first != last; ++first )
         if ( !p(*first)) 
@@ -43,7 +43,7 @@ bool all_of ( InputIterator first, InputIterator last, Predicate p )
 /// \param p    A predicate for testing the elements of the range
 ///
 template<typename Range, typename Predicate> 
-bool all_of ( const Range &r, Predicate p )
+BOOST_CXX14_CONSTEXPR bool all_of ( const Range &r, Predicate p )
 {
     return boost::algorithm::all_of ( boost::begin (r), boost::end (r), p );
 } 
@@ -57,7 +57,7 @@ bool all_of ( const Range &r, Predicate p )
 /// \param val   A value to compare against
 ///
 template<typename InputIterator, typename T> 
-bool all_of_equal ( InputIterator first, InputIterator last, const T &val )
+BOOST_CXX14_CONSTEXPR bool all_of_equal ( InputIterator first, InputIterator last, const T &val )
 {
     for ( ; first != last; ++first )
     if ( val != *first ) 
@@ -73,7 +73,7 @@ bool all_of_equal ( InputIterator first, InputIterator last, const T &val )
 /// \param val  A value to compare against
 ///
 template<typename Range, typename T> 
-bool all_of_equal ( const Range &r, const T &val ) 
+BOOST_CXX14_CONSTEXPR 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

@@ -28,7 +28,7 @@ namespace boost { namespace algorithm {
 /// \param p     A predicate for testing the elements of the sequence
 ///
 template<typename InputIterator, typename Predicate> 
-bool any_of ( InputIterator first, InputIterator last, Predicate p ) 
+BOOST_CXX14_CONSTEXPR bool any_of ( InputIterator first, InputIterator last, Predicate p ) 
 {
     for ( ; first != last; ++first )
         if ( p(*first)) 
@@ -44,7 +44,7 @@ bool any_of ( InputIterator first, InputIterator last, Predicate p )
 /// \param p    A predicate for testing the elements of the range
 ///
 template<typename Range, typename Predicate> 
-bool any_of ( const Range &r, Predicate p )
+BOOST_CXX14_CONSTEXPR bool any_of ( const Range &r, Predicate p )
 {
     return boost::algorithm::any_of (boost::begin (r), boost::end (r), p);
 } 
@@ -58,7 +58,7 @@ bool any_of ( const Range &r, Predicate p )
 /// \param val   A value to compare against
 ///
 template<typename InputIterator, typename V> 
-bool any_of_equal ( InputIterator first, InputIterator last, const V &val ) 
+BOOST_CXX14_CONSTEXPR bool any_of_equal ( InputIterator first, InputIterator last, const V &val ) 
 {
     for ( ; first != last; ++first )
         if ( val == *first )
@@ -74,7 +74,7 @@ bool any_of_equal ( InputIterator first, InputIterator last, const V &val )
 /// \param val   A value to compare against
 ///
 template<typename Range, typename V> 
-bool any_of_equal ( const Range &r, const V &val ) 
+BOOST_CXX14_CONSTEXPR 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

@@ -29,7 +29,7 @@ namespace boost { namespace algorithm {
 /// \param p        A predicate for testing the elements of the range
 /// \note           This function is part of the C++2011 standard library.
 template<typename InputIterator, typename OutputIterator, typename Predicate> 
-OutputIterator copy_if ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
+BOOST_CXX14_CONSTEXPR OutputIterator copy_if ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
 {
     for ( ; first != last; ++first )
         if (p(*first))
@@ -47,7 +47,7 @@ OutputIterator copy_if ( InputIterator first, InputIterator last, OutputIterator
 /// \param p        A predicate for testing the elements of the range
 ///
 template<typename Range, typename OutputIterator, typename Predicate>
-OutputIterator copy_if ( const Range &r, OutputIterator result, Predicate p )
+BOOST_CXX14_CONSTEXPR OutputIterator copy_if ( const Range &r, OutputIterator result, Predicate p )
 {
     return boost::algorithm::copy_if (boost::begin (r), boost::end(r), result, p);
 }
@@ -64,7 +64,7 @@ OutputIterator copy_if ( 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> 
-std::pair<InputIterator, OutputIterator>
+BOOST_CXX14_CONSTEXPR std::pair<InputIterator, OutputIterator>
 copy_while ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
 {
     for ( ; first != last && p(*first); ++first )
@@ -82,7 +82,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>
-std::pair<typename boost::range_iterator<const Range>::type, OutputIterator> 
+BOOST_CXX14_CONSTEXPR 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);
@@ -100,7 +100,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> 
-std::pair<InputIterator, OutputIterator>
+BOOST_CXX14_CONSTEXPR std::pair<InputIterator, OutputIterator>
 copy_until ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
 {
     for ( ; first != last && !p(*first); ++first )
@@ -118,7 +118,7 @@ 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>
-std::pair<typename boost::range_iterator<const Range>::type, OutputIterator> 
+BOOST_CXX14_CONSTEXPR 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);

include/boost/algorithm/cxx11/copy_n.hpp

@@ -24,7 +24,7 @@ namespace boost { namespace algorithm {
 /// \param result   An output iterator to write the results into
 /// \note           This function is part of the C++2011 standard library.
 template <typename InputIterator, typename Size, typename OutputIterator>
-OutputIterator copy_n ( InputIterator first, Size n, OutputIterator result )
+BOOST_CXX14_CONSTEXPR 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

@@ -26,7 +26,7 @@ namespace boost { namespace algorithm {
 /// \param p        A predicate for testing the elements of the range
 /// \note           This function is part of the C++2011 standard library.
 template<typename InputIterator, typename Predicate> 
-InputIterator find_if_not ( InputIterator first, InputIterator last, Predicate p )
+BOOST_CXX14_CONSTEXPR InputIterator find_if_not ( InputIterator first, InputIterator last, Predicate p )
 {
     for ( ; first != last; ++first )
         if ( !p(*first))
@@ -42,7 +42,7 @@ InputIterator find_if_not ( InputIterator first, InputIterator last, Predicate p
 /// \param p        A predicate for testing the elements of the range
 ///
 template<typename Range, typename Predicate>
-typename boost::range_iterator<const Range>::type find_if_not ( const Range &r, Predicate p )
+BOOST_CXX14_CONSTEXPR 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

@@ -25,7 +25,7 @@ namespace boost { namespace algorithm {
 /// \param value    The initial value of the sequence to be generated
 /// \note           This function is part of the C++2011 standard library.
 template <typename ForwardIterator, typename T>
-void iota ( ForwardIterator first, ForwardIterator last, T value )
+BOOST_CXX14_CONSTEXPR void iota ( ForwardIterator first, ForwardIterator last, T value )
 {
     for ( ; first != last; ++first, ++value )
         *first = value;
@@ -38,7 +38,7 @@ void iota ( ForwardIterator first, ForwardIterator last, T value )
 /// \param value    The initial value of the sequence to be generated
 ///
 template <typename Range, typename T>
-void iota ( Range &r, T value )
+BOOST_CXX14_CONSTEXPR void iota ( Range &r, T value )
 {
     boost::algorithm::iota (boost::begin(r), boost::end(r), value);
 }
@@ -52,7 +52,7 @@ void iota ( Range &r, T value )
 /// \param n        The number of items to write
 ///
 template <typename OutputIterator, typename T>
-OutputIterator iota_n ( OutputIterator out, T value, std::size_t n )
+BOOST_CXX14_CONSTEXPR 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

@@ -26,7 +26,7 @@ namespace boost { namespace algorithm {
 /// \param p        The predicate to test the values with
 /// \note           This function is part of the C++2011 standard library.
 template <typename InputIterator, typename UnaryPredicate>
-bool is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p )
+BOOST_CXX14_CONSTEXPR bool is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p )
 {
 //  Run through the part that satisfy the predicate
     for ( ; first != last; ++first )
@@ -47,7 +47,7 @@ bool is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p
 /// \param p        The predicate to test the values with
 ///
 template <typename Range, typename UnaryPredicate>
-bool is_partitioned ( const Range &r, UnaryPredicate p )
+BOOST_CXX14_CONSTEXPR 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_sorted.hpp

@@ -34,7 +34,7 @@ namespace boost { namespace algorithm {
 /// \param p     A binary predicate that returns true if two elements are ordered.
 ///
     template <typename ForwardIterator, typename Pred>
-    ForwardIterator is_sorted_until ( ForwardIterator first, ForwardIterator last, Pred p )
+    BOOST_CXX14_CONSTEXPR ForwardIterator is_sorted_until ( ForwardIterator first, ForwardIterator last, Pred p )
     {
         if ( first == last ) return last;  // the empty sequence is ordered
         ForwardIterator next = first;
@@ -54,7 +54,7 @@ namespace boost { namespace algorithm {
 /// \param last  One past the end of the sequence
 ///
     template <typename ForwardIterator>
-    ForwardIterator is_sorted_until ( ForwardIterator first, ForwardIterator last )
+    BOOST_CXX14_CONSTEXPR 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>());
@@ -69,7 +69,7 @@ namespace boost { namespace algorithm {
 /// \param p     A binary predicate that returns true if two elements are ordered.
 ///
     template <typename ForwardIterator, typename Pred>
-    bool is_sorted ( ForwardIterator first, ForwardIterator last, Pred p )
+    BOOST_CXX14_CONSTEXPR bool is_sorted ( ForwardIterator first, ForwardIterator last, Pred p )
     {
         return boost::algorithm::is_sorted_until (first, last, p) == last;
     }
@@ -81,7 +81,7 @@ namespace boost { namespace algorithm {
 /// \param last  One past the end of the sequence
 ///
     template <typename ForwardIterator>
-    bool is_sorted ( ForwardIterator first, ForwardIterator last )
+    BOOST_CXX14_CONSTEXPR bool is_sorted ( ForwardIterator first, ForwardIterator last )
     {
         return boost::algorithm::is_sorted_until (first, last) == last;
     }
@@ -98,7 +98,7 @@ namespace boost { namespace algorithm {
 /// \param p     A binary predicate that returns true if two elements are ordered.
 ///
     template <typename R, typename Pred>
-    typename boost::lazy_disable_if_c<
+    BOOST_CXX14_CONSTEXPR 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 )
@@ -113,7 +113,7 @@ namespace boost { namespace algorithm {
 /// \param range The range to be tested.
 ///
     template <typename R>
-    typename boost::range_iterator<const R>::type is_sorted_until ( const R &range )
+    BOOST_CXX14_CONSTEXPR 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 ));
     }
@@ -126,7 +126,7 @@ namespace boost { namespace algorithm {
 /// \param p     A binary predicate that returns true if two elements are ordered.
 ///
     template <typename R, typename Pred>
-    typename boost::lazy_disable_if_c< boost::is_same<R, Pred>::value, boost::mpl::identity<bool> >::type
+    BOOST_CXX14_CONSTEXPR 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 );
@@ -139,7 +139,7 @@ namespace boost { namespace algorithm {
 /// \param range The range to be tested.
 ///
     template <typename R>
-    bool is_sorted ( const R &range )
+    BOOST_CXX14_CONSTEXPR bool is_sorted ( const R &range )
     {
         return boost::algorithm::is_sorted ( boost::begin ( range ), boost::end ( range ));
     }
@@ -159,7 +159,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>
-    bool is_increasing ( ForwardIterator first, ForwardIterator last )
+    BOOST_CXX14_CONSTEXPR 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>());
@@ -175,7 +175,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>
-    bool is_increasing ( const R &range )
+    BOOST_CXX14_CONSTEXPR bool is_increasing ( const R &range )
     {
         return is_increasing ( boost::begin ( range ), boost::end ( range ));
     }
@@ -192,7 +192,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>
-    bool is_decreasing ( ForwardIterator first, ForwardIterator last )
+    BOOST_CXX14_CONSTEXPR 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>());
@@ -207,7 +207,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>
-    bool is_decreasing ( const R &range )
+    BOOST_CXX14_CONSTEXPR bool is_decreasing ( const R &range )
     {
         return is_decreasing ( boost::begin ( range ), boost::end ( range ));
     }
@@ -224,7 +224,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>
-    bool is_strictly_increasing ( ForwardIterator first, ForwardIterator last )
+    BOOST_CXX14_CONSTEXPR 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>());
@@ -239,7 +239,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>
-    bool is_strictly_increasing ( const R &range )
+    BOOST_CXX14_CONSTEXPR bool is_strictly_increasing ( const R &range )
     {
         return is_strictly_increasing ( boost::begin ( range ), boost::end ( range ));
     }
@@ -255,7 +255,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>
-    bool is_strictly_decreasing ( ForwardIterator first, ForwardIterator last )
+    BOOST_CXX14_CONSTEXPR 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>());
@@ -270,7 +270,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>
-    bool is_strictly_decreasing ( const R &range )
+    BOOST_CXX14_CONSTEXPR bool is_strictly_decreasing ( const R &range )
     {
         return is_strictly_decreasing ( boost::begin ( range ), boost::end ( range ));
     }

include/boost/algorithm/cxx11/none_of.hpp

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

@@ -14,6 +14,7 @@
 
 #include <utility>  // for std::pair
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
@@ -35,7 +36,7 @@ namespace boost { namespace algorithm {
 /// \note            This function is part of the C++2011 standard library.
 template <typename InputIterator, 
         typename OutputIterator1, typename OutputIterator2, typename UnaryPredicate>
-std::pair<OutputIterator1, OutputIterator2>
+BOOST_CXX14_CONSTEXPR std::pair<OutputIterator1, OutputIterator2>
 partition_copy ( InputIterator first, InputIterator last,
         OutputIterator1 out_true, OutputIterator2 out_false, UnaryPredicate p )
 {
@@ -57,7 +58,7 @@ partition_copy ( InputIterator first, InputIterator last,
 ///
 template <typename Range, typename OutputIterator1, typename OutputIterator2, 
             typename UnaryPredicate>
-std::pair<OutputIterator1, OutputIterator2>
+BOOST_CXX14_CONSTEXPR std::pair<OutputIterator1, OutputIterator2>
 partition_copy ( const Range &r, OutputIterator1 out_true, OutputIterator2 out_false, 
                                 UnaryPredicate p )
 {

include/boost/algorithm/cxx14/equal.hpp

@@ -12,7 +12,6 @@
 #ifndef BOOST_ALGORITHM_EQUAL_HPP
 #define BOOST_ALGORITHM_EQUAL_HPP
 
-#include <algorithm>    // for std::equal
 #include <iterator>
 
 namespace boost { namespace algorithm {
@@ -21,10 +20,11 @@ namespace detail {
 
     template <class T1, class T2>
     struct eq {
-        bool operator () ( const T1& v1, const T2& v2 ) const { return v1 == v2 ;}
+        BOOST_CONSTEXPR 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 )
@@ -32,11 +32,16 @@ namespace detail {
     //  Random-access iterators let is check the sizes in constant time
         if ( std::distance ( first1, last1 ) != std::distance ( first2, last2 ))
             return false;
-    // If we know that the sequences are the same size, the original version is fine
-        return std::equal ( first1, last1, first2, pred );
+
+    //  std::equal
+        for (; first1 != last1; ++first1, ++first2)
+            if (!pred(*first1, *first2))
+                return false;
+        return true;
     }
 
     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 )
@@ -60,6 +65,7 @@ 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 )
 {
@@ -78,6 +84,7 @@ 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/mismatch.hpp

@@ -2,7 +2,7 @@
    Copyright (c) Marshall Clow 2008-2012.
 
    Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
 
 /// \file  mismatch.hpp
@@ -13,6 +13,7 @@
 #define BOOST_ALGORITHM_MISMATCH_HPP
 
 #include <utility>      // for std::pair
+#include <boost/config.hpp>
 
 namespace boost { namespace algorithm {
 
@@ -27,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>
-std::pair<InputIterator1, InputIterator2> mismatch (
+BOOST_CXX14_CONSTEXPR std::pair<InputIterator1, InputIterator2> mismatch (
                     InputIterator1 first1, InputIterator1 last1,
                     InputIterator2 first2, InputIterator2 last2,
                     BinaryPredicate pred )
@@ -47,7 +48,7 @@ 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>
-std::pair<InputIterator1, InputIterator2> mismatch (
+BOOST_CXX14_CONSTEXPR std::pair<InputIterator1, InputIterator2> mismatch (
                     InputIterator1 first1, InputIterator1 last1,
                     InputIterator2 first2, InputIterator2 last2 )
 {

include/boost/algorithm/cxx17/exclusive_scan.hpp

@@ -2,7 +2,7 @@
    Copyright (c) Marshall Clow 2017.
 
    Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
 
 /// \file  exclusive_scan.hpp
@@ -44,7 +44,7 @@ OutputIterator exclusive_scan(InputIterator first, InputIterator last,
                               OutputIterator result, T init)
 {
 	typedef typename std::iterator_traits<InputIterator>::value_type VT;
-    return exclusive_scan(first, last, result, init, std::plus<VT>());
+    return boost::algorithm::exclusive_scan(first, last, result, init, std::plus<VT>());
 }
 
 }} // namespace boost and algorithm

include/boost/algorithm/cxx17/for_each_n.hpp

@@ -2,7 +2,7 @@
    Copyright (c) Marshall Clow 2017.
 
    Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
 
 /// \file  for_each_n.hpp

include/boost/algorithm/cxx17/inclusive_scan.hpp

@@ -2,7 +2,7 @@
    Copyright (c) Marshall Clow 2017.
 
    Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
 
 /// \file  transform_reduce.hpp
@@ -41,7 +41,7 @@ OutputIterator inclusive_scan(InputIterator first, InputIterator last,
         typename std::iterator_traits<InputIterator>::value_type init = *first;
         *result++ = init;
         if (++first != last)
-            return inclusive_scan(first, last, result, bOp, init);
+            return boost::algorithm::inclusive_scan(first, last, result, bOp, init);
         }
 
     return result;
@@ -52,7 +52,7 @@ OutputIterator inclusive_scan(InputIterator first, InputIterator last,
                    OutputIterator result)
 {
     typedef typename std::iterator_traits<InputIterator>::value_type VT;
-    return inclusive_scan(first, last, result, std::plus<VT>());
+    return boost::algorithm::inclusive_scan(first, last, result, std::plus<VT>());
 }
 
 }} // namespace boost and algorithm

include/boost/algorithm/cxx17/reduce.hpp

@@ -2,7 +2,7 @@
    Copyright (c) Marshall Clow 2017.
 
    Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
 
 /// \file  reduce.hpp
@@ -34,14 +34,14 @@ template<class InputIterator, class T>
 T reduce(InputIterator first, InputIterator last, T init)
 {
 	typedef typename std::iterator_traits<InputIterator>::value_type VT;
-    return reduce(first, last, init, std::plus<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 reduce(first, last,
+    return boost::algorithm::reduce(first, last,
        typename std::iterator_traits<InputIterator>::value_type());
 }
 
@@ -49,14 +49,14 @@ template<class Range>
 typename boost::range_value<Range>::type
 reduce(const Range &r)
 {
-    return reduce(boost::begin(r), boost::end(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 reduce(boost::begin (r), boost::end (r), init);
+    return boost::algorithm::reduce(boost::begin (r), boost::end (r), init);
 }
 
 
@@ -64,7 +64,7 @@ T reduce(const Range &r, T init)
 template<class Range, class T, class BinaryOperation>
 T reduce(const Range &r, T init, BinaryOperation bOp)
 {
-    return reduce(boost::begin(r), boost::end(r), init, bOp);
+    return boost::algorithm::reduce(boost::begin(r), boost::end(r), init, bOp);
 }
 
 }} // namespace boost and algorithm

include/boost/algorithm/cxx17/transform_exclusive_scan.hpp

@@ -2,7 +2,7 @@
    Copyright (c) Marshall Clow 2017.
 
    Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
 
 /// \file  transform_exclusive_scan.hpp

include/boost/algorithm/cxx17/transform_inclusive_scan.hpp

@@ -2,7 +2,7 @@
    Copyright (c) Marshall Clow 2017.
 
    Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
 
 /// \file  transform_reduce.hpp
@@ -46,7 +46,8 @@ OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
         typename std::iterator_traits<InputIterator>::value_type init = uOp(*first);
         *result++ = init;
         if (++first != last)
-            return transform_inclusive_scan(first, last, result, bOp, uOp, init);
+            return boost::algorithm::transform_inclusive_scan
+                                              (first, last, result, bOp, uOp, init);
         }
 
     return result;

include/boost/algorithm/cxx17/transform_reduce.hpp

@@ -2,7 +2,7 @@
    Copyright (c) Marshall Clow 2017.
 
    Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
 
 /// \file  transform_reduce.hpp
@@ -46,7 +46,7 @@ template<class InputIterator1, class InputIterator2, class T>
 T transform_reduce(InputIterator1 first1, InputIterator1 last1,
                    InputIterator2 first2, T init)
 {
-    return transform_reduce(first1, last1, first2, init,
+    return boost::algorithm::transform_reduce(first1, last1, first2, init,
                             std::plus<T>(), std::multiplies<T>());
 }
 

include/boost/algorithm/find_backward.hpp

@@ -0,0 +1,97 @@
+/*
+   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 <boost/config.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+#include <utility>
+
+
+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

@@ -0,0 +1,39 @@
+/*
+   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 <boost/config.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+#include <utility>
+
+
+namespace boost { namespace algorithm {
+
+template<typename InputIter, typename Sentinel, typename T>        
+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/string/finder.hpp

@@ -43,7 +43,6 @@ 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>
@@ -84,7 +83,6 @@ 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>
@@ -124,7 +122,6 @@ 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>
@@ -230,7 +227,6 @@ 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/iter_find.hpp

@@ -71,7 +71,11 @@ 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((
@@ -142,7 +146,11 @@ 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/split.hpp

@@ -61,7 +61,11 @@ 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(
@@ -96,7 +100,11 @@ 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() )
         {
@@ -139,7 +147,11 @@ 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 )
         {

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="http://www.sgi.com/tech/stl/  BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class T, class <a href="https://www.boost.org/sgi/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="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   minmax_element(ForwardIterator first, ForwardIterator last);
 
-  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>>
+  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>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   minmax_element(ForwardIterator first, ForwardIterator last,
                  BinaryPredicate comp);
 
   // Variants
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   ForwardIterator first_min_element(ForwardIterator first, ForwardIterator last);
 
-  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>>
+  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>>
   ForwardIterator first_min_element(ForwardIterator first, ForwardIterator last,
                                     BinaryPredicate comp);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   ForwardIterator last_min_element(ForwardIterator first, ForwardIterator last);
 
-  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>>
+  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>>
   ForwardIterator last_min_element(ForwardIterator first, ForwardIterator last,
                                    BinaryPredicate comp);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   ForwardIterator first_max_element(ForwardIterator first, ForwardIterator last);
 
-  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>>
+  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>>
   ForwardIterator first_max_element(ForwardIterator first, ForwardIterator last,
                                     BinaryPredicate comp);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   ForwardIterator last_max_element(ForwardIterator first, ForwardIterator last);
 
-  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>>
+  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>>
   ForwardIterator last_max_element(ForwardIterator first, ForwardIterator last,
                                    BinaryPredicate comp);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   first_min_first_max_element(ForwardIterator first, ForwardIterator last);
 
-  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>>
+  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>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   first_min_first_max_element(ForwardIterator first, ForwardIterator last,
                              BinaryPredicate comp);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   first_min_last_max_element(ForwardIterator first, ForwardIterator last);
 
-  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>>
+  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>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   first_min_last_max_element(ForwardIterator first, ForwardIterator last,
                              BinaryPredicate comp);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   last_min_first_max_element(ForwardIterator first, ForwardIterator last);
 
-  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>>
+  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>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   last_min_first_max_element(ForwardIterator first, ForwardIterator last,
                              BinaryPredicate comp);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   last_min_last_max_element(ForwardIterator first, ForwardIterator last);
 
-  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>>
+  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>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   last_min_last_max_element(ForwardIterator first, ForwardIterator last,
                             BinaryPredicate comp);

minmax/fuzzing/minmax_element.fuzz.cpp

@@ -0,0 +1,81 @@
+//  (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

@@ -0,0 +1,141 @@
+//  (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="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class T, class <a href="https://www.boost.org/sgi/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="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   minmax_element(ForwardIterator first, ForwardIterator last);
 
-  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>>
+  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>>
   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="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThan
+For minmax, <tt>T</tt> must be a model of <a href="https://www.boost.org/sgi/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="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward
+<tt>ForwardIterator</tt> is a model of <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">Forward
 Iterator</a>.</li>
 
 <li>
-<tt>ForwardIterator</tt>'s value type is <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThan
+<tt>ForwardIterator</tt>'s value type is <a href="https://www.boost.org/sgi/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="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward
+<tt>ForwardIterator</tt> is a model of <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">Forward
 Iterator</a>.</li>
 
 <li>
-<tt>BinaryPredicate</tt> is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary
+<tt>BinaryPredicate</tt> is a model of <a href="https://www.boost.org/sgi/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="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);
+  <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);
 
   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="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
+<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
 Comparable</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>
+<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>
 .
 <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,6 +20,19 @@
 #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);
@@ -117,7 +130,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 );
@@ -183,7 +196,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);
@@ -223,7 +236,7 @@ void test(int n BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Value))
   test_range(first, last, n);
 
   // Populate test vector with random values
-  std::random_shuffle(first, last);
+  do_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="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).
+             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).
 <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/test/split_test.cpp

@@ -7,6 +7,8 @@
 
 //  See http://www.boost.org for updates, documentation, and revision history.
 
+#include <boost/algorithm/string/config.hpp>
+
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/classification.hpp>
 // equals predicate is used for result comparison
@@ -82,6 +84,28 @@ void iterator_test()
         string("xx") );
     deep_compare( tokens, vtokens );
 
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    // If using a compiler that supports forwarding references, we should be able to use rvalues, too
+    find_all(
+        tokens,
+        string("xx-abc--xx-abb"),
+        "xx" );
+
+    BOOST_REQUIRE( tokens.size()==2 );
+    BOOST_CHECK( tokens[0]==string("xx") );
+    BOOST_CHECK( tokens[1]==string("xx") );
+
+    ifind_all(
+        tokens,
+        string("Xx-abc--xX-abb-xx"),
+        "xx" );
+
+    BOOST_REQUIRE( tokens.size()==3 );
+    BOOST_CHECK( tokens[0]==string("Xx") );
+    BOOST_CHECK( tokens[1]==string("xX") );
+    BOOST_CHECK( tokens[2]==string("xx") );
+#endif
+
     // split tests
     split(
         tokens,
@@ -144,6 +168,21 @@ void iterator_test()
     BOOST_REQUIRE( tokens.size()==1 );
     BOOST_CHECK( tokens[0]==string("") );
 
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    // If using a compiler that supports forwarding references, we should be able to use rvalues, too
+    split(
+        tokens,
+        string("Xx-abc--xX-abb-xx"),
+        is_any_of("xX"),
+        token_compress_on );
+
+    BOOST_REQUIRE( tokens.size()==4 );
+    BOOST_CHECK( tokens[0]==string("") );
+    BOOST_CHECK( tokens[1]==string("-abc--") );
+    BOOST_CHECK( tokens[2]==string("-abb-") );
+    BOOST_CHECK( tokens[3]==string("") );
+#endif
+
 
     find_iterator<string::iterator> fiter=make_find_iterator(str1, first_finder("xx"));
     find_iterator<string::iterator> fiter2;

test/Jamfile.v2

@@ -16,7 +16,7 @@ alias unit_test_framework
 
 
 {
-  test-suite algorithm:
+  test-suite algorithm
 # Search tests
    : [ run empty_search_test.cpp unit_test_framework      : : : : empty_search_test ]
      [ run search_test1.cpp unit_test_framework           : : : : search_test1 ]
@@ -83,6 +83,12 @@ alias unit_test_framework
 
 # Is_partitioned_until tests
      [ run is_partitioned_until_test.cpp unit_test_framework    : : : : is_partitioned_until_test ]
+   
+# Apply_permutation tests
+     [ run apply_permutation_test.cpp unit_test_framework    : : : : apply_permutation_test ]
+# Find tests
+     [ run find_not_test.cpp unit_test_framework   : : : : find_not_test ]
+     [ run find_backward_test.cpp unit_test_framework   : : : : find_backward_test ]
    ;
 }
 

test/all_of_test.cpp

@@ -19,9 +19,8 @@
 
 template<typename T>
 struct is_ {
-    is_ ( T v ) : val_ ( v ) {}
-    ~is_ () {}
-    bool operator () ( T comp ) const { return val_ == comp; }
+    BOOST_CXX14_CONSTEXPR is_ ( T v ) : val_ ( v ) {}
+    BOOST_CXX14_CONSTEXPR bool operator () ( T comp ) const { return val_ == comp; }
 private:
     is_ (); // need a value
 
@@ -33,7 +32,7 @@ namespace ba = boost::algorithm;
 void test_all ()
 {
 //  Note: The literal values here are tested against directly, careful if you change them:
-    int some_numbers[] = { 1, 1, 1, 18, 10 };
+    BOOST_CXX14_CONSTEXPR int some_numbers[] = { 1, 1, 1, 18, 10 };
     std::vector<int> vi(some_numbers, some_numbers + 5);
     std::list<int>   li(vi.begin(), vi.end ());
     
@@ -77,7 +76,15 @@ void test_all ()
     l_iter++; l_iter++; l_iter++;
     BOOST_CHECK ( ba::all_of_equal ( li.begin(), l_iter,            1 ));
     BOOST_CHECK ( ba::all_of       ( li.begin(), l_iter, is_<int> ( 1 )));
-    
+
+    BOOST_CXX14_CONSTEXPR bool constexpr_res =
+        !ba::all_of_equal ( some_numbers, 1 )                               &&
+        !ba::all_of       ( some_numbers, is_<int> ( 1 ))                   &&
+         ba::all_of_equal ( some_numbers, some_numbers + 3,            1 )  &&
+         ba::all_of       ( some_numbers, some_numbers + 3, is_<int> ( 1 )) &&
+        true;
+
+    BOOST_CHECK ( constexpr_res );
 }
 
 

test/any_of_test.cpp

@@ -19,9 +19,8 @@
 
 template<typename T>
 struct is_ {
-    is_ ( T v ) : val_ ( v ) {}
-    ~is_ () {}
-    bool operator () ( T comp ) const { return val_ == comp; }
+    BOOST_CXX14_CONSTEXPR is_ ( T v ) : val_ ( v ) {}
+    BOOST_CXX14_CONSTEXPR bool operator () ( T comp ) const { return val_ == comp; }
 private:
     is_ (); // need a value
 
@@ -33,7 +32,7 @@ namespace ba = boost::algorithm;
 void test_any ()
 {
 //  Note: The literal values here are tested against directly, careful if you change them:
-    int some_numbers[] = { 1, 5, 0, 18, 10 };
+    BOOST_CXX14_CONSTEXPR int some_numbers[] = { 1, 5, 0, 18, 10 };
     std::vector<int> vi(some_numbers, some_numbers + 5);
     std::list<int>   li(vi.begin(), vi.end ());
 
@@ -97,6 +96,15 @@ void test_any ()
     BOOST_CHECK ( ba::any_of       ( li.begin(), l_iter, is_<int> (  5 )));
     BOOST_CHECK (!ba::any_of_equal ( li.begin(), l_iter,            18 ));
     BOOST_CHECK (!ba::any_of       ( li.begin(), l_iter, is_<int> ( 18 )));
+    
+    BOOST_CXX14_CONSTEXPR bool constexpr_res =
+         ba::any_of_equal ( some_numbers, 1 )                                 &&
+         ba::any_of       ( some_numbers, is_<int> ( 1 ))                     &&
+        !ba::any_of_equal ( some_numbers, some_numbers + 3,            777 )  &&
+        !ba::any_of       ( some_numbers, some_numbers + 3, is_<int> ( 777 )) &&
+        true;
+
+    BOOST_CHECK ( constexpr_res );
 }
 
 

test/apply_permutation_test.cpp

@@ -0,0 +1,162 @@
+/*
+  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 <boost/algorithm/apply_permutation.hpp>
+
+#define BOOST_TEST_MAIN
+
+#include <boost/test/included/unit_test.hpp>
+
+namespace ba = boost::algorithm;
+
+
+BOOST_AUTO_TEST_CASE(test_apply_permutation)
+{
+    //Empty
+    {
+        std::vector<int> vec, order, result;
+        
+        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //1 element
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1);
+        order.push_back(0);
+        result = vec;
+        
+        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //2 elements, no changes
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2);
+        order.push_back(0); order.push_back(1);
+        result = vec;
+        
+        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //2 elements, changed
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2);
+        order.push_back(1); order.push_back(0);
+        result.push_back(2); result.push_back(1);
+        
+        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //Multiple elements, no changes
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2); vec.push_back(3); vec.push_back(4); vec.push_back(5);
+        order.push_back(0); order.push_back(1); order.push_back(2); order.push_back(3); order.push_back(4);
+        result = vec;
+        
+        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //Multiple elements, changed
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2); vec.push_back(3); vec.push_back(4); vec.push_back(5);
+        order.push_back(4); order.push_back(3); order.push_back(2); order.push_back(1); order.push_back(0);
+        result.push_back(5); result.push_back(4); result.push_back(3); result.push_back(2); result.push_back(1);
+        
+        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //Just test range interface
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2); vec.push_back(3); vec.push_back(4); vec.push_back(5);
+        order.push_back(0); order.push_back(1); order.push_back(2); order.push_back(3); order.push_back(4);
+        result = vec;
+        
+        ba::apply_permutation(vec, order);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_apply_reverse_permutation)
+{
+    //Empty
+    {
+        std::vector<int> vec, order, result;
+        
+        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //1 element
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1);
+        order.push_back(0);
+        result = vec;
+        
+        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //2 elements, no changes
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2);
+        order.push_back(0); order.push_back(1);
+        result = vec;
+        
+        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //2 elements, changed
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2);
+        order.push_back(1); order.push_back(0);
+        result.push_back(2); result.push_back(1);
+        
+        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //Multiple elements, no changes
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2); vec.push_back(3); vec.push_back(4); vec.push_back(5);
+        order.push_back(0); order.push_back(1); order.push_back(2); order.push_back(3); order.push_back(4);
+        result = vec;
+        
+        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //Multiple elements, changed
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2); vec.push_back(3); vec.push_back(4); vec.push_back(5);
+        order.push_back(4); order.push_back(3); order.push_back(2); order.push_back(1); order.push_back(0);
+        result.push_back(5); result.push_back(4); result.push_back(3); result.push_back(2); result.push_back(1);
+        
+        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //Just test range interface
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2); vec.push_back(3); vec.push_back(4); vec.push_back(5);
+        order.push_back(0); order.push_back(1); order.push_back(2); order.push_back(3); order.push_back(4);
+        result = vec;
+        
+        ba::apply_reverse_permutation(vec, order);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+}

test/clamp_test.cpp

@@ -14,8 +14,8 @@
 
 namespace ba = boost::algorithm;
 
-bool intGreater    ( int lhs, int rhs )       { return lhs > rhs; }
-bool doubleGreater ( double lhs, double rhs ) { return lhs > rhs; }
+BOOST_CONSTEXPR bool intGreater    ( int lhs, int rhs )       { return lhs > rhs; }
+BOOST_CONSTEXPR bool doubleGreater ( double lhs, double rhs ) { return lhs > rhs; }
 
 class custom {
 public:
@@ -45,6 +45,10 @@ void test_ints()
     BOOST_CHECK_EQUAL (  1, ba::clamp (  0, 1, 10 ));
     BOOST_CHECK_EQUAL ( 10, ba::clamp ( 10, 1, 10 ));
     BOOST_CHECK_EQUAL ( 10, ba::clamp ( 11, 1, 10 ));
+    BOOST_CXX14_CONSTEXPR bool constexpr_res = (
+        ba::clamp (  3, 1, 10 ) == 3
+    );
+    BOOST_CHECK( constexpr_res );
     
     BOOST_CHECK_EQUAL (  3, ba::clamp (  3, 10, 1, intGreater ));
     BOOST_CHECK_EQUAL (  1, ba::clamp (  1, 10, 1, intGreater ));
@@ -206,6 +210,110 @@ void test_int_range ()
     BOOST_CHECK ( std::equal ( b_e(junk), outputs ));
 }
 
+void test_constexpr()
+{
+
+//  Inside the range, equal to the endpoints, and outside the endpoints.
+    {
+        BOOST_CXX14_CONSTEXPR bool check_inside  = (3  == ba::clamp (  3, 1, 10 ));
+        BOOST_CHECK(check_inside);
+        BOOST_CXX14_CONSTEXPR bool check_min     = (1  == ba::clamp (  1, 1, 10 ));
+        BOOST_CHECK(check_min);
+        BOOST_CXX14_CONSTEXPR bool check_min_out = (1  == ba::clamp (  0, 1, 10 ));
+        BOOST_CHECK(check_min_out);
+        BOOST_CXX14_CONSTEXPR bool check_max     = (10 == ba::clamp ( 10, 1, 10 ));
+        BOOST_CHECK(check_max);
+        BOOST_CXX14_CONSTEXPR bool check_max_out = (10 == ba::clamp ( 11, 1, 10 ));
+        BOOST_CHECK(check_max_out);
+    }
+    {
+        BOOST_CXX14_CONSTEXPR bool check_inside  = (3  == ba::clamp (  3, 10, 1, intGreater ));
+        BOOST_CHECK(check_inside);
+        BOOST_CXX14_CONSTEXPR bool check_min     = (1  == ba::clamp (  1, 10, 1, intGreater ));
+        BOOST_CHECK(check_min);
+        BOOST_CXX14_CONSTEXPR bool check_min_out = (1  == ba::clamp (  0, 10, 1, intGreater ));
+        BOOST_CHECK(check_min_out);
+        BOOST_CXX14_CONSTEXPR bool check_max     = (10 == ba::clamp ( 10, 10, 1, intGreater ));
+        BOOST_CHECK(check_max);
+        BOOST_CXX14_CONSTEXPR bool check_max_out = (10 == ba::clamp ( 11, 10, 1, intGreater ));
+        BOOST_CHECK(check_max_out);
+    }
+
+//  Negative numbers
+    {
+        BOOST_CXX14_CONSTEXPR bool check_inside  = (-3  == ba::clamp  (  -3, -10, -1 ));
+        BOOST_CHECK(check_inside);
+        BOOST_CXX14_CONSTEXPR bool check_max     = (-1  == ba::clamp  (  -1, -10, -1 ));
+        BOOST_CHECK(check_max);
+        BOOST_CXX14_CONSTEXPR bool check_max_out = (-1  == ba::clamp  (   0, -10, -1 ));
+        BOOST_CHECK(check_max_out);
+        BOOST_CXX14_CONSTEXPR bool check_min     = (-10 == ba::clamp ( -10, -10, -1 ));
+        BOOST_CHECK(check_min);
+        BOOST_CXX14_CONSTEXPR bool check_min_out = (-10 == ba::clamp ( -11, -10, -1 ));
+        BOOST_CHECK(check_min_out);
+    }
+
+//  Mixed positive and negative numbers
+    {
+        BOOST_CXX14_CONSTEXPR bool check_inside  = (5   == ba::clamp (   5, -10, 10 ));
+        BOOST_CHECK(check_inside);
+        BOOST_CXX14_CONSTEXPR bool check_min     = (-10 == ba::clamp ( -10, -10, 10 ));
+        BOOST_CHECK(check_min);
+        BOOST_CXX14_CONSTEXPR bool check_min_out = (-10 == ba::clamp ( -15, -10, 10 ));
+        BOOST_CHECK(check_min_out);
+        BOOST_CXX14_CONSTEXPR bool check_max     = (10  == ba::clamp (  10, -10, 10 ));
+        BOOST_CHECK(check_max);
+        BOOST_CXX14_CONSTEXPR bool check_max_out = (10  == ba::clamp (  15, -10, 10 ));
+        BOOST_CHECK(check_max_out);
+    }
+//  Unsigned
+    {
+        BOOST_CXX14_CONSTEXPR bool check_inside  = (5U  == ba::clamp (  5U, 1U, 10U ));
+        BOOST_CHECK(check_inside);
+        BOOST_CXX14_CONSTEXPR bool check_min     = (1U  == ba::clamp (  1U, 1U, 10U ));
+        BOOST_CHECK(check_min);
+        BOOST_CXX14_CONSTEXPR bool check_min_out = (1U  == ba::clamp (  0U, 1U, 10U ));
+        BOOST_CHECK(check_min_out);
+        BOOST_CXX14_CONSTEXPR bool check_max     = (10U == ba::clamp ( 10U, 1U, 10U ));
+        BOOST_CHECK(check_max);
+        BOOST_CXX14_CONSTEXPR bool check_max_out = (10U == ba::clamp ( 15U, 1U, 10U ));
+        BOOST_CHECK(check_max_out);
+    }
+//  Mixed (1)
+    {
+        BOOST_CXX14_CONSTEXPR bool check_inside  = (5U  == ba::clamp (  5U, 1,  10 ));
+        BOOST_CHECK(check_inside);
+        BOOST_CXX14_CONSTEXPR bool check_min     = (1U  == ba::clamp (  1U, 1,  10 ));
+        BOOST_CHECK(check_min);
+        BOOST_CXX14_CONSTEXPR bool check_min_out = (1U  == ba::clamp (  0U, 1,  10 ));
+        BOOST_CHECK(check_min_out);
+        BOOST_CXX14_CONSTEXPR bool check_max     = (10U == ba::clamp ( 10U, 1,  10 ));
+        BOOST_CHECK(check_max);
+        BOOST_CXX14_CONSTEXPR bool check_max_out = (10U == ba::clamp ( 15U, 1,  10 ));
+        BOOST_CHECK(check_max_out);
+    }  
+//  Mixed (3)
+    {
+        BOOST_CXX14_CONSTEXPR bool check_inside  = (5U  == ba::clamp (  5U, 1,  10. ));
+        BOOST_CHECK(check_inside);
+        BOOST_CXX14_CONSTEXPR bool check_min     = (1U  == ba::clamp (  1U, 1,  10. ));
+        BOOST_CHECK(check_min);
+        BOOST_CXX14_CONSTEXPR bool check_min_out = (1U  == ba::clamp (  0U, 1,  10. ));
+        BOOST_CHECK(check_min_out);
+        BOOST_CXX14_CONSTEXPR bool check_max     = (10U == ba::clamp ( 10U, 1,  10. ));
+        BOOST_CHECK(check_max);
+        BOOST_CXX14_CONSTEXPR bool check_max_out = (10U == ba::clamp ( 15U, 1,  10. ));
+        BOOST_CHECK(check_max_out);
+    }
+    {
+        BOOST_CXX14_CONSTEXPR short foo = 50;
+        BOOST_CXX14_CONSTEXPR bool check_float   = ( 56    == ba::clamp ( foo, 56.9, 129 ));
+        BOOST_CHECK(check_float);
+        BOOST_CXX14_CONSTEXPR bool check_over    = ( 24910 == ba::clamp ( foo, 12345678, 123456999 ));
+        BOOST_CHECK(check_over);
+    }
+}
+
 BOOST_AUTO_TEST_CASE( test_main )
 {
     test_ints ();
@@ -213,6 +321,8 @@ BOOST_AUTO_TEST_CASE( test_main )
     test_custom ();
     
     test_int_range ();
+
+    test_constexpr ();
 //    test_float_range ();
 //    test_custom_range ();
 }

test/copy_if_test1.cpp

@@ -10,6 +10,8 @@
 #include <boost/config.hpp>
 #include <boost/algorithm/cxx11/copy_if.hpp>
 
+#include "iterator_test.hpp"
+
 #define BOOST_TEST_MAIN
 #include <boost/test/unit_test.hpp>
 
@@ -20,15 +22,18 @@
 #include <list>
 
 #include <boost/algorithm/cxx11/all_of.hpp>
+#include <boost/algorithm/cxx14/equal.hpp>
 #include <boost/algorithm/cxx11/none_of.hpp>
 
 namespace ba = boost::algorithm;
 // namespace ba = boost;
 
-bool is_true  ( int v ) { return true; }
-bool is_false ( int v ) { return false; }
-bool is_even  ( int v ) { return v % 2 == 0; }
-bool is_odd   ( int v ) { return v % 2 == 1; }
+BOOST_CXX14_CONSTEXPR bool is_true  ( int v ) { return true; }
+BOOST_CXX14_CONSTEXPR bool is_false ( int v ) { return false; }
+BOOST_CXX14_CONSTEXPR bool is_even  ( int v ) { return v % 2 == 0; }
+BOOST_CXX14_CONSTEXPR bool is_odd   ( int v ) { return v % 2 == 1; }
+BOOST_CXX14_CONSTEXPR bool is_zero  ( int v ) { return v == 0; }
+
 
 template <typename Container>
 void test_copy_if ( Container const &c ) {
@@ -155,6 +160,71 @@ void test_copy_until ( Container const &c ) {
     BOOST_CHECK ( ba::none_of ( v.begin (), v.end (), is_even ));
     BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
     }
+
+
+BOOST_CXX14_CONSTEXPR inline bool constexpr_test_copy_if() {
+    const int sz = 64;
+    int in_data[sz] = {0};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + sz;
+    
+    int out_data[sz] = {0};
+    int* out = out_data;
+    out = ba::copy_if ( from, to, out, is_false ); // copy none
+    res = (res && out == out_data);
+    
+    out = ba::copy_if ( from, to, out, is_true ); // copy all
+    res = (res && out == out_data + sz
+           && ba::equal( input_iterator<const int *>(out_data),  input_iterator<const int *>(out_data + sz), 
+                         input_iterator<const int *>(from), input_iterator<const int *>(to)));
+    
+    return res;
+    }
+
+BOOST_CXX14_CONSTEXPR inline bool constexpr_test_copy_while() {
+    const int sz = 64;
+    int in_data[sz] = {0};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + sz;
+    
+    int out_data[sz] = {0};
+    int* out = out_data;
+    out = ba::copy_while ( from, to, out, is_false ).second; // copy none
+    res = (res && out == out_data && ba::all_of(out, out + sz, is_zero));
+    
+    out = ba::copy_while ( from, to, out, is_true ).second; // copy all
+    res = (res && out == out_data + sz
+           && ba::equal( input_iterator<const int *>(out_data),  input_iterator<const int *>(out_data + sz), 
+                         input_iterator<const int *>(from), input_iterator<const int *>(to)));
+    
+    return res;
+    }
+
+BOOST_CXX14_CONSTEXPR inline bool constexpr_test_copy_until() {
+    const int sz = 64;
+    int in_data[sz] = {0};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + sz;
+    
+    int out_data[sz] = {0};
+    int* out = out_data;
+    out = ba::copy_until ( from, to, out, is_true ).second; // copy none
+    res = (res && out == out_data && ba::all_of(out, out + sz, is_zero));
+    
+    out = ba::copy_until ( from, to, out, is_false ).second; // copy all
+    res = (res && out == out_data + sz
+           && ba::equal( input_iterator<const int *>(out_data),  input_iterator<const int *>(out_data + sz), 
+                         input_iterator<const int *>(from), input_iterator<const int *>(to)));
+    
+    return res;
+    }
+    
     
 void test_sequence1 () {
     std::vector<int> v;
@@ -164,6 +234,13 @@ void test_sequence1 () {
     test_copy_while ( v );
     test_copy_until ( v );
     
+    BOOST_CXX14_CONSTEXPR bool constexpr_res_if = constexpr_test_copy_if();
+    BOOST_CHECK ( constexpr_res_if );
+    BOOST_CXX14_CONSTEXPR bool constexpr_res_while = constexpr_test_copy_while();
+    BOOST_CHECK ( constexpr_res_while );
+    BOOST_CXX14_CONSTEXPR bool constexpr_res_until = constexpr_test_copy_until();
+    BOOST_CHECK ( constexpr_res_until );
+    
     std::list<int> l;
     for ( int i = 25; i > 15; --i )
         l.push_back ( i );

test/copy_n_test1.cpp

@@ -9,6 +9,10 @@
 
 #include <boost/config.hpp>
 #include <boost/algorithm/cxx11/copy_n.hpp>
+#include <boost/algorithm/cxx14/equal.hpp>
+#include <boost/algorithm/cxx11/all_of.hpp>
+
+#include "iterator_test.hpp"
 
 #define BOOST_TEST_MAIN
 #include <boost/test/unit_test.hpp>
@@ -21,6 +25,8 @@
 namespace ba = boost::algorithm;
 // namespace ba = boost;
 
+BOOST_CXX14_CONSTEXPR bool is_zero( int v ) { return v == 0; }
+
 template <typename Container>
 void test_sequence ( Container const &c ) {
 
@@ -67,12 +73,38 @@ void test_sequence ( Container const &c ) {
     }
 
 
+BOOST_CXX14_CONSTEXPR inline bool test_constexpr() {
+    const size_t sz = 64;
+    int in_data[sz] = {0};
+    bool res = true;
+    
+    const int* from = in_data;
+    const int* to = in_data + sz;
+    
+    int out_data[sz] = {0};
+    int* out = out_data;
+    
+    out = ba::copy_n ( from, 0, out ); // Copy none
+    res = (res && out == out_data && ba::all_of(out, out + sz, is_zero));
+
+    out = ba::copy_n ( from, sz, out ); // Copy all
+    res = (res && out == out_data + sz
+           && ba::equal( input_iterator<const int *>(out_data),  input_iterator<const int *>(out_data + sz), 
+                         input_iterator<const int *>(from), input_iterator<const int *>(to)));
+    
+    return res;
+    }
+    
+    
 void test_sequence1 () {
     std::vector<int> v;
     for ( int i = 5; i < 15; ++i )
         v.push_back ( i );
     test_sequence  ( v );
     
+    BOOST_CXX14_CONSTEXPR bool constexpr_res = test_constexpr();
+    BOOST_CHECK(constexpr_res);
+    
     std::list<int> l;
     for ( int i = 25; i > 15; --i )
         l.push_back ( i );

test/equal_test.cpp

@@ -16,7 +16,7 @@
 #include <boost/test/unit_test.hpp>
 
 template <typename T>
-bool eq ( const T& a, const T& b ) { return a == b; }
+BOOST_CXX14_CONSTEXPR bool eq ( const T& a, const T& b ) { return a == b; }
 
 template <typename T>
 bool never_eq ( const T&, const T& ) { return false; }
@@ -123,7 +123,43 @@ void test_equal ()
 }
 
 
+BOOST_CXX14_CONSTEXPR bool test_constexpr_equal() {
+    int num[] = { 1, 1, 2, 3, 5};
+    const int sz = sizeof (num)/sizeof(num[0]);
+    bool res = true;
+//  Empty sequences are equal to each other
+    res = (   ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num), 
+                          input_iterator<int *>(num),     input_iterator<int *>(num))
+//  Identical long sequences are equal                         
+           && ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num + sz),
+                          input_iterator<int *>(num),     input_iterator<int *>(num + sz),
+                          eq<int> )
+//  Different sequences are different
+           && !ba::equal ( input_iterator<int *>(num + 1), input_iterator<int *>(num + sz),
+                           input_iterator<int *>(num),     input_iterator<int *>(num + sz))
+          );
+#ifdef __cpp_lib_array_constexpr // or cpp17 compiler
+//  Turn on tests for random_access_iterator, because std functions used in equal are marked constexpr_res
+    res = ( res 
+//  Empty sequences are equal to each other
+           && ba::equal ( random_access_iterator<int *>(num),     random_access_iterator<int *>(num), 
+                          random_access_iterator<int *>(num),     random_access_iterator<int *>(num))
+//  Identical long sequences are equal                         
+           && ba::equal ( random_access_iterator<int *>(num),     random_access_iterator<int *>(num + sz),
+                          random_access_iterator<int *>(num),     random_access_iterator<int *>(num + sz),
+                          eq<int> )
+//  Different sequences are different
+           && !ba::equal ( random_access_iterator<int *>(num + 1), random_access_iterator<int *>(num + sz),
+                           random_access_iterator<int *>(num),     random_access_iterator<int *>(num + sz))
+          );
+#endif
+    return res;
+  }
+
+
 BOOST_AUTO_TEST_CASE( test_main )
 {
   test_equal ();
+  BOOST_CXX14_CONSTEXPR bool constexpr_res = test_constexpr_equal ();
+  BOOST_CHECK (constexpr_res);
 }

test/find_backward_test.cpp

@@ -0,0 +1,420 @@
+/* 
+   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)
+
+    For more information, see http://www.boost.org
+*/
+#include <iostream>
+
+#include <boost/algorithm/find_backward.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+#include <list>
+
+
+namespace ba = boost::algorithm;
+
+template <typename Container>
+struct dist_t
+{
+    dist_t(Container & cont) : cont_(cont) {}
+    template<typename Iter>
+    std::ptrdiff_t operator()(Iter it) const
+    {
+        return std::distance(cont_.begin(), it);
+    }
+
+    Container & cont_;
+};
+
+BOOST_CXX14_CONSTEXPR bool check_constexpr_backward()
+{
+    int in_data[] = {1, 2, 3, 4, 5};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + 5;
+
+    const int* start = ba::find_backward(from, to, 1); // stops on first
+    res = (res && start == from);
+
+    start = ba::find_backward(in_data, 1); // stops on first
+    res = (res && start == from);
+
+    const int* end = ba::find_backward(from, to, 6); // stops on the end
+    res = (res && end == to);
+
+    end = ba::find_backward(in_data, 6); // stops on the end
+    res = (res && end == to);
+
+    const int* three = ba::find_backward(from, to, 3); // stops on third element
+    res = (res && three == in_data + 2);
+
+    three = ba::find_backward(in_data, 3); // stops on third element
+    res = (res && three == in_data + 2);
+
+    return res;
+}
+
+void test_find_backward()
+{
+    {
+        std::vector<int> v1;
+        const dist_t<std::vector<int> > dist(v1);
+
+        for (int i = 5; i < 15; ++i)
+            v1.push_back(i);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(v1.begin(), v1.end(), 0)), v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(v1.begin(), v1.end(), 100)), v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(v1.begin(), v1.end(), v1.back())),
+            v1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(v1.begin(), v1.end(), v1.front())), 0);
+
+        BOOST_CHECK_EQUAL(dist(ba::find_backward(v1, 0)), v1.size());
+        BOOST_CHECK_EQUAL(dist(ba::find_backward(v1, 100)), v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(v1, v1.back())), v1.size() - 1);
+        BOOST_CHECK_EQUAL(dist(ba::find_backward(v1, v1.front())), 0);
+    }
+
+    //  With bidirectional iterators.
+    {
+        std::list<int> l1;
+        const dist_t<std::list<int> > dist(l1);
+
+        for (int i = 5; i < 15; ++i)
+            l1.push_back(i);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(l1.begin(), l1.end(), 0)), l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(l1.begin(), l1.end(), 100)), l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(l1.begin(), l1.end(), l1.back())),
+            l1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(l1.begin(), l1.end(), l1.front())), 0);
+
+        BOOST_CHECK_EQUAL(dist(ba::find_backward(l1, 0)), l1.size());
+        BOOST_CHECK_EQUAL(dist(ba::find_backward(l1, 100)), l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(l1, l1.back())), l1.size() - 1);
+        BOOST_CHECK_EQUAL(dist(ba::find_backward(l1, l1.front())), 0);
+    }
+
+    BOOST_CXX14_CONSTEXPR bool ce_result = check_constexpr_backward();
+    BOOST_CHECK(ce_result);
+}
+
+struct equals
+{
+    BOOST_CXX14_CONSTEXPR equals(int n) : n_(n) {}
+    BOOST_CXX14_CONSTEXPR bool operator()(int i) { return i == n_; }
+    int n_;
+};
+
+BOOST_CXX14_CONSTEXPR bool check_constexpr_if_backward()
+{
+    int in_data[] = {1, 2, 3, 4, 5};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + 5;
+
+    const int* start = ba::find_if_backward(from, to, equals(1)); // stops on first
+    res = (res && start == from);
+
+    start = ba::find_if_backward(in_data, equals(1)); // stops on first
+    res = (res && start == from);
+
+    const int* end = ba::find_if_backward(from, to, equals(6)); // stops on the end
+    res = (res && end == to);
+
+    end = ba::find_if_backward(in_data, equals(6)); // stops on the end
+    res = (res && end == to);
+
+    const int* three = ba::find_if_backward(from, to, equals(3)); // stops on third element
+    res = (res && three == in_data + 2);
+
+    three = ba::find_if_backward(in_data, equals(3)); // stops on third element
+    res = (res && three == in_data + 2);
+
+    return res;
+}
+
+void test_find_if_backward()
+{
+    {
+        std::vector<int> v1;
+        const dist_t<std::vector<int> > dist(v1);
+
+        for (int i = 5; i < 15; ++i)
+            v1.push_back(i);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(v1.begin(), v1.end(), equals(0))),
+            v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(v1.begin(), v1.end(), equals(100))),
+            v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(v1.begin(), v1.end(), equals(v1.back()))),
+            v1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(
+                ba::find_if_backward(v1.begin(), v1.end(), equals(v1.front()))),
+            0);
+
+        BOOST_CHECK_EQUAL(dist(ba::find_if_backward(v1, equals(0))), v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(v1, equals(100))), v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(v1, equals(v1.back()))), v1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(v1, equals(v1.front()))), 0);
+    }
+
+    //  With bidirectional iterators.
+    {
+        std::list<int> l1;
+        const dist_t<std::list<int> > dist(l1);
+
+        for (int i = 5; i < 15; ++i)
+            l1.push_back(i);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(l1.begin(), l1.end(), equals(0))),
+            l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(l1.begin(), l1.end(), equals(100))),
+            l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(l1.begin(), l1.end(), equals(l1.back()))),
+            l1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(
+                ba::find_if_backward(l1.begin(), l1.end(), equals(l1.front()))),
+            0);
+
+        BOOST_CHECK_EQUAL(dist(ba::find_if_backward(l1, equals(0))), l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(l1, equals(100))), l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(l1, equals(l1.back()))), l1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(l1, equals(l1.front()))), 0);
+    }
+
+    BOOST_CXX14_CONSTEXPR bool ce_result = check_constexpr_if_backward();
+    BOOST_CHECK(ce_result);
+}
+
+struct not_equals
+{
+    BOOST_CXX14_CONSTEXPR not_equals(int n) : n_(n) {}
+    BOOST_CXX14_CONSTEXPR bool operator()(int i) { return i != n_; }
+    int n_;
+};
+
+BOOST_CXX14_CONSTEXPR bool check_constexpr_if_not_backward()
+{
+    int in_data[] = {1, 2, 3, 4, 5};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + 5;
+
+    const int* start = ba::find_if_not_backward(from, to, not_equals(1)); // stops on first
+    res = (res && start == from);
+
+    start = ba::find_if_not_backward(in_data, not_equals(1)); // stops on first
+    res = (res && start == from);
+
+    const int* end = ba::find_if_not_backward(from, to, not_equals(6)); // stops on the end
+    res = (res && end == to);
+
+    end = ba::find_if_not_backward(in_data, not_equals(6)); // stops on the end
+    res = (res && end == to);
+
+    const int* three = ba::find_if_not_backward(from, to, not_equals(3)); // stops on third element
+    res = (res && three == in_data + 2);
+
+    three = ba::find_if_not_backward(in_data, not_equals(3)); // stops on third element
+    res = (res && three == in_data + 2);
+
+    return res;
+}
+
+void test_find_if_not_backward()
+{
+    {
+        std::vector<int> v1;
+        const dist_t<std::vector<int> > dist(v1);
+
+        for (int i = 5; i < 15; ++i)
+            v1.push_back(i);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(v1.begin(), v1.end(), not_equals(0))),
+            v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(
+                v1.begin(), v1.end(), not_equals(100))),
+            v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(
+                v1.begin(), v1.end(), not_equals(v1.back()))),
+            v1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(
+                v1.begin(), v1.end(), not_equals(v1.front()))),
+            0);
+
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(v1, not_equals(0))), v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(v1, not_equals(100))), v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(v1, not_equals(v1.back()))),
+            v1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(v1, not_equals(v1.front()))), 0);
+    }
+
+    //  With bidirectional iterators.
+    {
+        std::list<int> l1;
+        const dist_t<std::list<int> > dist(l1);
+
+        for (int i = 5; i < 15; ++i)
+            l1.push_back(i);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(l1.begin(), l1.end(), not_equals(0))),
+            l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(
+                l1.begin(), l1.end(), not_equals(100))),
+            l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(
+                l1.begin(), l1.end(), not_equals(l1.back()))),
+            l1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(
+                l1.begin(), l1.end(), not_equals(l1.front()))),
+            0);
+
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(l1, not_equals(0))), l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(l1, not_equals(100))), l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(l1, not_equals(l1.back()))),
+            l1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(l1, not_equals(l1.front()))), 0);
+    }
+
+    BOOST_CXX14_CONSTEXPR bool ce_result = check_constexpr_if_not_backward();
+    BOOST_CHECK(ce_result);
+}
+
+BOOST_CXX14_CONSTEXPR bool check_constexpr_not_backward()
+{
+    int in_data[] = {1, 5, 5, 5, 5};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + 5;
+
+    const int* start = ba::find_not_backward(from, to, 5); // stops on first
+    res = (res && start == from);
+
+    start = ba::find_not_backward(in_data, 5); // stops on first
+    res = (res && start == from);
+
+    const int in_data_2[] = {6, 6, 6, 6, 6};
+    const int* end = ba::find_not_backward(in_data_2, in_data_2 + 5, 6); // stops on the end
+    res = (res && end == in_data_2 + 5);
+
+    end = ba::find_not_backward(in_data_2, 6); // stops on the end
+    res = (res && end == in_data_2 + 5);
+
+    return res;
+}
+
+void test_find_not_backward()
+{
+    {
+        std::vector<int> v1;
+        const dist_t<std::vector<int> > dist(v1);
+
+        for (int i = 0; i < 5; ++i)
+            v1.push_back(0);
+        for (int i = 0; i < 5; ++i)
+            v1.push_back(1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not_backward(v1.begin(), v1.end(), 1)), 4);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not_backward(v1.begin(), v1.end(), 0)),
+            v1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not_backward(v1.begin(), v1.end(), 2)),
+            v1.size() - 1);
+
+        BOOST_CHECK_EQUAL(dist(ba::find_not_backward(v1, 1)), 4);
+        BOOST_CHECK_EQUAL(dist(ba::find_not_backward(v1, 0)), v1.size() - 1);
+        BOOST_CHECK_EQUAL(dist(ba::find_not_backward(v1, 2)), v1.size() - 1);
+
+        v1.resize(5);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not_backward(v1.begin(), v1.end(), 0)), v1.size());
+
+        BOOST_CHECK_EQUAL(dist(ba::find_not_backward(v1, 0)), v1.size());
+    }
+
+    //  With bidirectional iterators.
+    {
+        std::list<int> l1;
+        const dist_t<std::list<int> > dist(l1);
+
+        for (int i = 0; i < 5; ++i)
+            l1.push_back(0);
+        for (int i = 0; i < 5; ++i)
+            l1.push_back(1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not_backward(l1.begin(), l1.end(), 1)), 4);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not_backward(l1.begin(), l1.end(), 0)),
+            l1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not_backward(l1.begin(), l1.end(), 2)),
+            l1.size() - 1);
+
+        BOOST_CHECK_EQUAL(dist(ba::find_not_backward(l1, 1)), 4);
+        BOOST_CHECK_EQUAL(dist(ba::find_not_backward(l1, 0)), l1.size() - 1);
+        BOOST_CHECK_EQUAL(dist(ba::find_not_backward(l1, 2)), l1.size() - 1);
+
+        l1.resize(5);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not_backward(l1.begin(), l1.end(), 0)), l1.size());
+
+        BOOST_CHECK_EQUAL(dist(ba::find_not_backward(l1, 0)), l1.size());
+    }
+
+    BOOST_CXX14_CONSTEXPR bool ce_result = check_constexpr_not_backward();
+    BOOST_CHECK(ce_result);
+}
+
+BOOST_AUTO_TEST_CASE(test_main)
+{
+    test_find_backward();
+    test_find_if_backward();
+    test_find_if_not_backward();
+    test_find_not_backward();
+}

test/find_if_not_test1.cpp

@@ -22,6 +22,29 @@
 namespace ba = boost::algorithm;
 // namespace ba = boost;
 
+BOOST_CXX14_CONSTEXPR bool is_true  ( int v ) { return true; }
+BOOST_CXX14_CONSTEXPR bool is_false ( int v ) { return false; }
+BOOST_CXX14_CONSTEXPR bool is_not_three ( int v ) { return v != 3; }
+
+BOOST_CXX14_CONSTEXPR bool check_constexpr() {
+    int in_data[] = {1, 2, 3, 4, 5};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + 5;
+    
+    const int* start = ba::find_if_not (from, to, is_false); // stops on first
+    res = (res && start == from);
+    
+    const int* end = ba::find_if_not(from, to, is_true); // stops on the end
+    res = (res && end == to);
+    
+    const int* three = ba::find_if_not(from, to, is_not_three); // stops on third element
+    res = (res && three == in_data + 2);
+    
+    return res;
+}
+
 template <typename Container>
 typename Container::iterator offset_to_iter ( Container &v, int offset ) {
     typename Container::iterator retval;

test/find_not_test.cpp

@@ -0,0 +1,134 @@
+/* 
+   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)
+
+    For more information, see http://www.boost.org
+*/
+#include <iostream>
+
+#include <boost/algorithm/find_not.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+#include <list>
+
+
+namespace ba = boost::algorithm;
+
+template <typename Container>
+struct dist_t
+{
+    dist_t(Container & cont) : cont_(cont) {}
+    template<typename Iter>
+    std::ptrdiff_t operator()(Iter it) const
+    {
+        return std::distance(cont_.begin(), it);
+    }
+
+    Container & cont_;
+};
+
+BOOST_CXX14_CONSTEXPR bool check_constexpr()
+{
+    int in_data[] = {2, 2, 3, 4, 5};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + 5;
+
+    const int* start = ba::find_not(from, to, 1); // stops on first
+    res = (res && start == from);
+
+    start = ba::find_not(in_data, 1); // stops on first
+    res = (res && start == from);
+
+    int in_data_2[] = {6, 6, 6, 6, 6};
+    const int* end = ba::find_not(in_data_2, in_data_2 + 5, 6); // stops on the end
+    res = (res && end == in_data_2 + 5);
+
+    end = ba::find_not(in_data_2, 6); // stops on the end
+    res = (res && end == in_data_2 + 5);
+
+    const int* three = ba::find_not(from, to, 2); // stops on third element
+    res = (res && three == in_data + 2);
+
+    three = ba::find_not(in_data, 2); // stops on third element
+    res = (res && three == in_data + 2);
+
+    return res;
+}
+
+void test_sequence()
+{
+    {
+        std::vector<int> v1;
+        const dist_t<std::vector<int> > dist(v1);
+
+        for (int i = 5; i < 15; ++i)
+            v1.push_back(i);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(v1.begin(), v1.end(), 0)), 0);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not(v1.begin(), v1.end(), v1.back())), 0);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not(v1.begin(), v1.end(), v1.front())), 1);
+
+        BOOST_CHECK_EQUAL(dist(ba::find_not(v1, 0)), 0);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(v1, v1.back())), 0);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(v1, v1.front())), 1);
+
+        v1 = std::vector<int>(10, 2);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(v1.begin(), v1.end(), 0)), 0);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not(v1.begin(), v1.end(), v1.back())), v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not(v1.begin(), v1.end(), v1.front())), v1.size());
+
+        BOOST_CHECK_EQUAL(dist(ba::find_not(v1, 0)), 0);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(v1, v1.back())), v1.size());
+        BOOST_CHECK_EQUAL(dist(ba::find_not(v1, v1.front())), v1.size());
+    }
+
+    //  With bidirectional iterators.
+    {
+        std::list<int> l1;
+        const dist_t<std::list<int> > dist(l1);
+
+        for (int i = 5; i < 15; ++i)
+            l1.push_back(i);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(l1.begin(), l1.end(), 0)), 0);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not(l1.begin(), l1.end(), l1.back())), 0);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not(l1.begin(), l1.end(), l1.front())), 1);
+
+        BOOST_CHECK_EQUAL(dist(ba::find_not(l1, 0)), 0);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(l1, l1.back())), 0);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(l1, l1.front())), 1);
+
+        l1.clear();
+        for (int i = 0; i < 10; ++i)
+            l1.push_back(2);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(l1.begin(), l1.end(), 0)), 0);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not(l1.begin(), l1.end(), l1.back())), l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not(l1.begin(), l1.end(), l1.front())), l1.size());
+
+        BOOST_CHECK_EQUAL(dist(ba::find_not(l1, 0)), 0);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(l1, l1.back())), l1.size());
+        BOOST_CHECK_EQUAL(dist(ba::find_not(l1, l1.front())), l1.size());
+    }
+
+    BOOST_CXX14_CONSTEXPR bool ce_result = check_constexpr();
+    BOOST_CHECK(ce_result);
+}
+
+
+BOOST_AUTO_TEST_CASE(test_main)
+{
+    test_sequence();
+}

test/iota_test1.cpp

@@ -20,7 +20,7 @@
 
 //  Test to make sure a sequence is "correctly formed"; i.e, ascending by one
 template <typename Iterator, typename T>
-bool test_iota_results ( Iterator first, Iterator last, T initial_value ) {
+BOOST_CXX14_CONSTEXPR bool test_iota_results ( Iterator first, Iterator last, T initial_value ) {
     if ( first == last ) return true;
     if ( initial_value != *first ) return false;
     Iterator prev = first;
@@ -32,12 +32,13 @@ bool test_iota_results ( Iterator first, Iterator last, T initial_value ) {
     return true;
     }
 
+    
 template <typename Range, typename T>
-bool test_iota_results ( const Range &r, T initial_value ) {
+BOOST_CXX14_CONSTEXPR bool test_iota_results ( const Range &r, T initial_value ) {
     return test_iota_results (boost::begin (r), boost::end (r), initial_value );
 }
 
-
+    
 void test_ints () {
     std::vector<int> v;
     std::list<int> l;
@@ -76,9 +77,38 @@ void test_ints () {
     boost::algorithm::iota_n ( std::front_inserter(l), 123, 20 );
     BOOST_CHECK ( test_iota_results ( l.rbegin (), l.rend (), 123 ));
     }
+    
+BOOST_CXX14_CONSTEXPR inline bool test_constexpr_iota() {
+    bool res = true;
+    int data[] = {0, 0, 0};
+    boost::algorithm::iota(data, data, 1); // fill none
+    res = (res && data[0] == 0);
+    
+    boost::algorithm::iota(data, data + 3, 1); // fill all
+    res = (res && test_iota_results(data, data + 3, 1));
+    
+    return res;
+    }
+    
+    
+BOOST_CXX14_CONSTEXPR inline bool test_constexpr_iota_n() {
+    bool res = true;
+    int data[] = {0, 0, 0};
+    boost::algorithm::iota_n(data, 1, 0); // fill none
+    res = (res && data[0] == 0);
+    
+    boost::algorithm::iota_n(data, 1, 3); // fill all
+    res = (res && test_iota_results(data, 1));
+    
+    return res;
+    }
 
 
 BOOST_AUTO_TEST_CASE( test_main )
 {
   test_ints ();
+  BOOST_CXX14_CONSTEXPR bool constexpr_iota_res = test_constexpr_iota ();
+  BOOST_CHECK(constexpr_iota_res);
+  BOOST_CXX14_CONSTEXPR bool constexpr_iota_n_res = test_constexpr_iota_n ();
+  BOOST_CHECK(constexpr_iota_n_res);
 }

test/is_partitioned_test1.cpp

@@ -25,16 +25,27 @@ namespace ba = boost::algorithm;
 template <typename T>
 struct less_than {
 public:
-    less_than ( T foo ) : val ( foo ) {}
-    less_than ( const less_than &rhs ) : val ( rhs.val ) {}
+    BOOST_CXX14_CONSTEXPR less_than ( T foo ) : val ( foo ) {}
+    BOOST_CXX14_CONSTEXPR less_than ( const less_than &rhs ) : val ( rhs.val ) {}
 
-    bool operator () ( const T &v ) const { return v < val; }
+    BOOST_CXX14_CONSTEXPR bool operator () ( const T &v ) const { return v < val; }
 private:
     less_than ();
     less_than operator = ( const less_than &rhs );
     T val;
     };
 
+    
+BOOST_CXX14_CONSTEXPR bool test_constexpr() {
+    int v[] = { 4, 5, 6, 7, 8, 9, 10 };
+    bool res = true;
+    res = ( res && ba::is_partitioned ( v, less_than<int>(3)));  // no elements
+    res = ( res && ba::is_partitioned ( v, less_than<int>(5)));  // only the first element
+    res = ( res && ba::is_partitioned ( v, less_than<int>(8)));  // in the middle somewhere
+    res = ( res && ba::is_partitioned ( v, less_than<int>(99))); // all elements
+    return res;
+    }
+    
 
 void test_sequence1 () {
     std::vector<int> v;
@@ -61,4 +72,6 @@ void test_sequence1 () {
 BOOST_AUTO_TEST_CASE( test_main )
 {
   test_sequence1 ();
+  BOOST_CXX14_CONSTEXPR bool constexpr_res = test_constexpr ();
+  BOOST_CHECK ( constexpr_res );
 }

test/iterator_test.hpp

@@ -30,23 +30,23 @@ public:
     typedef It                                                 pointer;
     typedef typename std::iterator_traits<It>::reference       reference;
 
-    It base() const {return it_;}
+    BOOST_CXX14_CONSTEXPR It base() const {return it_;}
 
-    input_iterator() : it_() {}
-    explicit input_iterator(It it) : it_(it) {}
+    BOOST_CXX14_CONSTEXPR input_iterator() : it_() {}
+    BOOST_CXX14_CONSTEXPR explicit input_iterator(It it) : it_(it) {}
 
     template <typename U>
-    input_iterator(const input_iterator<U>& u) :it_(u.it_) {}
+    BOOST_CXX14_CONSTEXPR input_iterator(const input_iterator<U>& u) :it_(u.it_) {}
 
-    reference operator*() const {return *it_;}
-    pointer  operator->() const {return  it_;}
+    BOOST_CXX14_CONSTEXPR reference operator*() const {return *it_;}
+    BOOST_CXX14_CONSTEXPR pointer  operator->() const {return  it_;}
 
-    input_iterator& operator++()    {++it_; return *this;}
-    input_iterator  operator++(int) {input_iterator tmp(*this); ++(*this); return tmp;}
+    BOOST_CXX14_CONSTEXPR input_iterator& operator++()    {++it_; return *this;}
+    BOOST_CXX14_CONSTEXPR input_iterator  operator++(int) {input_iterator tmp(*this); ++(*this); return tmp;}
 
-    friend bool operator==(const input_iterator& x, const input_iterator& y)
+    BOOST_CXX14_CONSTEXPR friend bool operator==(const input_iterator& x, const input_iterator& y)
         {return x.it_ == y.it_;}
-    friend bool operator!=(const input_iterator& x, const input_iterator& y)
+    BOOST_CXX14_CONSTEXPR friend bool operator!=(const input_iterator& x, const input_iterator& y)
         {return !(x == y);}
 
 private:
@@ -55,14 +55,14 @@ private:
 };
 
 template <typename T, typename U>
-inline bool
+BOOST_CXX14_CONSTEXPR inline bool
 operator==(const input_iterator<T>& x, const input_iterator<U>& y)
 {
     return x.base() == y.base();
 }
 
 template <typename T, typename U>
-inline bool
+BOOST_CXX14_CONSTEXPR inline bool
 operator!=(const input_iterator<T>& x, const input_iterator<U>& y)
 {
     return !(x == y);
@@ -79,22 +79,22 @@ public:
     typedef It                                                 pointer;
     typedef typename std::iterator_traits<It>::reference       reference;
 
-    It base() const {return it_;}
+    BOOST_CXX14_CONSTEXPR It base() const {return it_;}
 
-    forward_iterator() : it_() {}
-    explicit forward_iterator(It it) : it_(it) {}
+    BOOST_CXX14_CONSTEXPR forward_iterator() : it_() {}
+    BOOST_CXX14_CONSTEXPR explicit forward_iterator(It it) : it_(it) {}
     template <typename U>
-    forward_iterator(const forward_iterator<U>& u) :it_(u.it_) {}
+    BOOST_CXX14_CONSTEXPR forward_iterator(const forward_iterator<U>& u) :it_(u.it_) {}
 
-    reference operator*() const {return *it_;}
-    pointer  operator->() const {return  it_;}
+    BOOST_CXX14_CONSTEXPR reference operator*() const {return *it_;}
+    BOOST_CXX14_CONSTEXPR pointer  operator->() const {return  it_;}
 
-    forward_iterator& operator++()    {++it_; return *this;}
-    forward_iterator  operator++(int) {forward_iterator tmp(*this); ++(*this); return tmp;}
+    BOOST_CXX14_CONSTEXPR forward_iterator& operator++()    {++it_; return *this;}
+    BOOST_CXX14_CONSTEXPR forward_iterator  operator++(int) {forward_iterator tmp(*this); ++(*this); return tmp;}
 
-    friend bool operator==(const forward_iterator& x, const forward_iterator& y)
+    BOOST_CXX14_CONSTEXPR friend bool operator==(const forward_iterator& x, const forward_iterator& y)
         {return x.it_ == y.it_;}
-    friend bool operator!=(const forward_iterator& x, const forward_iterator& y)
+    BOOST_CXX14_CONSTEXPR friend bool operator!=(const forward_iterator& x, const forward_iterator& y)
         {return !(x == y);}
 private:
     It it_;
@@ -103,14 +103,14 @@ private:
 };
 
 template <typename T, typename U>
-inline bool
+BOOST_CXX14_CONSTEXPR inline bool
 operator==(const forward_iterator<T>& x, const forward_iterator<U>& y)
 {
     return x.base() == y.base();
 }
 
 template <typename T, typename U>
-inline bool
+BOOST_CXX14_CONSTEXPR inline bool
 operator!=(const forward_iterator<T>& x, const forward_iterator<U>& y)
 {
     return !(x == y);
@@ -127,35 +127,35 @@ public:
     typedef It                                                 pointer;
     typedef typename std::iterator_traits<It>::reference       reference;
 
-    It base() const {return it_;}
+    BOOST_CXX14_CONSTEXPR It base() const {return it_;}
 
-    bidirectional_iterator() : it_() {}
-    explicit bidirectional_iterator(It it) : it_(it) {}
+    BOOST_CXX14_CONSTEXPR bidirectional_iterator() : it_() {}
+    BOOST_CXX14_CONSTEXPR explicit bidirectional_iterator(It it) : it_(it) {}
     template <typename U>
-    bidirectional_iterator(const bidirectional_iterator<U>& u) :it_(u.it_) {}
+    BOOST_CXX14_CONSTEXPR bidirectional_iterator(const bidirectional_iterator<U>& u) :it_(u.it_) {}
 
-    reference operator*() const {return *it_;}
-    pointer  operator->() const {return  it_;}
+    BOOST_CXX14_CONSTEXPR reference operator*() const {return *it_;}
+    BOOST_CXX14_CONSTEXPR pointer  operator->() const {return  it_;}
 
-    bidirectional_iterator& operator++()    {++it_; return *this;}
-    bidirectional_iterator  operator++(int) {bidirectional_iterator tmp(*this); ++(*this); return tmp;}
+    BOOST_CXX14_CONSTEXPR bidirectional_iterator& operator++()    {++it_; return *this;}
+    BOOST_CXX14_CONSTEXPR bidirectional_iterator  operator++(int) {bidirectional_iterator tmp(*this); ++(*this); return tmp;}
 
-    bidirectional_iterator& operator--()    {--it_; return *this;}
-    bidirectional_iterator  operator--(int) {bidirectional_iterator tmp(*this); --(*this); return tmp;}
+    BOOST_CXX14_CONSTEXPR bidirectional_iterator& operator--()    {--it_; return *this;}
+    BOOST_CXX14_CONSTEXPR bidirectional_iterator  operator--(int) {bidirectional_iterator tmp(*this); --(*this); return tmp;}
 private:
     It it_;
     template <typename U> friend class bidirectional_iterator;
 };
 
 template <typename T, typename U>
-inline bool
+BOOST_CXX14_CONSTEXPR inline bool
 operator==(const bidirectional_iterator<T>& x, const bidirectional_iterator<U>& y)
 {
     return x.base() == y.base();
 }
 
 template <typename T, typename U>
-inline bool
+BOOST_CXX14_CONSTEXPR inline bool
 operator!=(const bidirectional_iterator<T>& x, const bidirectional_iterator<U>& y)
 {
     return !(x == y);
@@ -172,30 +172,30 @@ public:
     typedef It                                                 pointer;
     typedef typename std::iterator_traits<It>::reference       reference;
 
-    It base() const {return it_;}
+    BOOST_CXX14_CONSTEXPR It base() const {return it_;}
 
-    random_access_iterator() : it_() {}
-    explicit random_access_iterator(It it) : it_(it) {}
+    BOOST_CXX14_CONSTEXPR random_access_iterator() : it_() {}
+    BOOST_CXX14_CONSTEXPR explicit random_access_iterator(It it) : it_(it) {}
     template <typename U>
-    random_access_iterator(const random_access_iterator<U>& u) :it_(u.it_) {}
+    BOOST_CXX14_CONSTEXPR random_access_iterator(const random_access_iterator<U>& u) :it_(u.it_) {}
 
-    reference operator*() const {return *it_;}
-    pointer  operator->() const {return  it_;}
+    BOOST_CXX14_CONSTEXPR reference operator*() const {return *it_;}
+    BOOST_CXX14_CONSTEXPR pointer  operator->() const {return  it_;}
 
-    random_access_iterator& operator++()    {++it_; return *this;}
-    random_access_iterator  operator++(int) {random_access_iterator tmp(*this); ++(*this); return tmp;}
+    BOOST_CXX14_CONSTEXPR random_access_iterator& operator++()    {++it_; return *this;}
+    BOOST_CXX14_CONSTEXPR random_access_iterator  operator++(int) {random_access_iterator tmp(*this); ++(*this); return tmp;}
 
-    random_access_iterator& operator--()    {--it_; return *this;}
-    random_access_iterator  operator--(int) {random_access_iterator tmp(*this); --(*this); return tmp;}
+    BOOST_CXX14_CONSTEXPR random_access_iterator& operator--()    {--it_; return *this;}
+    BOOST_CXX14_CONSTEXPR random_access_iterator  operator--(int) {random_access_iterator tmp(*this); --(*this); return tmp;}
 
-    random_access_iterator& operator+=(difference_type n)       {it_ += n; return *this;}
-    random_access_iterator  operator+ (difference_type n) const {random_access_iterator tmp(*this); tmp += n; return tmp;}
-    friend random_access_iterator operator+(difference_type n, random_access_iterator x) {x += n; return x;}
+    BOOST_CXX14_CONSTEXPR random_access_iterator& operator+=(difference_type n)       {it_ += n; return *this;}
+    BOOST_CXX14_CONSTEXPR random_access_iterator  operator+ (difference_type n) const {random_access_iterator tmp(*this); tmp += n; return tmp;}
+    BOOST_CXX14_CONSTEXPR friend random_access_iterator operator+(difference_type n, random_access_iterator x) {x += n; return x;}
 
-    random_access_iterator& operator-=(difference_type n)       {return *this += -n;}
-    random_access_iterator  operator- (difference_type n) const {random_access_iterator tmp(*this); tmp -= n; return tmp;}
+    BOOST_CXX14_CONSTEXPR random_access_iterator& operator-=(difference_type n)       {return *this += -n;}
+    BOOST_CXX14_CONSTEXPR random_access_iterator  operator- (difference_type n) const {random_access_iterator tmp(*this); tmp -= n; return tmp;}
 
-    reference operator[](difference_type n) const {return it_[n];}
+    BOOST_CXX14_CONSTEXPR reference operator[](difference_type n) const {return it_[n];}
 private:
     It it_;
 
@@ -203,49 +203,49 @@ private:
 };
 
 template <typename T, typename U>
-inline bool
+BOOST_CXX14_CONSTEXPR inline bool
 operator==(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
 {
     return x.base() == y.base();
 }
 
 template <typename T, typename U>
-inline bool
+BOOST_CXX14_CONSTEXPR inline bool
 operator!=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
 {
     return !(x == y);
 }
 
 template <typename T, typename U>
-inline bool
+BOOST_CXX14_CONSTEXPR inline bool
 operator<(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
 {
     return x.base() < y.base();
 }
 
 template <typename T, typename U>
-inline bool
+BOOST_CXX14_CONSTEXPR inline bool
 operator<=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
 {
     return !(y < x);
 }
 
 template <typename T, typename U>
-inline bool
+BOOST_CXX14_CONSTEXPR inline bool
 operator>(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
 {
     return y < x;
 }
 
 template <typename T, typename U>
-inline bool
+BOOST_CXX14_CONSTEXPR inline bool
 operator>=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
 {
     return !(x < y);
 }
 
 template <typename T, typename U>
-inline typename std::iterator_traits<T>::difference_type
+BOOST_CXX14_CONSTEXPR inline typename std::iterator_traits<T>::difference_type
 operator-(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
 {
     return x.base() - y.base();
@@ -262,18 +262,18 @@ public:
     typedef It                                                 pointer;
     typedef typename std::iterator_traits<It>::reference       reference;
 
-    It base() const {return it_;}
+    BOOST_CXX14_CONSTEXPR It base() const {return it_;}
 
-    output_iterator () {}
-    explicit output_iterator(It it) : it_(it) {}
+    BOOST_CXX14_CONSTEXPR output_iterator () {}
+    BOOST_CXX14_CONSTEXPR explicit output_iterator(It it) : it_(it) {}
 
     template <typename U>
-    output_iterator(const output_iterator<U>& u) :it_(u.it_) {}
+    BOOST_CXX14_CONSTEXPR output_iterator(const output_iterator<U>& u) :it_(u.it_) {}
 
-    reference operator*() const {return *it_;}
+    BOOST_CXX14_CONSTEXPR reference operator*() const {return *it_;}
 
-    output_iterator& operator++()    {++it_; return *this;}
-    output_iterator  operator++(int) {output_iterator tmp(*this); ++(*this); return tmp;}
+    BOOST_CXX14_CONSTEXPR output_iterator& operator++()    {++it_; return *this;}
+    BOOST_CXX14_CONSTEXPR output_iterator  operator++(int) {output_iterator tmp(*this); ++(*this); return tmp;}
 
 private:
     It it_;
@@ -285,21 +285,21 @@ private:
 
 // == Get the base of an iterator; used for comparisons ==
 template <typename Iter>
-inline Iter base(output_iterator<Iter> i) { return i.base(); }
+BOOST_CXX14_CONSTEXPR inline Iter base(output_iterator<Iter> i) { return i.base(); }
 
 template <typename Iter>
-inline Iter base(input_iterator<Iter> i) { return i.base(); }
+BOOST_CXX14_CONSTEXPR inline Iter base(input_iterator<Iter> i) { return i.base(); }
 
 template <typename Iter>
-inline Iter base(forward_iterator<Iter> i) { return i.base(); }
+BOOST_CXX14_CONSTEXPR inline Iter base(forward_iterator<Iter> i) { return i.base(); }
 
 template <typename Iter>
-inline Iter base(bidirectional_iterator<Iter> i) { return i.base(); }
+BOOST_CXX14_CONSTEXPR inline Iter base(bidirectional_iterator<Iter> i) { return i.base(); }
 
 template <typename Iter>
-inline Iter base(random_access_iterator<Iter> i) { return i.base(); }
+BOOST_CXX14_CONSTEXPR inline Iter base(random_access_iterator<Iter> i) { return i.base(); }
 
 template <typename Iter>    // everything else
-inline Iter base(Iter i) { return i; }
+BOOST_CXX14_CONSTEXPR inline Iter base(Iter i) { return i; }
 
 #endif  // ITERATORS_H

test/mismatch_test.cpp

@@ -16,149 +16,176 @@
 #include <boost/test/unit_test.hpp>
 
 template <typename T>
-bool eq ( const T& a, const T& b ) { return a == b; }
+BOOST_CXX14_CONSTEXPR bool eq ( const T& a, const T& b ) { return a == b; }
 
 template <typename T>
-bool never_eq ( const T&, const T& ) { return false; }
+BOOST_CXX14_CONSTEXPR bool never_eq ( const T&, const T& ) { return false; }
 
 namespace ba = boost::algorithm;
 
 template <typename Iter1, typename Iter2>
-bool iter_eq ( std::pair<Iter1, Iter2> pr, Iter1 first, Iter2 second ) {
+BOOST_CXX14_CONSTEXPR bool iter_eq ( std::pair<Iter1, Iter2> pr, Iter1 first, Iter2 second ) {
     return pr.first == first && pr.second == second;
     }
 
 void test_mismatch ()
 {
 //  Note: The literal values here are tested against directly, careful if you change them:
-    int num[] = { 1, 1, 2, 3, 5 };
+    BOOST_CXX14_CONSTEXPR int num[] = { 1, 1, 2, 3, 5 };
     const int sz = sizeof (num)/sizeof(num[0]);
     
     
 //  No mismatch for empty sequences
     BOOST_CHECK ( iter_eq ( 
-        ba::mismatch ( input_iterator<int *>(num),     input_iterator<int *>(num), 
-                       input_iterator<int *>(num),     input_iterator<int *>(num)),
-                input_iterator<int *>(num), input_iterator<int *>(num)));
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num), 
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num)),
+                input_iterator<const int *>(num), input_iterator<const int *>(num)));
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( input_iterator<int *>(num),     input_iterator<int *>(num), 
-                       input_iterator<int *>(num),     input_iterator<int *>(num),
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num), 
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num),
                        never_eq<int> ),
-                input_iterator<int *>(num), input_iterator<int *>(num)));
+                input_iterator<const int *>(num), input_iterator<const int *>(num)));
 
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( random_access_iterator<int *>(num),     random_access_iterator<int *>(num), 
-                       random_access_iterator<int *>(num),     random_access_iterator<int *>(num),
+        ba::mismatch ( random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num), 
+                       random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num),
                        never_eq<int> ),
-                random_access_iterator<int *>(num), random_access_iterator<int *>(num)));
+                random_access_iterator<const int *>(num), random_access_iterator<const int *>(num)));
                               
 //  Empty vs. non-empty mismatch immediately
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( input_iterator<int *>(num),     input_iterator<int *>(num), 
-                       input_iterator<int *>(num),     input_iterator<int *>(num + 1)),
-                input_iterator<int *>(num),     input_iterator<int *>(num)));
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num), 
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + 1)),
+                input_iterator<const int *>(num),     input_iterator<const int *>(num)));
 
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( input_iterator<int *>(num + 1), input_iterator<int *>(num + 2), 
-                       input_iterator<int *>(num),     input_iterator<int *>(num)),
-                input_iterator<int *>(num + 1), input_iterator<int *>(num)));
+        ba::mismatch ( input_iterator<const int *>(num + 1), input_iterator<const int *>(num + 2), 
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num)),
+                input_iterator<const int *>(num + 1), input_iterator<const int *>(num)));
                     
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( random_access_iterator<int *>(num + 1), random_access_iterator<int *>(num + 2), 
-                       random_access_iterator<int *>(num),     random_access_iterator<int *>(num)),
-                random_access_iterator<int *>(num + 1), random_access_iterator<int *>(num)));
+        ba::mismatch ( random_access_iterator<const int *>(num + 1), random_access_iterator<const int *>(num + 2), 
+                       random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num)),
+                random_access_iterator<const int *>(num + 1), random_access_iterator<const int *>(num)));
 
 //  Single element sequences are equal if they contain the same value
     BOOST_CHECK ( iter_eq ( 
-        ba::mismatch ( input_iterator<int *>(num),     input_iterator<int *>(num + 1),
-                       input_iterator<int *>(num),     input_iterator<int *>(num + 1)),
-                input_iterator<int *>(num + 1), input_iterator<int *>(num + 1)));
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + 1)),
+                input_iterator<const int *>(num + 1), input_iterator<const int *>(num + 1)));
                        
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( input_iterator<int *>(num),     input_iterator<int *>(num + 1),
-                       input_iterator<int *>(num),     input_iterator<int *>(num + 1),
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
                        eq<int> ),
-                input_iterator<int *>(num + 1), input_iterator<int *>(num + 1)));
+                input_iterator<const int *>(num + 1), input_iterator<const int *>(num + 1)));
                     
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( random_access_iterator<int *>(num),     random_access_iterator<int *>(num + 1),
-                       random_access_iterator<int *>(num),     random_access_iterator<int *>(num + 1),
+        ba::mismatch ( random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num + 1),
+                       random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num + 1),
                        eq<int> ),
-                random_access_iterator<int *>(num + 1), random_access_iterator<int *>(num + 1)));
+                random_access_iterator<const int *>(num + 1), random_access_iterator<const int *>(num + 1)));
 
 
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( input_iterator<int *>(num),     input_iterator<int *>(num + 1),
-                       input_iterator<int *>(num),     input_iterator<int *>(num + 1),
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
                        never_eq<int> ),
-               input_iterator<int *>(num),     input_iterator<int *>(num)));
+               input_iterator<const int *>(num),     input_iterator<const int *>(num)));
                
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( random_access_iterator<int *>(num),     random_access_iterator<int *>(num + 1),
-                       random_access_iterator<int *>(num),     random_access_iterator<int *>(num + 1),
+        ba::mismatch ( random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num + 1),
+                       random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num + 1),
                        never_eq<int> ),
-               random_access_iterator<int *>(num),     random_access_iterator<int *>(num)));
+               random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num)));
 
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( input_iterator<int *>(num),     input_iterator<int *>(num + 1),
-                       input_iterator<int *>(num + 1), input_iterator<int *>(num + 2)),
-               input_iterator<int *>(num + 1), input_iterator<int *>(num + 2)));
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
+                       input_iterator<const int *>(num + 1), input_iterator<const int *>(num + 2)),
+               input_iterator<const int *>(num + 1), input_iterator<const int *>(num + 2)));
 
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( input_iterator<int *>(num),     input_iterator<int *>(num + 1),
-                       input_iterator<int *>(num + 1), input_iterator<int *>(num + 2),
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
+                       input_iterator<const int *>(num + 1), input_iterator<const int *>(num + 2),
                        eq<int> ),
-               input_iterator<int *>(num + 1), input_iterator<int *>(num + 2)));
+               input_iterator<const int *>(num + 1), input_iterator<const int *>(num + 2)));
 
     BOOST_CHECK ( iter_eq (
-            ba::mismatch ( input_iterator<int *>(num + 2), input_iterator<int *>(num + 3), 
-                           input_iterator<int *>(num),     input_iterator<int *>(num + 1)),
-                           input_iterator<int *>(num + 2), input_iterator<int *>(num)));
+            ba::mismatch ( input_iterator<const int *>(num + 2), input_iterator<const int *>(num + 3), 
+                           input_iterator<const int *>(num),     input_iterator<const int *>(num + 1)),
+                           input_iterator<const int *>(num + 2), input_iterator<const int *>(num)));
                            
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( input_iterator<int *>(num + 2), input_iterator<int *>(num + 3),
-                       input_iterator<int *>(num),     input_iterator<int *>(num + 1),
+        ba::mismatch ( input_iterator<const int *>(num + 2), input_iterator<const int *>(num + 3),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
                        eq<int> ),
-               input_iterator<int *>(num + 2), input_iterator<int *>(num)));
+               input_iterator<const int *>(num + 2), input_iterator<const int *>(num)));
                        
                               
                               
 //  Identical long sequences are equal. 
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( input_iterator<int *>(num),     input_iterator<int *>(num + sz),
-                       input_iterator<int *>(num),     input_iterator<int *>(num + sz)),
-            input_iterator<int *>(num + sz), input_iterator<int *>(num + sz)));
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + sz),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + sz)),
+            input_iterator<const int *>(num + sz), input_iterator<const int *>(num + sz)));
 
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( input_iterator<int *>(num),     input_iterator<int *>(num + sz),
-                       input_iterator<int *>(num),     input_iterator<int *>(num + sz),
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + sz),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + sz),
                        eq<int> ),
-            input_iterator<int *>(num + sz), input_iterator<int *>(num + sz)));
+            input_iterator<const int *>(num + sz), input_iterator<const int *>(num + sz)));
 
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( input_iterator<int *>(num),     input_iterator<int *>(num + sz),
-                       input_iterator<int *>(num),     input_iterator<int *>(num + sz),
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + sz),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + sz),
                        never_eq<int> ),
-            input_iterator<int *>(num),     input_iterator<int *>(num)));
+            input_iterator<const int *>(num),     input_iterator<const int *>(num)));
 
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( input_iterator<int *>(num),             input_iterator<int *>(num + sz),
-                       random_access_iterator<int *>(num),     random_access_iterator<int *>(num + sz),
+        ba::mismatch ( input_iterator<const int *>(num),             input_iterator<const int *>(num + sz),
+                       random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num + sz),
                        never_eq<int> ),
-            input_iterator<int *>(num),     random_access_iterator<int *>(num)));
+            input_iterator<const int *>(num),     random_access_iterator<const int *>(num)));
 
-//  different sequences are different
+//  Different sequences are different
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( input_iterator<int *>(num + 1), input_iterator<int *>(num + sz),
-                       input_iterator<int *>(num),     input_iterator<int *>(num + sz)),
-            input_iterator<int *>(num + 2), input_iterator<int *>(num + 1)));
+        ba::mismatch ( input_iterator<const int *>(num + 1), input_iterator<const int *>(num + sz),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + sz)),
+            input_iterator<const int *>(num + 2), input_iterator<const int *>(num + 1)));
 
     BOOST_CHECK ( iter_eq (
-        ba::mismatch ( input_iterator<int *>(num + 1), input_iterator<int *>(num + sz),
-                       input_iterator<int *>(num),     input_iterator<int *>(num + sz),
+        ba::mismatch ( input_iterator<const int *>(num + 1), input_iterator<const int *>(num + sz),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + sz),
                        eq<int> ),
-            input_iterator<int *>(num + 2), input_iterator<int *>(num + 1)));
-
+            input_iterator<const int *>(num + 2), input_iterator<const int *>(num + 1)));
+            
+//  Checks constexpr
+    BOOST_CXX14_CONSTEXPR bool res = (
+//  No mismatch for empty
+        iter_eq ( 
+            ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num), 
+                           input_iterator<const int *>(num),     input_iterator<const int *>(num)),
+                input_iterator<const int *>(num), input_iterator<const int *>(num))
+//  Empty vs. non-empty mismatch immediately  
+        && iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num), 
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + 1)),
+                input_iterator<const int *>(num),     input_iterator<const int *>(num))
+//  Single element sequences are equal if they contain the same value                
+        && iter_eq ( 
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
+                       eq<int>),
+                input_iterator<const int *>(num + 1), input_iterator<const int *>(num + 1))
+//  Identical long sequences are equal.
+        && iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + sz),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + sz),
+                       eq<int> ),
+                input_iterator<const int *>(num + sz), input_iterator<const int *>(num + sz))
+        );
+    
+    BOOST_CHECK ( res );
 }
 
 

test/none_of_test.cpp

@@ -19,9 +19,8 @@
 
 template<typename T>
 struct is_ {
-    is_ ( T v ) : val_ ( v ) {}
-    ~is_ () {}
-    bool operator () ( T comp ) const { return val_ == comp; }
+    BOOST_CXX14_CONSTEXPR is_ ( T v ) : val_ ( v ) {}
+    BOOST_CXX14_CONSTEXPR bool operator () ( T comp ) const { return val_ == comp; }
 private:
     is_ (); // need a value
 
@@ -33,7 +32,7 @@ namespace ba = boost::algorithm;
 void test_none()
 {
 //  Note: The literal values here are tested against directly, careful if you change them:
-    int some_numbers[] = { 1, 5, 0, 18, 1 };
+    BOOST_CXX14_CONSTEXPR int some_numbers[] = { 1, 5, 0, 18, 1 };
     std::vector<int> vi(some_numbers, some_numbers + 5);
     std::list<int>   li(vi.begin(), vi.end ());
     
@@ -89,6 +88,15 @@ void test_none()
     BOOST_CHECK ( ba::none_of_equal ( li.begin(), l_iter,            18 ));
     BOOST_CHECK ( ba::none_of       ( li.begin(), l_iter, is_<int> ( 18 )));
     BOOST_CHECK (!ba::none_of       ( li.begin(), l_iter, is_<int> (  5 )));
+
+    BOOST_CXX14_CONSTEXPR bool constexpr_res =
+        !ba::none_of_equal ( some_numbers, 1 )                                 &&
+        !ba::none_of       ( some_numbers, is_<int> ( 1 ))                     &&
+         ba::none_of_equal ( some_numbers, some_numbers + 3,            100 )  &&
+         ba::none_of       ( some_numbers, some_numbers + 3, is_<int> ( 100 )) &&
+        true;
+
+    BOOST_CHECK ( constexpr_res );
 }
 
 BOOST_AUTO_TEST_CASE( test_main )

test/one_of_test.cpp

@@ -19,9 +19,8 @@
 
 template<typename T>
 struct is_ {
-    is_ ( T v ) : val_ ( v ) {}
-    ~is_ () {}
-    bool operator () ( T comp ) const { return val_ == comp; }
+    BOOST_CXX14_CONSTEXPR is_ ( T v ) : val_ ( v ) {}
+    BOOST_CXX14_CONSTEXPR bool operator () ( T comp ) const { return val_ == comp; }
 private:
     is_ (); // need a value
 
@@ -33,7 +32,7 @@ namespace ba = boost::algorithm;
 void test_one ()
 {
 //  Note: The literal values here are tested against directly, careful if you change them:
-    int some_numbers[] = { 1, 1, 2, 3, 5 };
+    BOOST_CXX14_CONSTEXPR int some_numbers[] = { 1, 1, 2, 3, 5 };
     std::vector<int> vi(some_numbers, some_numbers + 5);
     std::list<int>   li(vi.begin(), vi.end ());
     
@@ -92,7 +91,13 @@ void test_one ()
     BOOST_CHECK ( ba::one_of       ( li.begin(), l_iter, is_<int> ( 2 )));
     BOOST_CHECK (!ba::one_of_equal ( li.begin(), l_iter,            3 ));
     BOOST_CHECK (!ba::one_of       ( li.begin(), l_iter, is_<int> ( 3 )));
+    
+    BOOST_CXX14_CONSTEXPR bool constexpr_res =
+       !ba::one_of ( some_numbers, is_<int> ( 6 ))                       &&
+        ba::one_of ( some_numbers + 1, some_numbers + 3, is_<int> ( 1 )) &&
+       true;
 
+    BOOST_CHECK ( constexpr_res );
 }
 
 

test/ordered_test.cpp

@@ -29,11 +29,13 @@ using namespace boost;
 
 namespace ba = boost::algorithm;
 
+BOOST_CXX14_CONSTEXPR bool less( int x, int y ) { return x < y; }
+
 static void
 test_ordered(void)
 {
-    const int strictlyIncreasingValues[] = { 1, 2, 3, 4, 5 };
-    const int randomValues[] = { 3, 6, 1, 2, 7 };
+    BOOST_CXX14_CONSTEXPR const int strictlyIncreasingValues[] = { 1, 2, 3, 4, 5 };
+    BOOST_CXX14_CONSTEXPR const int randomValues[] = { 3, 6, 1, 2, 7 };
     const int constantValues[] = { 1, 2, 2, 2, 5 };
           int nonConstantArray[] = { 1, 2, 2, 2, 5 };
     const int inOrderUntilTheEnd [] = { 0, 1, 2, 3, 4, 5, 6, 7, 6 };
@@ -74,18 +76,26 @@ test_ordered(void)
     BOOST_CHECK ( ba::is_sorted_until ( a_begin(randomValues), a_begin(randomValues))                           == a_begin(randomValues));
     BOOST_CHECK ( ba::is_sorted_until ( a_begin(randomValues), a_begin(randomValues) + 1, std::equal_to<int>()) == a_begin(randomValues) + 1);
     BOOST_CHECK ( ba::is_sorted_until ( a_begin(randomValues), a_begin(randomValues) + 1 )                      == a_begin(randomValues) + 1);
+
+    BOOST_CXX14_CONSTEXPR bool constexpr_res = (
+        ba::is_sorted ( boost::begin(strictlyIncreasingValues), boost::end(strictlyIncreasingValues) )
+        && !ba::is_sorted (a_range(randomValues))
+        && ba::is_sorted_until ( boost::begin(strictlyIncreasingValues), boost::end(strictlyIncreasingValues), less) == a_end(strictlyIncreasingValues)
+        && ba::is_sorted_until ( randomValues, less)                                                                 == &randomValues[2]
+    );
+    BOOST_CHECK ( constexpr_res );
 }
 
 
 static void
 test_increasing_decreasing(void)
 {
-    const int strictlyIncreasingValues[] = { 1, 2, 3, 4, 5 };
-    const int strictlyDecreasingValues[] = { 9, 8, 7, 6, 5 };
-    const int increasingValues[] = { 1, 2, 2, 2, 5 };
-    const int decreasingValues[] = { 9, 7, 7, 7, 5 };
-    const int randomValues[] = { 3, 6, 1, 2, 7 };
-    const int constantValues[] = { 7, 7, 7, 7, 7 };
+    BOOST_CXX14_CONSTEXPR const int strictlyIncreasingValues[] = { 1, 2, 3, 4, 5 };
+    BOOST_CXX14_CONSTEXPR const int strictlyDecreasingValues[] = { 9, 8, 7, 6, 5 };
+    BOOST_CXX14_CONSTEXPR const int increasingValues[] = { 1, 2, 2, 2, 5 };
+    BOOST_CXX14_CONSTEXPR const int decreasingValues[] = { 9, 7, 7, 7, 5 };
+    BOOST_CXX14_CONSTEXPR const int randomValues[] = { 3, 6, 1, 2, 7 };
+    BOOST_CXX14_CONSTEXPR const int constantValues[] = { 7, 7, 7, 7, 7 };
 
     // Test a strictly increasing sequence
     BOOST_CHECK (  ba::is_strictly_increasing (b_e(strictlyIncreasingValues)));
@@ -146,6 +156,15 @@ test_increasing_decreasing(void)
     BOOST_CHECK ( !ba::is_strictly_decreasing (strictlyIncreasingValues, strictlyIncreasingValues+2));
     BOOST_CHECK ( !ba::is_decreasing          (strictlyIncreasingValues, strictlyIncreasingValues+2));
     
+    BOOST_CXX14_CONSTEXPR bool constexpr_res = (
+            ba::is_increasing           (boost::begin(increasingValues),         boost::end(increasingValues))
+        &&  ba::is_decreasing           (boost::begin(decreasingValues),         boost::end(decreasingValues))
+        &&  ba::is_strictly_increasing  (boost::begin(strictlyIncreasingValues), boost::end(strictlyIncreasingValues))
+        &&  ba::is_strictly_decreasing  (boost::begin(strictlyDecreasingValues), boost::end(strictlyDecreasingValues))
+        && !ba::is_strictly_increasing  (boost::begin(increasingValues),         boost::end(increasingValues))
+        && !ba::is_strictly_decreasing  (boost::begin(decreasingValues),         boost::end(decreasingValues))
+    );
+    BOOST_CHECK ( constexpr_res );
 }
 
 BOOST_AUTO_TEST_CASE( test_main )

test/partition_copy_test1.cpp

@@ -47,10 +47,10 @@ void test_sequence ( const Container &c, Predicate comp ) {
 template <typename T>
 struct less_than {
 public:
-    less_than ( T foo ) : val ( foo ) {}
-    less_than ( const less_than &rhs ) : val ( rhs.val ) {}
+    BOOST_CXX14_CONSTEXPR less_than ( T foo ) : val ( foo ) {}
+    BOOST_CXX14_CONSTEXPR less_than ( const less_than &rhs ) : val ( rhs.val ) {}
 
-    bool operator () ( const T &v ) const { return v < val; }
+    BOOST_CXX14_CONSTEXPR bool operator () ( const T &v ) const { return v < val; }
 private:
     less_than ();
     less_than operator = ( const less_than &rhs );
@@ -81,8 +81,30 @@ void test_sequence1 () {
 
     }
 
+    
+BOOST_CXX14_CONSTEXPR bool test_constexpr () {
+    int in[] = {1, 1, 2};
+    int out_true[3] = {0};
+    int out_false[3] = {0};
+    bool res = true;
+    ba::partition_copy( in, in + 3, out_true, out_false, less_than<int>(2) );
+    res = (res && ba::all_of(out_true, out_true + 2, less_than<int>(2)) );
+    res = (res && ba::none_of(out_false, out_false + 1, less_than<int>(2)) );
+    
+// clear elements
+    out_true [0] = 0;
+    out_true [1] = 0;
+    out_false[0] = 0;
+    
+    ba::partition_copy( in, out_true, out_false, less_than<int>(2));
+    res = ( res && ba::all_of(out_true, out_true + 2, less_than<int>(2)));
+    res = ( res && ba::none_of(out_false, out_false + 1, less_than<int>(2)));
+    return res;
+    }
 
 BOOST_AUTO_TEST_CASE( test_main )
 {
   test_sequence1 ();
+  BOOST_CXX14_CONSTEXPR bool constexpr_res = test_constexpr ();
+  BOOST_CHECK ( constexpr_res );
 }

test/partition_subrange_test.cpp

@@ -8,7 +8,7 @@
 #include <vector>
 #include <iostream>
 
-#if __cplusplus >= 201103L
+#if (__cplusplus >= 201103L) || defined(BOOST_NO_CXX98_RANDOM_SHUFFLE)
 #include <random>
 
 std::default_random_engine gen;
@@ -34,7 +34,7 @@ void check_sequence ( Iter first, Iter last, Iter sf, Iter sl )
 // 		}
 // 	if (sl == last) std::cout << "<";
 // 	std::cout << '\n';
-	
+
 	if (sf == sl) return;
 	for (Iter i = first; i < sf; ++i)
 		BOOST_CHECK(*i < *sf);
@@ -76,7 +76,7 @@ BOOST_AUTO_TEST_CASE( test_main )
 	std::vector<int> v;
 	for ( int i = 0; i < 10; ++i )
 		v.push_back(i);
-	
+
 	const std::vector<int>::iterator b = v.begin();
 	ba::partition_subrange(b, v.end(), b + 3, b + 6);
 	check_sequence        (b, v.end(), b + 3, b + 6);
@@ -84,7 +84,7 @@ BOOST_AUTO_TEST_CASE( test_main )
 // 	BOOST_CHECK_EQUAL(v[3], 3);
 // 	BOOST_CHECK_EQUAL(v[4], 4);
 // 	BOOST_CHECK_EQUAL(v[5], 5);
-	
+
 //	Mix them up and try again - single element
 	do_shuffle(v.begin(), v.end());
 	ba::partition_subrange(b, v.end(), b + 7, b + 8);
@@ -124,7 +124,7 @@ BOOST_AUTO_TEST_CASE( test_main )
 	std::vector<int> v;
 	for ( int i = 0; i < 10; ++i )
 		v.push_back(i);
-	
+
 	const std::vector<int>::iterator b = v.begin();
 	ba::partition_subrange(b, v.end(), b + 3, b + 6, std::greater<int>());
 	check_sequence        (b, v.end(), b + 3, b + 6, std::greater<int>());

test/power_test.cpp

@@ -18,7 +18,7 @@
 
 namespace ba = boost::algorithm;
 
-BOOST_AUTO_TEST_CASE( test_main )
+void test_power ()
 {
     BOOST_CHECK ( ba::power(0, 0) == 1);
     BOOST_CHECK ( ba::power(5, 0) == 1);
@@ -34,3 +34,51 @@ BOOST_AUTO_TEST_CASE( test_main )
     BOOST_CHECK ( ba::power(3,2) == ba::power(3,2, std::multiplies<int>()));
     BOOST_CHECK ( ba::power(3,2, std::plus<int>()) == 6);
 }
+
+
+void test_power_constexpr ()
+{
+    BOOST_CXX14_CONSTEXPR bool check_zero_power1 =
+        ba::power(0, 0) == 1;
+    BOOST_CHECK(check_zero_power1);
+    BOOST_CXX14_CONSTEXPR bool check_zero_power2 =
+        ba::power(5, 0) == 1;
+    BOOST_CHECK(check_zero_power2);
+    BOOST_CXX14_CONSTEXPR bool check_one_base1 =
+        ba::power(1, 1) == 1;
+    BOOST_CHECK(check_one_base1);
+    BOOST_CXX14_CONSTEXPR bool check_one_base2 =
+        ba::power(1, 4) == 1;
+    BOOST_CHECK(check_one_base2);
+    BOOST_CXX14_CONSTEXPR bool check_power1 = 
+        ba::power(3, 2) == 9;
+    BOOST_CHECK(check_power1);
+    BOOST_CXX14_CONSTEXPR bool check_power2 = 
+        ba::power(2, 3) == 8;
+    BOOST_CHECK(check_power2);
+    BOOST_CXX14_CONSTEXPR bool check_power3 = 
+        ba::power(3, 3) == 27;
+    BOOST_CHECK(check_power3);
+    BOOST_CXX14_CONSTEXPR bool check_power4 = 
+        ba::power(2, 30) == 0x40000000;
+    BOOST_CHECK(check_power4);
+    BOOST_CXX14_CONSTEXPR bool check_power5 = 
+        ba::power(5L, 10) == 3125*3125;
+    BOOST_CHECK(check_power5);
+    BOOST_CXX14_CONSTEXPR bool check_power6 = 
+        ba::power(18, 3) == 18*18*18;
+    BOOST_CHECK(check_power6);
+    
+    BOOST_CXX14_CONSTEXPR bool check_multiple = 
+        ba::power(3, 2, std::multiplies<int>()) == ba::power(3, 2);
+    BOOST_CHECK(check_multiple);
+    BOOST_CXX14_CONSTEXPR bool check_plus = 
+        ba::power(3, 2, std::plus<int>()) == 6;
+    BOOST_CHECK(check_plus);
+}
+
+
+BOOST_AUTO_TEST_CASE( test_main ) {
+  test_power ();
+  test_power_constexpr ();
+}

test/sort_subrange_test.cpp

@@ -8,7 +8,7 @@
 #include <vector>
 #include <iostream>
 
-#if __cplusplus >= 201103L
+#if (__cplusplus >= 201103L) || defined(BOOST_NO_CXX98_RANDOM_SHUFFLE)
 #include <random>
 
 std::default_random_engine gen;
@@ -57,7 +57,7 @@ BOOST_AUTO_TEST_CASE( test_main )
 	std::vector<int> v;
 	for ( int i = 0; i < 10; ++i )
 		v.push_back(i);
-	
+
 	const std::vector<int>::iterator b = v.begin();
 	ba::sort_subrange(b, v.end(), b + 3, b + 6);
 	check_sequence   (b, v.end(), b + 3, b + 6);
@@ -65,7 +65,7 @@ BOOST_AUTO_TEST_CASE( test_main )
 	BOOST_CHECK_EQUAL(v[3], 3);
 	BOOST_CHECK_EQUAL(v[4], 4);
 	BOOST_CHECK_EQUAL(v[5], 5);
-	
+
 //	Mix them up and try again - single element
 	do_shuffle(v.begin(), v.end());
 	ba::sort_subrange(b, v.end(), b + 7, b + 8);
@@ -105,7 +105,7 @@ BOOST_AUTO_TEST_CASE( test_main )
 	std::vector<int> v;
 	for ( int i = 0; i < 10; ++i )
 		v.push_back(i);
-	
+
 	const std::vector<int>::iterator b = v.begin();
 	ba::sort_subrange(b, v.end(), b + 3, b + 6, std::greater<int>());
 	check_sequence   (b, v.end(), b + 3, b + 6, std::greater<int>());