[DEV] add v1.66.0

libs/algorithm/example/Jamfile.v2

@@ -0,0 +1,25 @@
+#  Boost algorithm library example programs Jamfile
+#
+#  Copyright Marshall Clow 2010-2012. Use, modification and
+#  distribution is 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)
+#
+#  See http://www.boost.org for updates, documentation, and revision history.
+
+
+project /boost/algorithm/example
+    : requirements
+      <include>../../../
+      <optimization>speed
+      <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
+      <toolset>msvc:<define>NOMINMAX
+      <link>static
+    :
+    ;
+
+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;
+

libs/algorithm/example/clamp_example.cpp

@@ -0,0 +1,54 @@
+/* 
+   Copyright (c) Marshall Clow 2010-2012.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <string>
+#include <iostream>     // for cout, etc
+
+#include <boost/algorithm/clamp.hpp>
+
+namespace ba = boost::algorithm;
+
+bool compare_string_lengths ( const std::string &one, const std::string &two )
+{
+    return one.length () < two.length ();
+}
+
+int main ( int /*argc*/, char * /*argv*/ [] ) {
+//  Clamp takes a value and two "fenceposts", and brings the value "between" the fenceposts.
+
+//  If the input value is "between" the fenceposts, then it is returned unchanged.
+    std::cout << "Clamping   5 to between [1, 10] -> " << ba::clamp ( 5, 1, 10 ) << std::endl;
+
+//  If the input value is out side the range of the fenceposts, it "brought into" range.
+    std::cout << "Clamping  15 to between [1, 10] -> " << ba::clamp (  15, 1, 10 ) << std::endl;
+    std::cout << "Clamping -15 to between [1, 10] -> " << ba::clamp ( -15, 1, 10 ) << std::endl;
+
+//  It doesn't just work for ints
+    std::cout << "Clamping 5.1 to between [1, 10] -> " << ba::clamp ( 5.1, 1.0, 10.0 ) << std::endl;
+
+    {
+        std::string one ( "Lower Bound" ), two ( "upper bound!" ), test1 ( "test#" ), test2 ( "#test" );
+        std::cout << "Clamping '" << test1 << "' between ['" << one << "' and '" << two << "'] -> '" << 
+            ba::clamp ( test1, one, two ) << "'" << std::endl;
+        std::cout << "Clamping '" << test2 << "' between ['" << one << "' and '" << two << "'] -> '" << 
+            ba::clamp ( test2, one, two ) << "'" << std::endl;
+    //  There is also a predicate based version, if you want to compare objects in your own way
+        std::cout << "Clamping '" << test1 << "' between ['" << one << "' and '" << two << "'] (comparing lengths) -> '" << 
+            ba::clamp ( test1, one, two, compare_string_lengths ) << "'" << std::endl;
+        std::cout << "Clamping '" << test2 << "' between ['" << one << "' and '" << two << "'] (comparing lengths) -> '" << 
+            ba::clamp ( test2, one, two, compare_string_lengths ) << "'" << std::endl;
+    
+    }
+
+//  Sometimes, though, you don't get quite what you expect
+//  This is because the two double arguments get converted to int
+    std::cout << "Somewhat unexpected: clamp ( 12, 14.7, 15.9 ) --> " << ba::clamp ( 12, 14.7, 15.9 ) << std::endl;
+    std::cout << "Expected:     clamp ((double)12, 14.7, 15.9 ) --> " << ba::clamp ((double) 12, 14.7, 15.9 ) << std::endl;
+    return 0;
+    }

libs/algorithm/example/is_palindrome_example.cpp

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

libs/algorithm/example/is_partitioned_until_example.cpp

