hdkv/yuzu
1
Fork 0
Code Issues Pull Requests Releases 1 Activity

early-access version 3088

Browse Source
This commit is contained in:
pineappleEA
2022-11-05 15:35:56 +01:00
parent 4e4fc25ce3
commit b601909c6d
35519 changed files with 5996896 additions and 860 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/Jamfile.v2 vendored Executable file
View File

@@ -0,0 +1,57 @@
# Boost.Algorithm
#
# Copyright (c) 2010-2012 Marshall Clow
#
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
# Quickbook
# -----------------------------------------------------------------------------
import os ;
using quickbook ;
using doxygen ;
using boostbook ;
doxygen autodoc
:
[ glob ../../../boost/algorithm/*.hpp
../../../boost/algorithm/searching/*.hpp
../../../boost/algorithm/cxx11/*.hpp
../../../boost/algorithm/cxx14/*.hpp
../../../boost/algorithm/cxx17/*.hpp
]
:
<doxygen:param>"PREDEFINED=\"BOOST_ALGORITHM_DOXYGEN=1\""
<doxygen:param>WARNINGS=YES # Default NO, but useful to see warnings, especially in a logfile.
;
xml algorithm : algorithm.qbk ;
boostbook standalone
:
algorithm
:
<dependency>autodoc
<xsl:param>boost.root=../../../..
<xsl:param>"boost.doxygen.reftitle=Boost.Algorithms C++ Reference"
<xsl:param>chapter.autolabel=0
<xsl:param>chunk.section.depth=8
<xsl:param>toc.section.depth=3
<xsl:param>toc.max.depth=3
<xsl:param>generate.section.toc.level=1
;
###############################################################################
alias boostdoc
: ../string/doc/string_algo.xml
:
: <dependency>../string/doc//autodoc
: ;
explicit boostdoc ;
alias boostrelease : standalone ;
explicit boostrelease ;

264
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/algorithm.qbk vendored Executable file
View File

@@ -0,0 +1,264 @@
[library The Boost Algorithm Library
[quickbook 1.5]
[id algorithm]
[dirname algorithm]
[purpose Library of useful algorithms]
[category algorithms]
[authors [Clow, Marshall]]
[copyright 2010-2012 Marshall Clow]
[source-mode c++]
[license
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])
]
]
[section Description and Rationale]
Boost.Algorithm is a collection of general purpose algorithms. While Boost contains many libraries of data structures, there is no single library for general purpose algorithms. Even though the algorithms are generally useful, many tend to be thought of as "too small" for Boost.
An implementation of Boyer-Moore searching, for example, might take a developer a week or so to implement, including test cases and documentation. However, scheduling a review to include that code into Boost might take several months, and run into resistance because "it is too small". Nevertheless, a library of tested, reviewed, documented algorithms can make the developer's life much easier, and that is the purpose of this library.
[heading Future plans]
I will be soliciting submissions from other developers, as well as looking through the literature for existing algorithms to include. The Adobe Source Library, for example, contains many useful algorithms that already have documentation and test cases. Knuth's _The Art of Computer Programming_ is chock-full of algorithm descriptions, too.
My goal is to run regular algorithm reviews, similar to the Boost library review process, but with smaller chunks of code.
[heading Dependencies]
Boost.Algorithm uses Boost.Range, Boost.Assert, Boost.Array, Boost.TypeTraits, and Boost.StaticAssert.
[heading Acknowledgements]
Thanks to all the people who have reviewed this library and made suggestions for improvements. Steven Watanabe and Sean Parent, in particular, have provided a great deal of help.
[endsect]
[/ include toc.qbk]
[section:Searching Searching Algorithms]
[include boyer_moore.qbk]
[include boyer_moore_horspool.qbk]
[include knuth_morris_pratt.qbk]
[endsect]
[section:CXX11 C++11 Algorithms]
[section:CXX11_inner_algorithms]
[include all_of.qbk]
[include any_of.qbk]
[include none_of.qbk]
[include one_of.qbk]
[include ordered-hpp.qbk]
[include is_partitioned.qbk]
[include is_permutation.qbk]
[include partition_point.qbk]
[section:partition_copy partition_copy ]
[*[^[link header.boost.algorithm.cxx11.partition_copy_hpp partition_copy] ] ]
Copy a subset of a sequence to a new sequence
[endsect:partition_copy]
[section:copy_if copy_if ]
[*[^[link header.boost.algorithm.cxx11.copy_if_hpp copy_if] ] ]
Copy a subset of a sequence to a new sequence
[endsect:copy_if]
[section:copy_n copy_n ]
[*[^[link header.boost.algorithm.cxx11.copy_n_hpp copy_n] ] ]
Copy n items from one sequence to another
[endsect:copy_n]
[section:iota iota ]
[*[^[link header.boost.algorithm.cxx11.iota_hpp iota] ] ]
Generate an increasing series
[endsect:iota]
[endsect:CXX11_inner_algorithms]
[endsect:CXX11]
[section:CXX14 C++14 Algorithms]
[section:CXX14_inner_algorithms]
[include equal.qbk]
[include mismatch.qbk]
[endsect:CXX14_inner_algorithms]
[endsect:CXX14]
[section:CXX17 C++17 Algorithms]
[section:CXX17_inner_algorithms]
[section:for_each_n for_each_n]
[*[^[link boost.algorithm.for_each_n for_each_n] ] ]
Apply a functor to the elements of a sequence
[endsect:for_each_n]
[endsect:CXX17_inner_algorithms]
[endsect:CXX17]
[section:Misc Other Algorithms]
[section:misc_inner_algorithms]
[section:none_of_equal none_of_equal ]
[*[^[link header.boost.algorithm.cxx11.none_of_hpp none_of_equal] ] ]
Whether none of a range's elements matches a value
[endsect:none_of_equal]
[section:one_of_equal one_of_equal ]
[*[^[link header.boost.algorithm.cxx11.one_of_hpp one_of_equal] ] ]
Whether only one of a range's elements matches a value
[endsect:one_of_equal]
[section:is_decreasing is_decreasing ]
[*[^[link header.boost.algorithm.cxx11.is_sorted_hpp is_decreasing] ] ]
Whether an entire sequence is decreasing; i.e, each item is less than or equal to the previous one
[endsect:is_decreasing]
[section:is_increasing is_increasing ]
[*[^[link header.boost.algorithm.cxx11.is_sorted_hpp is_increasing] ] ]
Whether an entire sequence is increasing; i.e, each item is greater than or equal to the previous one
[endsect:is_increasing]
[section:is_strictly_decreasing is_strictly_decreasing ]
[*[^[link header.boost.algorithm.cxx11.is_sorted_hpp is_strictly_decreasing] ] ]
Whether an entire sequence is strictly decreasing; i.e, each item is less than the previous one
[endsect:is_strictly_decreasing]
[section:is_strictly_increasing is_strictly_increasing ]
[*[^[link header.boost.algorithm.cxx11.is_sorted_hpp is_strictly_increasing] ] ]
Whether an entire sequence is strictly increasing; i.e, each item is greater than the previous one
[endsect:is_strictly_increasing]
[include clamp-hpp.qbk]
[section:clamp_range clamp_range ]
[*[^[link header.boost.algorithm.clamp_hpp clamp_range] ] ]
Perform [^clamp] on the elements of a range and write the results into an output iterator
[endsect:clamp_range]
[include find_not.qbk]
[include find_backward.qbk]
[section:find_not_backward find_not_backward ]
[*[^[link header.boost.algorithm.find_backward_hpp find_not_backward] ] ]
Find the last element in a sequence that does not equal a value.
See [link the_boost_algorithm_library.Misc.misc_inner_algorithms.find_backward find_backward].
[endsect:find_not_backward]
[section:find_if_backward find_if_backward ]
[*[^[link header.boost.algorithm.find_backward_hpp find_if_backward] ] ]
Find the last element in a sequence that satisfies a predicate.
See [link the_boost_algorithm_library.Misc.misc_inner_algorithms.find_backward find_backward].
[endsect:find_if_backward]
[section:find_if_not find_if_not ]
[*[^[link header.boost.algorithm.cxx11.find_if_not_hpp find_if_not] ] ]
Find the first element in a sequence that does not satisfy a predicate.
See [link the_boost_algorithm_library.Misc.misc_inner_algorithms.find_not find_not].
[endsect:find_if_not]
[section:find_if_not_backward find_if_not_backward ]
[*[^[link header.boost.algorithm.find_backward_hpp find_if_not_backward] ] ]
Find the last element in a sequence that does not satisfy a predicate.
See [link the_boost_algorithm_library.Misc.misc_inner_algorithms.find_backward find_backward].
[endsect:find_if_not_backward]
[include gather.qbk]
[include hex.qbk]
[section:unhex unhex ]
[*[^[link header.boost.algorithm.hex_hpp unhex] ] ]
Convert a sequence of hexadecimal characters into a sequence of integers or characters
[endsect:unhex]
[section:hex_lower hex_lower ]
[*[^[link header.boost.algorithm.hex_hpp hex_lower] ] ]
Convert a sequence of integral types into a lower case hexadecimal sequence of characters
[endsect:hex_lower]
[include is_palindrome.qbk]
[include is_partitioned_until.qbk]
[section:apply_reverse_permutation apply_reverse_permutation ]
See below
[endsect:apply_reverse_permutation]
[include apply_permutation.qbk]
[section:copy_until copy_until ]
[*[^[link header.boost.algorithm.cxx11.copy_if_hpp copy_until] ] ]
Copy all the elements at the start of the input range that do not satisfy the predicate to the output range
[endsect:copy_until]
[section:copy_while copy_while ]
[*[^[link header.boost.algorithm.cxx11.copy_if_hpp copy_while] ] ]
Copy all the elements at the start of the input range that satisfy the predicate to the output range
[endsect:copy_while]
[section:iota_n iota_n ]
[*[^[link boost.algorithm.iota_n iota_n] ] ]
Write a sequence of n increasing values to an output iterator
[endsect:iota_n]
[section:power power ]
[*[^[link header.boost.algorithm.algorithm_hpp power] ] ]
Raise a value to an integral power ([^constexpr] since C++14)
[endsect:power]
[endsect:misc_inner_algorithms]
[endsect:Misc]
[section:not_yet_documented_cxx17_algos Not-yet-documented C++17 Algorithms]
* [*[^[link header.boost.algorithm.cxx17.exclusive_scan_hpp exclusive_scan] ] ]
* [*[^[link header.boost.algorithm.cxx17.inclusive_scan_hpp inclusive_scan] ] ]
* [*[^[link header.boost.algorithm.cxx17.reduce_hpp reduce] ] ]
* [*[^[link header.boost.algorithm.cxx17.transform_exclusive_scan_hpp transform_exclusive_scan] ] ]
* [*[^[link header.boost.algorithm.cxx17.transform_inclusive_scan_hpp transform_inclusive_scan] ] ]
* [*[^[link header.boost.algorithm.cxx17.transform_reduce_hpp transform_reduce] ] ]
[endsect:not_yet_documented_cxx17_algos]
[section:not_yet_documented_other_algos Not-yet-documented Other Algorithms]
* [*[^[link header.boost.algorithm.minmax_hpp minmax] ] ]
* [*[^[link header.boost.algorithm.minmax_element_hpp first_max_element] ] ]
* [*[^[link header.boost.algorithm.minmax_element_hpp first_min_element] ] ]
* [*[^[link header.boost.algorithm.minmax_element_hpp first_min_first_max_element] ] ]
* [*[^[link header.boost.algorithm.minmax_element_hpp first_min_last_max_element] ] ]
* [*[^[link header.boost.algorithm.minmax_element_hpp last_max_element] ] ]
* [*[^[link header.boost.algorithm.minmax_element_hpp last_min_element] ] ]
* [*[^[link header.boost.algorithm.minmax_element_hpp last_min_first_max_element] ] ]
* [*[^[link header.boost.algorithm.minmax_element_hpp last_min_last_max_element] ] ]
* [*[^[link header.boost.algorithm.minmax_element_hpp minmax_element] ] ]
* [*[^[link header.boost.algorithm.sort_subrange_hpp partition_subrange] ] ]
* [*[^[link header.boost.algorithm.sort_subrange_hpp sort_subrange] ] ]
[endsect:not_yet_documented_other_algos]
[xinclude autodoc.xml]

89
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/all_of.qbk vendored Executable file
View File

@@ -0,0 +1,89 @@
[/ File all_of.qbk]
[section:all_of all_of]
[/license
Copyright (c) 2010-2012 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
]
The header file 'boost/algorithm/cxx11/all_of.hpp' contains four variants of a single algorithm, `all_of`. The algorithm tests all the elements of a sequence and returns true if they all share a property.
The routine `all_of` takes a sequence and a predicate. It will return true if the predicate returns true when applied to every element in the sequence.
The routine `all_of_equal` takes a sequence and a value. It will return true if every element in the sequence compares equal to the passed in value.
Both routines come in two forms; the first one takes two iterators to define the range. The second form takes a single range parameter, and uses Boost.Range to traverse it.
[heading interface]
The function `all_of` returns true if the predicate returns true for every item in the sequence. There are two versions; one takes two iterators, and the other takes a range.
``
namespace boost { namespace algorithm {
template<typename InputIterator, typename Predicate>
bool all_of ( InputIterator first, InputIterator last, Predicate p );
template<typename Range, typename Predicate>
bool all_of ( const Range &r, Predicate p );
}}
``
The function `all_of_equal` is similar to `all_of`, but instead of taking a predicate to test the elements of the sequence, it takes a value to compare against.
``
namespace boost { namespace algorithm {
template<typename InputIterator, typename V>
bool all_of_equal ( InputIterator first, InputIterator last, V const &val );
template<typename Range, typename V>
bool all_of_equal ( const Range &r, V const &val );
}}
``
[heading Examples]
Given the container `c` containing `{ 0, 1, 2, 3, 14, 15 }`, then
``
bool isOdd ( int i ) { return i % 2 == 1; }
bool lessThan10 ( int i ) { return i < 10; }
using boost::algorithm;
all_of ( c, isOdd ) --> false
all_of ( c.begin (), c.end (), lessThan10 ) --> false
all_of ( c.begin (), c.begin () + 3, lessThan10 ) --> true
all_of ( c.end (), c.end (), isOdd ) --> true // empty range
all_of_equal ( c, 3 ) --> false
all_of_equal ( c.begin () + 3, c.begin () + 4, 3 ) --> true
all_of_equal ( c.begin (), c.begin (), 99 ) --> true // empty range
``
[heading Iterator Requirements]
`all_of` and `all_of_equal` work on all iterators except output iterators.
[heading Complexity]
All of the variants of `all_of` and `all_of_equal` run in ['O(N)] (linear) time; that is, they compare against each element in the list once. If any of the comparisons fail, the algorithm will terminate immediately, without examining the remaining members of the sequence.
[heading Exception Safety]
All of the variants of `all_of` and `all_of_equal` take their parameters by value or const reference, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
[heading Notes]
* The routine `all_of` is also available as part of the C++11 standard.
* `all_of` and `all_of_equal` both return true for empty ranges, no matter what is passed to test against. When there are no items in the sequence to test, they all satisfy the condition to be tested against.
* The second parameter to `all_of_value` is a template parameter, rather than deduced from the first parameter (`std::iterator_traits<InputIterator>::value_type`) because that allows more flexibility for callers, and takes advantage of built-in comparisons for the type that is pointed to by the iterator. The function is defined to return true if, for all elements in the sequence, the expression `*iter == val` evaluates to true (where `iter` is an iterator to each element in the sequence)
[endsect]
[/ File all_of.qbk
Copyright 2011 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
]

89
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/any_of.qbk vendored Executable file
View File

@@ -0,0 +1,89 @@
[/ File any_of.qbk]
[section:any_of any_of]
[/license
Copyright (c) 2010-2012 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
]
The header file 'boost/algorithm/cxx11/any_of.hpp' contains four variants of a single algorithm, `any_of`. The algorithm tests the elements of a sequence and returns true if any of the elements has a particular property.
The routine `any_of` takes a sequence and a predicate. It will return true if the predicate returns true for any element in the sequence.
The routine `any_of_equal` takes a sequence and a value. It will return true if any element in the sequence compares equal to the passed in value.
Both routines come in two forms; the first one takes two iterators to define the range. The second form takes a single range parameter, and uses Boost.Range to traverse it.
[heading interface]
The function `any_of` returns true if the predicate returns true any item in the sequence. There are two versions; one takes two iterators, and the other takes a range.
``
namespace boost { namespace algorithm {
template<typename InputIterator, typename Predicate>
bool any_of ( InputIterator first, InputIterator last, Predicate p );
template<typename Range, typename Predicate>
bool any_of ( const Range &r, Predicate p );
}}
``
The function `any_of_equal` is similar to `any_of`, but instead of taking a predicate to test the elements of the sequence, it takes a value to compare against.
``
namespace boost { namespace algorithm {
template<typename InputIterator, typename V>
bool any_of_equal ( InputIterator first, InputIterator last, V const &val );
template<typename Range, typename V>
bool any_of_equal ( const Range &r, V const &val );
}}
``
[heading Examples]
Given the container `c` containing `{ 0, 1, 2, 3, 14, 15 }`, then
``
bool isOdd ( int i ) { return i % 2 == 1; }
bool lessThan10 ( int i ) { return i < 10; }
using boost::algorithm;
any_of ( c, isOdd ) --> true
any_of ( c.begin (), c.end (), lessThan10 ) --> true
any_of ( c.begin () + 4, c.end (), lessThan10 ) --> false
any_of ( c.end (), c.end (), isOdd ) --> false // empty range
any_of_equal ( c, 3 ) --> true
any_of_equal ( c.begin (), c.begin () + 3, 3 ) --> false
any_of_equal ( c.begin (), c.begin (), 99 ) --> false // empty range
``
[heading Iterator Requirements]
`any_of` and `any_of_equal` work on all iterators except output iterators.
[heading Complexity]
All of the variants of `any_of` and `any_of_equal` run in ['O(N)] (linear) time; that is, they compare against each element in the list once. If any of the comparisons succeed, the algorithm will terminate immediately, without examining the remaining members of the sequence.
[heading Exception Safety]
All of the variants of `any_of` and `any_of_equal` take their parameters by value or const reference, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
[heading Notes]
* The routine `any_of` is also available as part of the C++11 standard.
* `any_of` and `any_of_equal` both return false for empty ranges, no matter what is passed to test against.
* The second parameter to `any_of_value` is a template parameter, rather than deduced from the first parameter (`std::iterator_traits<InputIterator>::value_type`) because that allows more flexibility for callers, and takes advantage of built-in comparisons for the type that is pointed to by the iterator. The function is defined to return true if, for any element in the sequence, the expression `*iter == val` evaluates to true (where `iter` is an iterator to each element in the sequence)
[endsect]
[/ File any_of.qbk
Copyright 2011 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
]

96
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/apply_permutation.qbk vendored Executable file
View File

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

109
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/boyer_moore.qbk vendored Executable file
View File

@@ -0,0 +1,109 @@
[/ QuickBook Document version 1.5 ]
[section:BoyerMoore Boyer-Moore Search]
[/license
Copyright (c) 2010-2012 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
]
[heading Overview]
The header file 'boyer_moore.hpp' contains an implementation of the Boyer-Moore algorithm for searching sequences of values.
The Boyer–Moore string search algorithm is a particularly efficient string searching algorithm, and it has been the standard benchmark for the practical string search literature. The Boyer-Moore algorithm was invented by Bob Boyer and J. Strother Moore, and published in the October 1977 issue of the Communications of the ACM , and a copy of that article is available at [@http://www.cs.utexas.edu/~moore/publications/fstrpos.pdf].
The Boyer-Moore algorithm uses two precomputed tables to give better performance than a naive search. These tables depend on the pattern being searched for, and give the Boyer-Moore algorithm larger a memory footprint and startup costs than a simpler algorithm, but these costs are recovered quickly during the searching process, especially if the pattern is longer than a few elements.
However, the Boyer-Moore algorithm cannot be used with comparison predicates like `std::search`.
Nomenclature: I refer to the sequence being searched for as the "pattern", and the sequence being searched in as the "corpus".
[heading Interface]
For flexibility, the Boyer-Moore algorithm has two interfaces; an object-based interface and a procedural one. The object-based interface builds the tables in the constructor, and uses operator () to perform the search. The procedural interface builds the table and does the search all in one step. If you are going to be searching for the same pattern in multiple corpora, then you should use the object interface, and only build the tables once.
Here is the object interface:
``
template <typename patIter>
class boyer_moore {
public:
boyer_moore ( patIter first, patIter last );
~boyer_moore ();
template <typename corpusIter>
pair<corpusIter, corpusIter> operator () ( corpusIter corpus_first, corpusIter corpus_last );
};
``
and here is the corresponding procedural interface:
``
template <typename patIter, typename corpusIter>
pair<corpusIter, corpusIter> boyer_moore_search (
corpusIter corpus_first, corpusIter corpus_last,
patIter pat_first, patIter pat_last );
``
Each of the functions is passed two pairs of iterators. The first two define the corpus and the second two define the pattern. Note that the two pairs need not be of the same type, but they do need to "point" at the same type. In other words, `patIter::value_type` and `curpusIter::value_type` need to be the same type.
The return value of the function is a pair of iterators pointing to the position of the pattern in the corpus. If the pattern is empty, it returns at empty range at the start of the corpus (`corpus_first`, `corpus_first`). If the pattern is not found, it returns at empty range at the end of the corpus (`corpus_last`, `corpus_last`).
[heading Compatibility Note]
Earlier versions of this searcher returned only a single iterator. As explained in [@https://cplusplusmusings.wordpress.com/2016/02/01/sometimes-you-get-things-wrong/], this was a suboptimal interface choice, and has been changed, starting in the 1.62.0 release. Old code that is expecting a single iterator return value can be updated by replacing the return value of the searcher's `operator ()` with the `.first` field of the pair.
Instead of:
``
iterator foo = searcher(a, b);
``
you now write:
``
iterator foo = searcher(a, b).first;
``
[heading Performance]
The execution time of the Boyer-Moore algorithm, while still linear in the size of the string being searched, can have a significantly lower constant factor than many other search algorithms: it doesn't need to check every character of the string to be searched, but rather skips over some of them. Generally the algorithm gets faster as the pattern being searched for becomes longer. Its efficiency derives from the fact that with each unsuccessful attempt to find a match between the search string and the text it is searching, it uses the information gained from that attempt to rule out as many positions of the text as possible where the string cannot match.
[heading Memory Use]
The algorithm allocates two internal tables. The first one is proportional to the length of the pattern; the second one has one entry for each member of the "alphabet" in the pattern. For (8-bit) character types, this table contains 256 entries.
[heading Complexity]
The worst-case performance to find a pattern in the corpus is ['O(N)] (linear) time; that is, proportional to the length of the corpus being searched. In general, the search is sub-linear; not every entry in the corpus need be checked.
[heading Exception Safety]
Both the object-oriented and procedural versions of the Boyer-Moore algorithm take their parameters by value and do not use any information other than what is passed in. Therefore, both interfaces provide the strong exception guarantee.
[heading Notes]
* When using the object-based interface, the pattern must remain unchanged for during the searches; i.e, from the time the object is constructed until the final call to operator () returns.
* The Boyer-Moore algorithm requires random-access iterators for both the pattern and the corpus.
[heading Customization points]
The Boyer-Moore object takes a traits template parameter which enables the caller to customize how one of the precomputed tables is stored. This table, called the skip table, contains (logically) one entry for every possible value that the pattern can contain. When searching 8-bit character data, this table contains 256 elements. The traits class defines the table to be used.
The default traits class uses a `boost::array` for small 'alphabets' and a `tr1::unordered_map` for larger ones. The array-based skip table gives excellent performance, but could be prohibitively large when the 'alphabet' of elements to be searched grows. The unordered_map based version only grows as the number of unique elements in the pattern, but makes many more heap allocations, and gives slower lookup performance.
To use a different skip table, you should define your own skip table object and your own traits class, and use them to instantiate the Boyer-Moore object. The interface to these objects is described TBD.
[endsect]
[/ File boyer_moore.qbk
Copyright 2011 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
]

107
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/boyer_moore_horspool.qbk vendored Executable file
View File

@@ -0,0 +1,107 @@
[/ QuickBook Document version 1.5 ]
[section:BoyerMooreHorspool Boyer-Moore-Horspool Search]
[/license
Copyright (c) 2010-2012 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
]
[heading Overview]
The header file 'boyer_moore_horspool.hpp' contains an implementation of the Boyer-Moore-Horspool algorithm for searching sequences of values.
The Boyer-Moore-Horspool search algorithm was published by Nigel Horspool in 1980. It is a refinement of the Boyer-Moore algorithm that trades space for time. It uses less space for internal tables than Boyer-Moore, and has poorer worst-case performance.
The Boyer-Moore-Horspool algorithm cannot be used with comparison predicates like `std::search`.
[heading Interface]
Nomenclature: I refer to the sequence being searched for as the "pattern", and the sequence being searched in as the "corpus".
For flexibility, the Boyer-Moore-Horspool algorithm has two interfaces; an object-based interface and a procedural one. The object-based interface builds the tables in the constructor, and uses operator () to perform the search. The procedural interface builds the table and does the search all in one step. If you are going to be searching for the same pattern in multiple corpora, then you should use the object interface, and only build the tables once.
Here is the object interface:
``
template <typename patIter>
class boyer_moore_horspool {
public:
boyer_moore_horspool ( patIter first, patIter last );
~boyer_moore_horspool ();
template <typename corpusIter>
pair<corpusIter, corpusIter> operator () ( corpusIter corpus_first, corpusIter corpus_last );
};
``
and here is the corresponding procedural interface:
``
template <typename patIter, typename corpusIter>
pair<corpusIter, corpusIter> boyer_moore_horspool_search (
corpusIter corpus_first, corpusIter corpus_last,
patIter pat_first, patIter pat_last );
``
Each of the functions is passed two pairs of iterators. The first two define the corpus and the second two define the pattern. Note that the two pairs need not be of the same type, but they do need to "point" at the same type. In other words, `patIter::value_type` and `curpusIter::value_type` need to be the same type.
The return value of the function is a pair of iterators pointing to the position of the pattern in the corpus. If the pattern is empty, it returns at empty range at the start of the corpus (`corpus_first`, `corpus_first`). If the pattern is not found, it returns at empty range at the end of the corpus (`corpus_last`, `corpus_last`).
[heading Compatibility Note]
Earlier versions of this searcher returned only a single iterator. As explained in [@https://cplusplusmusings.wordpress.com/2016/02/01/sometimes-you-get-things-wrong/], this was a suboptimal interface choice, and has been changed, starting in the 1.62.0 release. Old code that is expecting a single iterator return value can be updated by replacing the return value of the searcher's `operator ()` with the `.first` field of the pair.
Instead of:
``
iterator foo = searcher(a, b);
``
you now write:
``
iterator foo = searcher(a, b).first;
``
[heading Performance]
The execution time of the Boyer-Moore-Horspool algorithm is linear in the size of the string being searched; it can have a significantly lower constant factor than many other search algorithms: it doesn't need to check every character of the string to be searched, but rather skips over some of them. Generally the algorithm gets faster as the pattern being searched for becomes longer. Its efficiency derives from the fact that with each unsuccessful attempt to find a match between the search string and the text it is searching, it uses the information gained from that attempt to rule out as many positions of the text as possible where the string cannot match.
[heading Memory Use]
The algorithm an internal table that has one entry for each member of the "alphabet" in the pattern. For (8-bit) character types, this table contains 256 entries.
[heading Complexity]
The worst-case performance is ['O(m x n)], where ['m] is the length of the pattern and ['n] is the length of the corpus. The average time is ['O(n)]. The best case performance is sub-linear, and is, in fact, identical to Boyer-Moore, but the initialization is quicker and the internal loop is simpler than Boyer-Moore.
[heading Exception Safety]
Both the object-oriented and procedural versions of the Boyer-Moore-Horspool algorithm take their parameters by value and do not use any information other than what is passed in. Therefore, both interfaces provide the strong exception guarantee.
[heading Notes]
* When using the object-based interface, the pattern must remain unchanged for during the searches; i.e, from the time the object is constructed until the final call to operator () returns.
* The Boyer-Moore-Horspool algorithm requires random-access iterators for both the pattern and the corpus.
[heading Customization points]
The Boyer-Moore-Horspool object takes a traits template parameter which enables the caller to customize how the precomputed table is stored. This table, called the skip table, contains (logically) one entry for every possible value that the pattern can contain. When searching 8-bit character data, this table contains 256 elements. The traits class defines the table to be used.
The default traits class uses a `boost::array` for small 'alphabets' and a `tr1::unordered_map` for larger ones. The array-based skip table gives excellent performance, but could be prohibitively large when the 'alphabet' of elements to be searched grows. The unordered_map based version only grows as the number of unique elements in the pattern, but makes many more heap allocations, and gives slower lookup performance.
To use a different skip table, you should define your own skip table object and your own traits class, and use them to instantiate the Boyer-Moore-Horspool object. The interface to these objects is described TBD.
[endsect]
[/ File boyer_moore_horspool.qbk
Copyright 2011 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
]

73
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/clamp-hpp.qbk vendored Executable file
View File

@@ -0,0 +1,73 @@
[/ QuickBook Document version 1.5 ]
[section:clamp clamp]
[/license
Copyright (c) 2010-2012 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
]
The header file clamp.hpp contains two functions for "clamping" a value between a pair of boundary values.
[heading clamp]
The function `clamp (v, lo, hi)` returns:
* lo if v < lo
* hi if hi < v
* otherwise, v
Note: using `clamp` with floating point numbers may give unexpected results if one of the values is `NaN`.
There is also a version that allows the caller to specify a comparison predicate to use instead of `operator <`.
``
template<typename T>
const T& clamp ( const T& val, const T& lo, const T& hi );
template<typename T, typename Pred>
const T& clamp ( const T& val, const T& lo, const T& hi, Pred p );
``
The following code: ``
int foo = 23;
foo = clamp ( foo, 1, 10 );
``
will leave `foo` with a value of 10
Complexity:
`clamp` will make either one or two calls to the comparison predicate before returning one of the three parameters.
[heading clamp_range]
There are also four range-based versions of clamp, that apply clamping to a series of values. You could write them yourself with std::transform and bind, like this: `std::transform ( first, last, out, bind ( clamp ( _1, lo, hi )))`, but they are provided here for your convenience.
``
template<typename InputIterator, typename OutputIterator>
OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out,
typename std::iterator_traits<InputIterator>::value_type lo,
typename std::iterator_traits<InputIterator>::value_type hi );
template<typename Range, typename OutputIterator>
OutputIterator clamp_range ( const Range &r, OutputIterator out,
typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type lo,
typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type hi );
template<typename InputIterator, typename OutputIterator, typename Pred>
OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out,
typename std::iterator_traits<InputIterator>::value_type lo,
typename std::iterator_traits<InputIterator>::value_type hi, Pred p );
template<typename Range, typename OutputIterator, typename Pred>
OutputIterator clamp_range ( const Range &r, OutputIterator out,
typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type lo,
typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type hi,
Pred p );
``
[endsect]

80
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/equal.qbk vendored Executable file
View File

@@ -0,0 +1,80 @@
[/ File equal.qbk]
[section:equal equal ]
[/license
Copyright (c) 2013 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
]
The header file 'equal.hpp' contains two variants of a the stl algorithm `equal`. The algorithm tests to see if two sequences contain equal values;
Before (the proposed) C++14 the algorithm `std::equal` took three iterators and an optional comparison predicate. The first two iterators `[first1, last1)` defined a sequence, and the second one `first2` defined the start of the second sequence. The second sequence was assumed to be the same length as the first.
In C++14, two new variants were introduced, taking four iterators and an optional comparison predicate. The four iterators define two sequences `[first1, last1)` and `[first2, last2)` explicitly, rather than defining the second one implicitly. This leads to correct answers in more cases (and avoid undefined behavior in others).
Consider the two sequences:
```
auto seq1 = { 0, 1, 2 };
auto seq2 = { 0, 1, 2, 3, 4 };
std::equal ( seq1.begin (), seq1.end (), seq2.begin ()); // true
std::equal ( seq2.begin (), seq2.end (), seq1.begin ()); // Undefined behavior
std::equal ( seq1.begin (), seq1.end (), seq2.begin (), seq2.end ()); // false
```
You can argue that `true` is the correct answer in the first case, even though the sequences are not the same. The first N entries in `seq2` are the same as the entries in `seq1` - but that's not all that's in `seq2`. But in the second case, the algorithm will read past the end of `seq1`, resulting in undefined behavior (large earthquake, incorrect results, pregnant cat, etc).
However, if the two sequences are specified completely, it's clear that they are not equal.
[heading interface]
The function `equal` returns true if the two sequences compare equal; i.e, if each element in the sequence compares equal to the corresponding element in the other sequence. One version uses `std::equal_to` to do the comparison; the other lets the caller pass predicate to do the comparisons.
``
template <class InputIterator1, class InputIterator2>
bool equal ( InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2 );
template <class InputIterator1, class InputIterator2, class BinaryPredicate>
bool equal ( InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, BinaryPredicate pred );
``
[heading Examples]
Given the container `c1` containing `{ 0, 1, 2, 3, 14, 15 }`, and `c2` containing `{ 1, 2, 3 }`, then
``
equal ( c1.begin (), c1.end (), c2.begin (), c2.end ()) --> false
equal ( c1.begin () + 1, c1.begin () + 3, c2.begin (), c2.end ()) --> true
equal ( c1.end (), c1.end (), c2.end (), c2.end ()) --> true // empty sequences are alway equal to each other
``
[heading Iterator Requirements]
`equal` works on all iterators except output iterators.
[heading Complexity]
Both of the variants of `equal` run in ['O(N)] (linear) time; that is, they compare against each element in the list once. If the sequence is found to be not equal at any point, the routine will terminate immediately, without examining the rest of the elements.
[heading Exception Safety]
Both of the variants of `equal` take their parameters by value and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
[heading Notes]
* The four iterator version of the routine `equal` is part of the C++14 standard. When C++14 standard library implementations become available, the implementation from the standard library should be used.
* `equal` returns true for two empty ranges, no matter what predicate is passed to test against.
[endsect]
[/ File equal.qbk
Copyright 2011 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
]

116
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/find_backward.qbk vendored Executable file
View File

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

83
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/find_not.qbk vendored Executable file
View File

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

79
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/gather.qbk vendored Executable file
View File

@@ -0,0 +1,79 @@
[/ File gather.qbk]
[section:gather gather]
[/license
Copyright (c) 2013 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
]
The header file 'boost/algorithm/gather.hpp' contains two variants of a single algorithm, `gather`.
`gather()` takes a collection of elements defined by a pair of iterators and moves the ones satisfying a predicate to them to a position (called the pivot) within the sequence. The algorithm is stable. The result is a pair of iterators that contains the items that satisfy the predicate.
[heading Interface]
The function `gather` returns a `std::pair` of iterators that denote the elements that satisfy the predicate.
There are two versions; one takes two iterators, and the other takes a range.
``
namespace boost { namespace algorithm {
template <typename BidirectionalIterator, typename Pred>
std::pair<BidirectionalIterator,BidirectionalIterator>
gather ( BidirectionalIterator first, BidirectionalIterator last, BidirectionalIterator pivot, Pred pred );
template <typename BidirectionalRange, typename Pred>
std::pair<typename boost::range_iterator<const BidirectionalRange>::type, typename boost::range_iterator<const BidirectionalRange>::type>
gather ( const BidirectionalRange &range, typename boost::range_iterator<const BidirectionalRange>::type pivot, Pred pred );
}}
``
[heading Examples]
Given an sequence containing:
``
0 1 2 3 4 5 6 7 8 9
``
a call to gather ( arr, arr + 10, arr + 4, IsEven ) will result in:
``
1 3 0 2 4 6 8 5 7 9
|---|-----|
first | second
pivot
``
where `first` and `second` are the fields of the pair that is returned by the call.
[heading Iterator Requirements]
`gather` work on bidirectional iterators or better. This requirement comes from the usage of `stable_partition`, which requires bidirectional iterators. Some standard libraries (libstdc++ and libc++, for example) have implementations of `stable_partition` that work with forward iterators. If that is the case, then `gather` will work with forward iterators as well.
[heading Storage Requirements]
`gather` uses `stable_partition`, which will attempt to allocate temporary memory, but will work in-situ if there is none available.
[heading Complexity]
If there is sufficient memory available, the run time is linear: `O(N)`
If there is not any memory available, then the run time is `O(N log N)`.
[heading Exception Safety]
[heading Notes]
[endsect]
[/ File gather.qbk
Copyright 2013 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
]

109
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/hex.qbk vendored Executable file
View File

@@ -0,0 +1,109 @@
[/ File hex.qbk]
[section:hex hex]
[/license
Copyright (c) 2011-2012 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
]
The header file `'boost/algorithm/hex.hpp'` contains three variants each of two algorithms, `hex` and `unhex`. They are inverse algorithms; that is, one undoes the effort of the other. `hex` takes a sequence of values, and turns them into hexadecimal characters. `unhex` takes a sequence of hexadecimal characters, and outputs a sequence of values.
`hex` and `unhex` come from MySQL, where they are used in database queries and stored procedures.
[heading interface]
The function `hex` takes a sequence of values and writes hexadecimal characters. There are three different interfaces, differing only in how the input sequence is specified.
The first one takes an iterator pair. The second one takes a pointer to the start of a zero-terminated sequence, such as a c string, and the third takes a range as defined by the Boost.Range library.
``
template <typename InputIterator, typename OutputIterator>
OutputIterator hex ( InputIterator first, InputIterator last, OutputIterator out );
template <typename T, typename OutputIterator>
OutputIterator hex ( const T *ptr, OutputIterator out );
template <typename Range, typename OutputIterator>
OutputIterator hex ( const Range &r, OutputIterator out );
``
`hex` writes only values in the range '0'..'9' and 'A'..'F', but is not limited to character output. The output iterator could refer to a wstring, or a vector of integers, or any other integral type.
The function `unhex` takes the output of `hex` and turns it back into a sequence of values.
The input parameters for the different variations of `unhex` are the same as `hex`.
``
template <typename InputIterator, typename OutputIterator>
OutputIterator unhex ( InputIterator first, InputIterator last, OutputIterator out );
template <typename T, typename OutputIterator>
OutputIterator unhex ( const T *ptr, OutputIterator out );
template <typename Range, typename OutputIterator>
OutputIterator unhex ( const Range &r, OutputIterator out );
``
[heading Error Handling]
The header 'hex.hpp' defines three exception classes:
``
struct hex_decode_error: virtual boost::exception, virtual std::exception {};
struct not_enough_input : public hex_decode_error;
struct non_hex_input : public hex_decode_error;
``
If the input to `unhex` does not contain an "even number" of hex digits, then an exception of type `boost::algorithm::not_enough_input` is thrown.
If the input to `unhex` contains any non-hexadecimal characters, then an exception of type `boost::algorithm::non_hex_input` is thrown.
If you want to catch all the decoding errors, you can catch exceptions of type `boost::algorithm::hex_decode_error`.
[heading Examples]
Assuming that `out` is an iterator that accepts `char` values, and `wout` accepts `wchar_t` values (and that sizeof ( wchar_t ) == 2)
``
hex ( "abcdef", out ) --> "616263646566"
hex ( "32", out ) --> "3332"
hex ( "abcdef", wout ) --> "006100620063006400650066"
hex ( "32", wout ) --> "00330032"
unhex ( "616263646566", out ) --> "abcdef"
unhex ( "3332", out ) --> "32"
unhex ( "616263646566", wout ) --> "\6162\6364\6566" ( i.e, a 3 character string )
unhex ( "3332", wout ) --> "\3233" ( U+3332, SQUARE HUARADDO )
unhex ( "3", out ) --> Error - not enough input
unhex ( "32", wout ) --> Error - not enough input
unhex ( "ACEG", out ) --> Error - non-hex input
``
[heading Iterator Requirements]
`hex` and `unhex` work on all iterator types.
[heading Complexity]
All of the variants of `hex` and `unhex` run in ['O(N)] (linear) time; that is, that is, they process each element in the input sequence once.
[heading Exception Safety]
All of the variants of `hex` and `unhex` take their parameters by value or const reference, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee. However, when working on input iterators, if an exception is thrown, the input iterators will not be reset to their original values (i.e, the characters read from the iterator cannot be un-read)
[heading Notes]
* `hex` and `unhex` both do nothing when passed empty ranges.
[endsect]
[/ File hex.qbk
Copyright 2011 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
]

98
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/is_palindrome.qbk vendored Executable file
View File

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

69
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/is_partitioned.qbk vendored Executable file
View File

@@ -0,0 +1,69 @@
[/ File is_partitioned.qbk]
[section:is_partitioned is_partitioned ]
[/license
Copyright (c) 2010-2012 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
]
The header file 'is_partitioned.hpp' contains two variants of a single algorithm, `is_partitioned`. The algorithm tests to see if a sequence is partitioned according to a predicate; in other words, all the items in the sequence that satisfy the predicate are at the beginning of the sequence.
The routine `is_partitioned` takes a sequence and a predicate. It returns true if the sequence is partitioned according to the predicate.
`is_partitioned` come in two forms; the first one takes two iterators to define the range. The second form takes a single range parameter, and uses Boost.Range to traverse it.
[heading interface]
The function `is_partitioned` returns true if the items in the sequence are separated according to their ability to satisfy the predicate. There are two versions; one takes two iterators, and the other takes a range.
``
template<typename InputIterator, typename Predicate>
bool is_partitioned ( InputIterator first, InputIterator last, Predicate p );
template<typename Range, typename Predicate>
bool is_partitioned ( const Range &r, Predicate p );
``
[heading Examples]
Given the container `c` containing `{ 0, 1, 2, 3, 14, 15 }`, then
``
bool isOdd ( int i ) { return i % 2 == 1; }
bool lessThan10 ( int i ) { return i < 10; }
is_partitioned ( c, isOdd ) --> false
is_partitioned ( c, lessThan10 ) --> true
is_partitioned ( c.begin (), c.end (), lessThan10 ) --> true
is_partitioned ( c.begin (), c.begin () + 3, lessThan10 ) --> true
is_partitioned ( c.end (), c.end (), isOdd ) --> true // empty range
``
[heading Iterator Requirements]
`is_partitioned` works on all iterators except output iterators.
[heading Complexity]
Both of the variants of `is_partitioned` run in ['O(N)] (linear) time; that is, they compare against each element in the list once. If the sequence is found to be not partitioned at any point, the routine will terminate immediately, without examining the rest of the elements.
[heading Exception Safety]
Both of the variants of `is_partitioned` take their parameters by value or const reference, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
[heading Notes]
* The iterator-based version of the routine `is_partitioned` is also available as part of the C++11 standard.
* `is_partitioned` returns true for empty and single-element ranges, no matter what predicate is passed to test against.
[endsect]
[/ File is_partitioned.qbk
Copyright 2011 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
]

67
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/is_partitioned_until.qbk vendored Executable file
View File

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

87
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/is_permutation.qbk vendored Executable file
View File

@@ -0,0 +1,87 @@
[/ File is_permutation.qbk]
[section:is_permutation is_permutation ]
[/license
Copyright (c) 2010-2012 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
]
The header file 'is_permutation.hpp' contains six variants of a single algorithm, `is_permutation`. The algorithm tests to see if one sequence is a permutation of a second one; in other words, it contains all the same members, possibly in a different order.
The routine `is_permutation` takes two sequences and an (optional) predicate. It returns true if the two sequences contain the same members. If it is passed a predicate, it uses the predicate to compare the elements of the sequence to see if they are the same.
`is_permutation` come in three forms. The first one takes two iterators to define the first range, and the starting iterator of the second range. The second form takes a two iterators to define the first range and two more to define the second range. The third form takes a single range parameter, and uses Boost.Range to traverse it.
[heading Interface]
The function `is_permutation` returns true if the two input sequences contain the same elements. There are six versions; two take three iterators, two take four iterators, and the other two take two ranges.
In general, you should prefer the four iterator versions over the three iterator ones. The three iterator version has to "create" the fourth iterator internally by calling `std::advance(first2, std::distance(first1,last1))`, and if the second sequence is shorter than the first, that's undefined behavior.
``
template< class ForwardIterator1, class ForwardIterator2 >
bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2 );
template< class ForwardIterator1, class ForwardIterator2, class BinaryPredicate >
bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, BinaryPredicate p );
template< class ForwardIterator1, class ForwardIterator2 >
bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2 );
template< class ForwardIterator1, class ForwardIterator2, class BinaryPredicate >
bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2,
BinaryPredicate p );
template <typename Range, typename ForwardIterator>
bool is_permutation ( const Range &r, ForwardIterator first2 );
template <typename Range, typename ForwardIterator, typename BinaryPredicate>
bool is_permutation ( const Range &r, ForwardIterator first2, BinaryPredicate pred );
``
[heading Examples]
Given the container `c1` containing `{ 0, 1, 2, 3, 14, 15 }`, and `c2` containing `{ 15, 14, 3, 1, 2 }`, then
``
is_permutation ( c1.begin(), c1.end (), c2.begin(), c2.end ()) --> false
is_permutation ( c1.begin() + 1, c1.end (), c2.begin(), c2.end ()) --> true
is_permutation ( c1.end (), c1.end (), c2.end(), c2.end ()) --> true // all empty ranges are permutations of each other
``
[heading Iterator Requirements]
`is_permutation` works on forward iterators or better.
[heading Complexity]
All of the variants of `is_permutation` run in ['O(N^2)] (quadratic) time; that is, they compare against each element in the list (potentially) N times. If passed random-access iterators, `is_permutation` can return quickly if the sequences are different sizes.
[heading Exception Safety]
All of the variants of `is_permutation` take their parameters by value, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
[heading Notes]
* The three iterator versions of the routine `is_permutation` are also available as part of the C++11 standard.
* The four iterator versions of the routine `is_permutation` are part of the proposed C++14 standard. When C++14 standard libraries become available, the implementation should be changed to use the implementation from the standard library (if available).
* `is_permutation` returns true when passed a pair of empty ranges, no matter what predicate is passed to test with.
[endsect]
[/ File is_permutation.qbk
Copyright 2011 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
]

101
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/knuth_morris_pratt.qbk vendored Executable file
View File

@@ -0,0 +1,101 @@
[/ QuickBook Document version 1.5 ]
[section:KnuthMorrisPratt Knuth-Morris-Pratt Search]
[/license
Copyright (c) 2010-2012 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
]
[heading Overview]
The header file 'knuth_morris_pratt.hpp' contains an implementation of the Knuth-Morris-Pratt algorithm for searching sequences of values.
The basic premise of the Knuth-Morris-Pratt algorithm is that when a mismatch occurs, there is information in the pattern being searched for that can be used to determine where the next match could begin, enabling the skipping of some elements of the corpus that have already been examined.
It does this by building a table from the pattern being searched for, with one entry for each element in the pattern.
The algorithm was conceived in 1974 by Donald Knuth and Vaughan Pratt, and independently by James H. Morris. The three published it jointly in 1977 in the SIAM Journal on Computing [@http://citeseer.ist.psu.edu/context/23820/0]
However, the Knuth-Morris-Pratt algorithm cannot be used with comparison predicates like `std::search`.
[heading Interface]
Nomenclature: I refer to the sequence being searched for as the "pattern", and the sequence being searched in as the "corpus".
For flexibility, the Knuth-Morris-Pratt algorithm has two interfaces; an object-based interface and a procedural one. The object-based interface builds the table in the constructor, and uses operator () to perform the search. The procedural interface builds the table and does the search all in one step. If you are going to be searching for the same pattern in multiple corpora, then you should use the object interface, and only build the tables once.
Here is the object interface:
``
template <typename patIter>
class knuth_morris_pratt {
public:
knuth_morris_pratt ( patIter first, patIter last );
~knuth_morris_pratt ();
template <typename corpusIter>
pair<corpusIter, corpusIter> operator () ( corpusIter corpus_first, corpusIter corpus_last );
};
``
and here is the corresponding procedural interface:
``
template <typename patIter, typename corpusIter>
pair<corpusIter, corpusIter> knuth_morris_pratt_search (
corpusIter corpus_first, corpusIter corpus_last,
patIter pat_first, patIter pat_last );
``
Each of the functions is passed two pairs of iterators. The first two define the corpus and the second two define the pattern. Note that the two pairs need not be of the same type, but they do need to "point" at the same type. In other words, `patIter::value_type` and `curpusIter::value_type` need to be the same type.
The return value of the function is a pair of iterators pointing to the position of the pattern in the corpus. If the pattern is empty, it returns at empty range at the start of the corpus (`corpus_first`, `corpus_first`). If the pattern is not found, it returns at empty range at the end of the corpus (`corpus_last`, `corpus_last`).
[heading Compatibility Note]
Earlier versions of this searcher returned only a single iterator. As explained in [@https://cplusplusmusings.wordpress.com/2016/02/01/sometimes-you-get-things-wrong/], this was a suboptimal interface choice, and has been changed, starting in the 1.62.0 release. Old code that is expecting a single iterator return value can be updated by replacing the return value of the searcher's `operator ()` with the `.first` field of the pair.
Instead of:
``
iterator foo = searcher(a, b);
``
you now write:
``
iterator foo = searcher(a, b).first;
``
[heading Performance]
The execution time of the Knuth-Morris-Pratt algorithm is linear in the size of the string being searched. Generally the algorithm gets faster as the pattern being searched for becomes longer. Its efficiency derives from the fact that with each unsuccessful attempt to find a match between the search string and the text it is searching, it uses the information gained from that attempt to rule out as many positions of the text as possible where the string cannot match.
[heading Memory Use]
The algorithm an that contains one entry for each element the pattern, plus one extra. So, when searching for a 1026 byte string, the table will have 1027 entries.
[heading Complexity]
The worst-case performance is ['O(2n)], where ['n] is the length of the corpus. The average time is ['O(n)]. The best case performance is sub-linear.
[heading Exception Safety]
Both the object-oriented and procedural versions of the Knuth-Morris-Pratt algorithm take their parameters by value and do not use any information other than what is passed in. Therefore, both interfaces provide the strong exception guarantee.
[heading Notes]
* When using the object-based interface, the pattern must remain unchanged for during the searches; i.e, from the time the object is constructed until the final call to operator () returns.
* The Knuth-Morris-Pratt algorithm requires random-access iterators for both the pattern and the corpus. It should be possible to write this to use bidirectional iterators (or possibly even forward ones), but this implementation does not do that.
[endsect]
[/ File knuth_morris_pratt.qbk
Copyright 2011 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
]

82
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/mismatch.qbk vendored Executable file
View File

@@ -0,0 +1,82 @@
[/ File mismatch.qbk]
[section:mismatch mismatch ]
[/license
Copyright (c) 2013 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
]
The header file 'mismatch.hpp' contains two variants of a the stl algorithm `mismatch`. The algorithm finds the first point in two sequences where they do not match.
Before (the proposed) C++14 the algorithm `std::mismatch` took three iterators and an optional comparison predicate. The first two iterators `[first1, last1)` defined a sequence, and the second one `first2` defined the start of the second sequence. The second sequence was assumed to be the same length as the first.
In C++14, two new variants were introduced, taking four iterators and an optional comparison predicate. The four iterators define two sequences `[first1, last1)` and `[first2, last2)` explicitly, rather than defining the second one implicitly. This leads to correct answers in more cases (and avoid undefined behavior in others).
Consider the two sequences:
```
auto seq1 = { 0, 1, 2 };
auto seq2 = { 0, 1, 2, 3, 4 };
std::mismatch ( seq1.begin (), seq1.end (), seq2.begin ()); // <3, 3>
std::mismatch ( seq2.begin (), seq2.end (), seq1.begin ()); // Undefined behavior
std::mismatch ( seq1.begin (), seq1.end (), seq2.begin (), seq2.end ()); // <3, 3>
```
The first N entries in `seq2` are the same as the entries in `seq1` - but that's not all that's in `seq2`. In the second case, the algorithm will read past the end of `seq1`, resulting in undefined behavior (large earthquake, incorrect results, pregnant cat, etc).
However, if the two sequences are specified completely, it's clear that where the mismatch occurs.
[heading interface]
The function `mismatch` returns a pair of iterators which denote the first mismatching elements in each sequence. If the sequences match completely, `mismatch` returns their end iterators. One version uses `std::equal_to` to do the comparison; the other lets the caller pass predicate to do the comparisons.
``
template <class InputIterator1, class InputIterator2>
std::pair<InputIterator1, InputIterator2>
mismatch ( InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2 );
template <class InputIterator1, class InputIterator2, class BinaryPredicate>
std::pair<InputIterator1, InputIterator2>
mismatch ( InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, BinaryPredicate pred );
``
[heading Examples]
Given the container `c1` containing `{ 0, 1, 2, 3, 14, 15 }`, and `c2` containing `{ 1, 2, 3 }`, then
``
mismatch ( c1.begin(), c1.end(), c2.begin(), c2.end()) --> <c1.begin(), c2.begin()> // first elements do not match
mismatch ( c1.begin() + 1, c1.begin() + 4, c2.begin(), c2.end()) --> <c1.begin() + 4, c2.end ()> // all elements of `c2` match
mismatch ( c1.end(), c1.end(), c2.end(), c2.end()) --> <c1.end(), c2.end()> // empty sequences don't match at the end.
``
[heading Iterator Requirements]
`mismatch` works on all iterators except output iterators.
[heading Complexity]
Both of the variants of `mismatch` run in ['O(N)] (linear) time; that is, they compare against each element in the list once. If the sequence is found to be not equal at any point, the routine will terminate immediately, without examining the rest of the elements.
[heading Exception Safety]
Both of the variants of `mismatch` take their parameters by value and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
[heading Notes]
* If the sequences are equal (or both are empty), then mismatch returns the end iterators of both sequences.
* The four iterator version of the routine `mismatch` is part of the C++14 standard. When C++14 standard library implementations become available, the implementation from the standard library should be used.
[endsect]
[/ File mismatch.qbk
Copyright 2011 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
]

90
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/none_of.qbk vendored Executable file
View File

@@ -0,0 +1,90 @@
[/ File none_of.qbk]
[section:none_of none_of]
[/license
Copyright (c) 2010-2012 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
]
The header file 'boost/algorithm/cxx11/none_of.hpp' contains four variants of a single algorithm, `none_of`. The algorithm tests all the elements of a sequence and returns true if they none of them share a property.
The routine `none_of` takes a sequence and a predicate. It will return true if the predicate returns false when applied to every element in the sequence.
The routine `none_of_equal` takes a sequence and a value. It will return true if none of the elements in the sequence compare equal to the passed in value.
Both routines come in two forms; the first one takes two iterators to define the range. The second form takes a single range parameter, and uses Boost.Range to traverse it.
[heading interface]
The function `none_of` returns true if the predicate returns false for every item in the sequence. There are two versions; one takes two iterators, and the other takes a range.
``
namespace boost { namespace algorithm {
template<typename InputIterator, typename Predicate>
bool none_of ( InputIterator first, InputIterator last, Predicate p );
template<typename Range, typename Predicate>
bool none_of ( const Range &r, Predicate p );
}}
``
The function `none_of_equal` is similar to `none_of`, but instead of taking a predicate to test the elements of the sequence, it takes a value to compare against.
``
namespace boost { namespace algorithm {
template<typename InputIterator, typename V>
bool none_of_equal ( InputIterator first, InputIterator last, V const &val );
template<typename Range, typename V>
bool none_of_equal ( const Range &r, V const &val );
}}
``
[heading Examples]
Given the container `c` containing `{ 0, 1, 2, 3, 14, 15 }`, then
``
bool isOdd ( int i ) { return i % 2 == 1; }
bool lessThan10 ( int i ) { return i < 10; }
using boost::algorithm;
none_of ( c, isOdd ) --> false
none_of ( c.begin (), c.end (), lessThan10 ) --> false
none_of ( c.begin () + 4, c.end (), lessThan10 ) --> true
none_of ( c.end (), c.end (), isOdd ) --> true // empty range
none_of_equal ( c, 3 ) --> false
none_of_equal ( c.begin (), c.begin () + 3, 3 ) --> true
none_of_equal ( c.begin (), c.begin (), 99 ) --> true // empty range
``
[heading Iterator Requirements]
`none_of` and `none_of_equal` work on all iterators except output iterators.
[heading Complexity]
All of the variants of `none_of` and `none_of_equal` run in ['O(N)] (linear) time; that is, they compare against each element in the list once. If any of the comparisons succeed, the algorithm will terminate immediately, without examining the remaining members of the sequence.
[heading Exception Safety]
All of the variants of `none_of` and `none_of_equal` take their parameters by value or const reference, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
[heading Notes]
* The routine `none_of` is also available as part of the C++11 standard.
* `none_of` and `none_of_equal` both return true for empty ranges, no matter what is passed to test against.
* The second parameter to `none_of_value` is a template parameter, rather than deduced from the first parameter (`std::iterator_traits<InputIterator>::value_type`) because that allows more flexibility for callers, and takes advantage of built-in comparisons for the type that is pointed to by the iterator. The function is defined to return true if, for all elements in the sequence, the expression `*iter == val` evaluates to false (where `iter` is an iterator to each element in the sequence)
[endsect]
[/ File none_of.qbk
Copyright 2011 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
]

87
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/one_of.qbk vendored Executable file
View File

@@ -0,0 +1,87 @@
[/ File one_of.qbk]
[section:one_of one_of]
[/license
Copyright (c) 2010-2012 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
]
The header file 'boost/algorithm/cxx11/one_of.hpp' contains four variants of a single algorithm, `one_of`. The algorithm tests the elements of a sequence and returns true if exactly one of the elements in the sequence has a particular property.
The routine `one_of` takes a sequence and a predicate. It will return true if the predicate returns true for one element in the sequence.
The routine `one_of_equal` takes a sequence and a value. It will return true if one element in the sequence compares equal to the passed in value.
Both routines come in two forms; the first one takes two iterators to define the range. The second form takes a single range parameter, and uses Boost.Range to traverse it.
[heading interface]
The function `one_of` returns true if the predicate returns true for one item in the sequence. There are two versions; one takes two iterators, and the other takes a range.
``
namespace boost { namespace algorithm {
template<typename InputIterator, typename Predicate>
bool one_of ( InputIterator first, InputIterator last, Predicate p );
template<typename Range, typename Predicate>
bool one_of ( const Range &r, Predicate p );
}}
``
The function `one_of_equal` is similar to `one_of`, but instead of taking a predicate to test the elements of the sequence, it takes a value to compare against.
``
namespace boost { namespace algorithm {
template<typename InputIterator, typename V>
bool one_of_equal ( InputIterator first, InputIterator last, V const &val );
template<typename Range, typename V>
bool one_of_equal ( const Range &r, V const &val );
}}
``
[heading Examples]
Given the container `c` containing `{ 0, 1, 2, 3, 14, 15 }`, then
``
bool isOdd ( int i ) { return i % 2 == 1; }
bool lessThan10 ( int i ) { return i < 10; }
using boost::algorithm;
one_of ( c, isOdd ) --> false
one_of ( c.begin (), c.end (), lessThan10 ) --> false
one_of ( c.begin () + 3, c.end (), lessThan10 ) --> true
one_of ( c.end (), c.end (), isOdd ) --> false // empty range
one_of_equal ( c, 3 ) --> true
one_of_equal ( c.begin (), c.begin () + 3, 3 ) --> false
one_of_equal ( c.begin (), c.begin (), 99 ) --> false // empty range
``
[heading Iterator Requirements]
`one_of` and `one_of_equal` work on all iterators except output iterators.
[heading Complexity]
All of the variants of `one_of` and `one_of_equal` run in ['O(N)] (linear) time; that is, they compare against each element in the list once. If more than one of the elements in the sequence satisfy the condition, then algorithm will return false immediately, without examining the remaining members of the sequence.
[heading Exception Safety]
All of the variants of `one_of` and `one_of_equal` take their parameters by value or const reference, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
[heading Notes]
* `one_of` and `one_of_equal` both return false for empty ranges, no matter what is passed to test against.
* The second parameter to `one_of_equal` is a template parameter, rather than deduced from the first parameter (`std::iterator_traits<InputIterator>::value_type`) because that allows more flexibility for callers, and takes advantage of built-in comparisons for the type that is pointed to by the iterator. The function is defined to return true if, for one element in the sequence, the expression `*iter == val` evaluates to true (where `iter` is an iterator to each element in the sequence)
[endsect]
[/ File one_of.qbk
Copyright 2011 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
]

130
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/ordered-hpp.qbk vendored Executable file
View File

@@ -0,0 +1,130 @@
[/ QuickBook Document version 1.5 ]
[section:is_sorted is_sorted ]
[/license
Copyright (c) 2010-2012 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
]
The header file `<boost/algorithm/cxx11/is_sorted.hpp>` contains functions for determining if a sequence is ordered.
[heading is_sorted]
The function `is_sorted(sequence)` determines whether or not a sequence is completely sorted according so some criteria. If no comparison predicate is specified, then `std::less` is used (i.e, the test is to see if the sequence is non-decreasing)
``
namespace boost { namespace algorithm {
template <typename ForwardIterator, typename Pred>
bool is_sorted ( ForwardIterator first, ForwardIterator last, Pred p );
template <typename ForwardIterator>
bool is_sorted ( ForwardIterator first, ForwardIterator last );
template <typename Range, typename Pred>
bool is_sorted ( const Range &r, Pred p );
template <typename Range>
bool is_sorted ( const Range &r );
}}
``
Iterator requirements: The `is_sorted` functions will work forward iterators or better.
[heading is_sorted_until]
If `distance(first, last) < 2`, then `is_sorted ( first, last )` returns `last`. Otherwise, it returns the last iterator i in [first,last] for which the range [first,i) is sorted.
In short, it returns the element in the sequence that is "out of order". If the entire sequence is sorted (according to the predicate), then it will return `last`.
``
namespace boost { namespace algorithm {
template <typename ForwardIterator, typename Pred>
FI is_sorted_until ( ForwardIterator first, ForwardIterator last, Pred p );
template <typename ForwardIterator>
ForwardIterator is_sorted_until ( ForwardIterator first, ForwardIterator last );
template <typename Range, typename Pred>
typename boost::range_iterator<const R>::type is_sorted_until ( const Range &r, Pred p );
template <typename Range>
typename boost::range_iterator<const R>::type is_sorted_until ( const Range &r );
}}
``
Iterator requirements: The `is_sorted_until` functions will work on forward iterators or better. Since they have to return a place in the input sequence, input iterators will not suffice.
Complexity:
`is_sorted_until` will make at most ['N-1] calls to the predicate (given a sequence of length ['N]).
Examples:
Given the sequence `{ 1, 2, 3, 4, 5, 3 }`, `is_sorted_until ( beg, end, std::less<int>())` would return an iterator pointing at the second `3`.
Given the sequence `{ 1, 2, 3, 4, 5, 9 }`, `is_sorted_until ( beg, end, std::less<int>())` would return `end`.
There are also a set of "wrapper functions" for is_ordered which make it easy to see if an entire sequence is ordered. These functions return a boolean indicating success or failure rather than an iterator to where the out of order items were found.
To test if a sequence is increasing (each element at least as large as the preceding one):
``
namespace boost { namespace algorithm {
template <typename Iterator>
bool is_increasing ( Iterator first, Iterator last );
template <typename R>
bool is_increasing ( const R &range );
}}
``
To test if a sequence is decreasing (each element no larger than the preceding one):
``
namespace boost { namespace algorithm {
template <typename ForwardIterator>
bool is_decreasing ( ForwardIterator first, ForwardIterator last );
template <typename R>
bool is_decreasing ( const R &range );
}}
``
To test if a sequence is strictly increasing (each element larger than the preceding one):
``
namespace boost { namespace algorithm {
template <typename ForwardIterator>
bool is_strictly_increasing ( ForwardIterator first, ForwardIterator last );
template <typename R>
bool is_strictly_increasing ( const R &range );
}}
``
To test if a sequence is strictly decreasing (each element smaller than the preceding one):
``
namespace boost { namespace algorithm {
template <typename ForwardIterator>
bool is_strictly_decreasing ( ForwardIterator first, ForwardIterator last );
template <typename R>
bool is_strictly_decreasing ( const R &range );
}}
``
Complexity:
Each of these calls is just a thin wrapper over `is_sorted`, so they have the same complexity as `is_sorted`.
[heading Notes]
* The routines `is_sorted` and `is_sorted_until` are part of the C++11 standard. When compiled using a C++11 implementation, the implementation from the standard library will be used.
* `is_sorted` and `is_sorted_until` both return true for empty ranges and ranges of length one.
[endsect]

68
externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/doc/partition_point.qbk vendored Executable file
View File

@@ -0,0 +1,68 @@
[/ File partition_point.qbk]
[section:partition_point partition_point ]
[/license
Copyright (c) 2010-2012 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
]
The header file 'partition_point.hpp' contains two variants of a single algorithm, `partition_point`. Given a partitioned sequence and a predicate, the algorithm finds the partition point; i.e, the first element in the sequence that does not satisfy the predicate.
The routine `partition_point` takes a partitioned sequence and a predicate. It returns an iterator which 'points to' the first element in the sequence that does not satisfy the predicate. If all the items in the sequence satisfy the predicate, then it returns one past the final element in the sequence.
`partition_point` come in two forms; the first one takes two iterators to define the range. The second form takes a single range parameter, and uses Boost.Range to traverse it.
[heading interface]
There are two versions; one takes two iterators, and the other takes a range.
``
template<typename ForwardIterator, typename Predicate>
ForwardIterator partition_point ( ForwardIterator first, ForwardIterator last, Predicate p );
template<typename Range, typename Predicate>
boost::range_iterator<Range> partition_point ( const Range &r, Predicate p );
``
[heading Examples]
Given the container `c` containing `{ 0, 1, 2, 3, 14, 15 }`, then
``
bool lessThan10 ( int i ) { return i < 10; }
bool isOdd ( int i ) { return i % 2 == 1; }
partition_point ( c, lessThan10 ) --> c.begin () + 4 (pointing at 14)
partition_point ( c.begin (), c.end (), lessThan10 ) --> c.begin () + 4 (pointing at 14)
partition_point ( c.begin (), c.begin () + 3, lessThan10 ) -> c.begin () + 3 (end)
partition_point ( c.end (), c.end (), isOdd ) --> c.end () // empty range
``
[heading Iterator Requirements]
`partition_point` requires forward iterators or better; it will not work on input iterators or output iterators.
[heading Complexity]
Both of the variants of `partition_point` run in ['O( log (N))] (logarithmic) time; that is, the predicate will be will be applied approximately ['log(N)] times. To do this, however, the algorithm needs to know the size of the sequence. For forward and bidirectional iterators, calculating the size of the sequence is an ['O(N)] operation.
[heading Exception Safety]
Both of the variants of `partition_point` take their parameters by value or const reference, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
[heading Notes]
* The iterator-based version of the routine `partition_point` is also available as part of the C++11 standard.
* For empty ranges, the partition point is the end of the range.
[endsect]
[/ File partition_point.qbk
Copyright 2011 Marshall Clow
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
]