[DEV] add v1.76.0

libs/algorithm/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 ]
    ;
 }
 

libs/algorithm/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 );
 }
 
 

libs/algorithm/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 );
 }
 
 

libs/algorithm/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());
+    }
+}

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

libs/algorithm/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 );

libs/algorithm/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 );

libs/algorithm/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);
 }

libs/algorithm/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();
+}

libs/algorithm/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;

libs/algorithm/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();
+}

libs/algorithm/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);
 }

libs/algorithm/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 );
 }

libs/algorithm/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

libs/algorithm/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 );
 }
 
 

libs/algorithm/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 )

libs/algorithm/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 );
 }
 
 

libs/algorithm/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 )

libs/algorithm/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 );
 }

libs/algorithm/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>());

libs/algorithm/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 ();
+}

libs/algorithm/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>());