@@ -0,0 +1,70 @@
+/*
+   Copyright (c) Alexander Zaitsev <zamazan4ik@gmail.by>, 2017
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <vector>
+#include <functional>
+#include <iostream>
+
+#include <boost/algorithm/is_partitioned_until.hpp>
+
+
+namespace ba = boost::algorithm;
+
+bool isOdd(const int v1)
+{
+    return v1 % 2 != 0;
+}
+
+struct isOddComp
+{
+    bool operator()(const int v1) const
+    {
+        return v1 % 2 != 0;
+    }
+};
+
+
+int main ( int /*argc*/, char * /*argv*/ [] )
+{
+    std::vector<int> good({1, 2, 4});
+    std::vector<int> bad({1, 2, 3});
+
+    //Use custom function
+    auto it1 = ba::is_partitioned_until(good.begin(), good.end(), isOdd);
+    if(it1 == good.end())
+    {
+        std::cout << "The sequence is partitioned\n";
+    }
+    else
+    {
+        std::cout << "is_partitioned_until check failed here: " << *it1 << std::endl;
+    }
+
+    //Use custom comparator
+    auto it2 = ba::is_partitioned_until(good.begin(), good.end(), isOddComp());
+    if(it2 == good.end())
+    {
+        std::cout << "The sequence is partitioned\n";
+    }
+    else
+    {
+        std::cout << "is_partitioned_until check failed here: " << *it2 << std::endl;
+    }
+
+    auto it3 = ba::is_partitioned_until(bad, isOdd);
+    if(it3 == bad.end())
+    {
+        std::cout << "The sequence is partitioned\n";
+    }
+    else
+    {
+        std::cout << "is_partitioned_until check failed here: " << *it3 << std::endl;
+    }
+    return 0;
+}

libs/algorithm/example/search_example.cpp

@@ -0,0 +1,57 @@
+/* 
+   Copyright (c) Marshall Clow 2010-2012.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <string>
+#include <iostream>     //  for cout, etc.
+
+#include <boost/algorithm/searching/boyer_moore.hpp>
+#include <boost/algorithm/searching/boyer_moore_horspool.hpp>
+#include <boost/algorithm/searching/knuth_morris_pratt.hpp>
+
+namespace ba = boost::algorithm;
+
+const std::string haystack ( "ABACAB is it everywhere!" );
+const std::string needle1  ( "ACAB" );
+const std::string needle2  ( "not ABA" );
+
+
+
+int main ( int /*argc*/, char * /*argv*/ [] ) {
+//  In search.hpp, there are generic implementations of three classic sequence search
+//  algorithms. They all have the same (dual) interface.
+
+//  There is a procedural interface, based on std::search:
+    if ( ba::boyer_moore_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != haystack.end ())
+        std::cout << "Found '" << needle1 << "'  in '" << haystack << "' (boyer-moore 1)" << std::endl;
+    else
+        std::cout << "Did NOT find '" << needle1 << "'  in '" << haystack << "' (boyer-moore 1)" << std::endl;
+
+//  If you plan on searching for the same pattern in several different data sets,
+//  you can create a search object and use that over and over again - amortizing the setup
+//  costs across several searches
+    ba::boyer_moore<std::string::const_iterator> search1 ( needle1.begin (), needle1.end ());
+    if ( search1 ( haystack.begin (), haystack.end ()) != haystack.end ())
+        std::cout << "Found '" << needle1 << "'  in '" << haystack << "' (boyer-moore 2)" << std::endl;
+    else
+        std::cout << "Did NOT find '" << needle1 << "'  in '" << haystack << "' (boyer-moore 2)" << std::endl;
+
+//  There is also an implementation of boyer-moore-horspool searching
+    if ( ba::boyer_moore_horspool_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != haystack.end ())
+        std::cout << "Found '" << needle1 << "'  in '" << haystack << "' (boyer-moore-horspool)" << std::endl;
+    else
+        std::cout << "Did NOT find '" << needle1 << "'  in '" << haystack << "' (boyer-moore-horspool)" << std::endl;
+
+//  And also the knuth-pratt-morris search algorithm
+    if ( ba::knuth_morris_pratt_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != haystack.end ())
+        std::cout << "Found '" << needle1 << "'  in '" << haystack << "' (knuth_morris_pratt)" << std::endl;
+    else
+        std::cout << "Did NOT find '" << needle1 << "'  in '" << haystack << "' (knuth_morris_pratt)" << std::endl;
+
+    return 0;
+    }