...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
Misc Algorithms.
Marshall Clow
namespace boost { namespace algorithm { template<typename T> T identity_operation(std::multiplies< T >); template<typename T> T identity_operation(std::plus< T >); template<typename T, typename Integer> boost::enable_if< boost::is_integral< Integer >, T >::type power(T, Integer); template<typename T, typename Integer, typename Operation> boost::enable_if< boost::is_integral< Integer >, T >::type power(T, Integer, Operation); } }
Clamp algorithm.
Marshall Clow
Suggested by olafvdspek in https://svn.boost.org/trac/boost/ticket/3215
namespace boost { namespace algorithm { template<typename T, typename Pred> T const & clamp(T const &, typename boost::mpl::identity< T >::type const &, typename boost::mpl::identity< T >::type const &, Pred); template<typename T> T const & clamp(const T &, typename boost::mpl::identity< T >::type const &, typename boost::mpl::identity< T >::type const &); template<typename InputIterator, typename OutputIterator> OutputIterator clamp_range(InputIterator first, InputIterator last, OutputIterator out, typename std::iterator_traits< InputIterator >::value_type const & lo, typename std::iterator_traits< InputIterator >::value_type const & hi); template<typename Range, typename OutputIterator> boost::disable_if_c< boost::is_same< Range, OutputIterator >::value, OutputIterator >::type clamp_range(const Range &, OutputIterator, typename std::iterator_traits< typename boost::range_iterator< const Range >::type >::value_type const &, typename std::iterator_traits< typename boost::range_iterator< const Range >::type >::value_type const &); template<typename InputIterator, typename OutputIterator, typename Pred> OutputIterator clamp_range(InputIterator first, InputIterator last, OutputIterator out, typename std::iterator_traits< InputIterator >::value_type const & lo, typename std::iterator_traits< InputIterator >::value_type const & hi, Pred p); template<typename Range, typename OutputIterator, typename Pred> boost::disable_if_c< boost::is_same< Range, OutputIterator >::value, OutputIterator >::type clamp_range(const Range &, OutputIterator, typename std::iterator_traits< typename boost::range_iterator< const Range >::type >::value_type const &, typename std::iterator_traits< typename boost::range_iterator< const Range >::type >::value_type const &, Pred); } }
Test ranges to see if all elements match a value or predicate.
Marshall Clow
namespace boost { namespace algorithm { template<typename InputIterator, typename Predicate> bool all_of(InputIterator, InputIterator, Predicate); template<typename Range, typename Predicate> bool all_of(const Range &, Predicate); template<typename InputIterator, typename T> bool all_of_equal(InputIterator, InputIterator, const T &); template<typename Range, typename T> bool all_of_equal(const Range &, const T &); } }
Test ranges to see if any elements match a value or predicate.
Marshall Clow
namespace boost { namespace algorithm { template<typename InputIterator, typename Predicate> bool any_of(InputIterator, InputIterator, Predicate); template<typename Range, typename Predicate> bool any_of(const Range &, Predicate); template<typename InputIterator, typename V> bool any_of_equal(InputIterator, InputIterator, const V &); template<typename Range, typename V> bool any_of_equal(const Range &, const V &); } }
Copy a subset of a sequence to a new sequence.
Marshall Clow
namespace boost { namespace algorithm { template<typename InputIterator, typename OutputIterator, typename Predicate> OutputIterator copy_if(InputIterator, InputIterator, OutputIterator, Predicate); template<typename Range, typename OutputIterator, typename Predicate> OutputIterator copy_if(const Range &, OutputIterator, Predicate); template<typename InputIterator, typename OutputIterator, typename Predicate> std::pair< InputIterator, OutputIterator > copy_while(InputIterator, InputIterator, OutputIterator, Predicate); template<typename Range, typename OutputIterator, typename Predicate> std::pair< typename boost::range_iterator< const Range >::type, OutputIterator > copy_while(const Range &, OutputIterator, Predicate); template<typename InputIterator, typename OutputIterator, typename Predicate> std::pair< InputIterator, OutputIterator > copy_until(InputIterator, InputIterator, OutputIterator, Predicate); template<typename Range, typename OutputIterator, typename Predicate> std::pair< typename boost::range_iterator< const Range >::type, OutputIterator > copy_until(const Range &, OutputIterator, Predicate); } }
Copy n items from one sequence to another.
Marshall Clow
namespace boost { namespace algorithm { template<typename InputIterator, typename Size, typename OutputIterator> OutputIterator copy_n(InputIterator, Size, OutputIterator); } }
Find the first element in a sequence that does not satisfy a predicate.
Marshall Clow
namespace boost { namespace algorithm { template<typename InputIterator, typename Predicate> InputIterator find_if_not(InputIterator, InputIterator, Predicate); template<typename Range, typename Predicate> boost::range_iterator< const Range >::type find_if_not(const Range &, Predicate); } }
Generate an increasing series.
Marshall Clow
namespace boost { namespace algorithm { template<typename ForwardIterator, typename T> void iota(ForwardIterator, ForwardIterator, T); template<typename Range, typename T> void iota(Range &, T); template<typename OutputIterator, typename T> OutputIterator iota_n(OutputIterator, T, std::size_t); } }
Tell if a sequence is partitioned.
Marshall Clow
namespace boost { namespace algorithm { template<typename InputIterator, typename UnaryPredicate> bool is_partitioned(InputIterator, InputIterator, UnaryPredicate); template<typename Range, typename UnaryPredicate> bool is_partitioned(const Range &, UnaryPredicate); } }
namespace boost { namespace algorithm { template<typename ForwardIterator1, typename ForwardIterator2, typename BinaryPredicate> bool is_permutation(ForwardIterator1, ForwardIterator1, ForwardIterator2, BinaryPredicate); template<typename ForwardIterator1, typename ForwardIterator2> bool is_permutation(ForwardIterator1, ForwardIterator1, ForwardIterator2); template<typename Range, typename ForwardIterator> bool is_permutation(const Range &, ForwardIterator); template<typename Range, typename ForwardIterator, typename BinaryPredicate> boost::disable_if_c< boost::is_same< Range, ForwardIterator >::value, bool >::type is_permutation(const Range &, ForwardIterator, BinaryPredicate); } }
namespace boost { namespace algorithm { template<typename ForwardIterator1, typename ForwardIterator2> bool is_permutation(ForwardIterator1, ForwardIterator1, ForwardIterator2, ForwardIterator2); template<typename ForwardIterator1, typename ForwardIterator2, typename BinaryPredicate> bool is_permutation(ForwardIterator1, ForwardIterator1, ForwardIterator2, ForwardIterator2, BinaryPredicate); } }
namespace boost { namespace algorithm { template<typename ForwardIterator, typename Pred> ForwardIterator is_sorted_until(ForwardIterator, ForwardIterator, Pred); template<typename ForwardIterator> ForwardIterator is_sorted_until(ForwardIterator, ForwardIterator); template<typename ForwardIterator, typename Pred> bool is_sorted(ForwardIterator, ForwardIterator, Pred); template<typename ForwardIterator> bool is_sorted(ForwardIterator, ForwardIterator); template<typename R, typename Pred> boost::lazy_disable_if_c< boost::is_same< R, Pred >::value, typename boost::range_iterator< const R > >::type is_sorted_until(const R &, Pred); template<typename R> boost::range_iterator< const R >::type is_sorted_until(const R &); template<typename R, typename Pred> boost::lazy_disable_if_c< boost::is_same< R, Pred >::value, boost::mpl::identity< bool > >::type is_sorted(const R &, Pred); template<typename R> bool is_sorted(const R &); template<typename ForwardIterator> bool is_increasing(ForwardIterator, ForwardIterator); template<typename R> bool is_increasing(const R &); template<typename ForwardIterator> bool is_decreasing(ForwardIterator, ForwardIterator); template<typename R> bool is_decreasing(const R &); template<typename ForwardIterator> bool is_strictly_increasing(ForwardIterator, ForwardIterator); template<typename R> bool is_strictly_increasing(const R &); template<typename ForwardIterator> bool is_strictly_decreasing(ForwardIterator, ForwardIterator); template<typename R> bool is_strictly_decreasing(const R &); } }
Test ranges to see if no elements match a value or predicate.
Marshall Clow
namespace boost { namespace algorithm { template<typename InputIterator, typename Predicate> bool none_of(InputIterator, InputIterator, Predicate); template<typename Range, typename Predicate> bool none_of(const Range &, Predicate); template<typename InputIterator, typename V> bool none_of_equal(InputIterator, InputIterator, const V &); template<typename Range, typename V> bool none_of_equal(const Range &, const V &); } }
Test ranges to see if only one element matches a value or predicate.
Marshall Clow
namespace boost { namespace algorithm { template<typename InputIterator, typename Predicate> bool one_of(InputIterator, InputIterator, Predicate); template<typename Range, typename Predicate> bool one_of(const Range &, Predicate); template<typename InputIterator, typename V> bool one_of_equal(InputIterator, InputIterator, const V &); template<typename Range, typename V> bool one_of_equal(const Range &, const V &); } }
Copy a subset of a sequence to a new sequence.
Marshall Clow
namespace boost { namespace algorithm { template<typename InputIterator, typename OutputIterator1, typename OutputIterator2, typename UnaryPredicate> std::pair< OutputIterator1, OutputIterator2 > partition_copy(InputIterator, InputIterator, OutputIterator1, OutputIterator2, UnaryPredicate); template<typename Range, typename OutputIterator1, typename OutputIterator2, typename UnaryPredicate> std::pair< OutputIterator1, OutputIterator2 > partition_copy(const Range &, OutputIterator1, OutputIterator2, UnaryPredicate); } }
Find the partition point in a sequence.
Marshall Clow
namespace boost { namespace algorithm { template<typename ForwardIterator, typename Predicate> ForwardIterator partition_point(ForwardIterator, ForwardIterator, Predicate); template<typename Range, typename Predicate> boost::range_iterator< Range >::type partition_point(Range &, Predicate); } }
Test ranges to if they are equal.
Marshall Clow
namespace boost { namespace algorithm { template<typename InputIterator1, typename InputIterator2, typename BinaryPredicate> bool equal(InputIterator1, InputIterator1, InputIterator2, InputIterator2, BinaryPredicate); template<typename InputIterator1, typename InputIterator2> bool equal(InputIterator1, InputIterator1, InputIterator2, InputIterator2); } }
Find the first mismatched element in a sequence.
Marshall Clow
namespace boost { namespace algorithm { template<typename InputIterator1, typename InputIterator2, typename BinaryPredicate> std::pair< InputIterator1, InputIterator2 > mismatch(InputIterator1, InputIterator1, InputIterator2, InputIterator2, BinaryPredicate); template<typename InputIterator1, typename InputIterator2> std::pair< InputIterator1, InputIterator2 > mismatch(InputIterator1, InputIterator1, InputIterator2, InputIterator2); } }
namespace boost { namespace algorithm { // iterator-based gather implementation template<typename BidirectionalIterator, typename Pred> std::pair< BidirectionalIterator, BidirectionalIterator > gather(BidirectionalIterator first, BidirectionalIterator last, BidirectionalIterator pivot, Pred pred); // range-based gather implementation 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); } }
Convert sequence of integral types into a sequence of hexadecimal characters and back. Based on the MySQL functions HEX and UNHEX.
Marshall Clow
namespace boost { namespace algorithm { struct hex_decode_error; struct not_enough_input; struct non_hex_input; typedef boost::error_info< struct bad_char_, char > bad_char; template<typename InputIterator, typename OutputIterator> unspecified hex(InputIterator, InputIterator, OutputIterator); template<typename InputIterator, typename OutputIterator> unspecified hex_lower(InputIterator, InputIterator, OutputIterator); template<typename T, typename OutputIterator> boost::enable_if< boost::is_integral< T >, OutputIterator >::type hex(const T *, OutputIterator); template<typename T, typename OutputIterator> boost::enable_if< boost::is_integral< T >, OutputIterator >::type hex_lower(const T *, OutputIterator); template<typename Range, typename OutputIterator> unspecified hex(const Range &, OutputIterator); template<typename Range, typename OutputIterator> unspecified hex_lower(const Range &, OutputIterator); template<typename InputIterator, typename OutputIterator> OutputIterator unhex(InputIterator, InputIterator, OutputIterator); template<typename T, typename OutputIterator> OutputIterator unhex(const T *, OutputIterator); template<typename Range, typename OutputIterator> OutputIterator unhex(const Range &, OutputIterator); template<typename String> String hex(const String &); template<typename String> String hex_lower(const String &); template<typename String> String unhex(const String &); } }
Checks the input sequence on palindrome.
Alexander Zaitsev
namespace boost { namespace algorithm { template<typename BidirectionalIterator, typename Predicate> bool is_palindrome(BidirectionalIterator, BidirectionalIterator, Predicate); template<typename BidirectionalIterator> bool is_palindrome(BidirectionalIterator, BidirectionalIterator); template<typename R> bool is_palindrome(const R &); template<typename R, typename Predicate> bool is_palindrome(const R &, Predicate); bool is_palindrome(const char *); template<typename Predicate> bool is_palindrome(const char *, Predicate); } }
namespace boost { template<typename T> tuple< T const &, T const & > minmax(T const & a, T const & b); template<typename T, typename BinaryPredicate> tuple< T const &, T const & > minmax(T const & a, T const & b, BinaryPredicate comp); }
namespace boost { template<typename ForwardIter> std::pair< ForwardIter, ForwardIter > minmax_element(ForwardIter first, ForwardIter last); template<typename ForwardIter, typename BinaryPredicate> std::pair< ForwardIter, ForwardIter > minmax_element(ForwardIter first, ForwardIter last, BinaryPredicate comp); template<typename ForwardIter> ForwardIter first_min_element(ForwardIter first, ForwardIter last); template<typename ForwardIter, typename BinaryPredicate> ForwardIter first_min_element(ForwardIter first, ForwardIter last, BinaryPredicate comp); template<typename ForwardIter> ForwardIter last_min_element(ForwardIter first, ForwardIter last); template<typename ForwardIter, typename BinaryPredicate> ForwardIter last_min_element(ForwardIter first, ForwardIter last, BinaryPredicate comp); template<typename ForwardIter> ForwardIter first_max_element(ForwardIter first, ForwardIter last); template<typename ForwardIter, typename BinaryPredicate> ForwardIter first_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp); template<typename ForwardIter> ForwardIter last_max_element(ForwardIter first, ForwardIter last); template<typename ForwardIter, typename BinaryPredicate> ForwardIter last_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp); template<typename ForwardIter> std::pair< ForwardIter, ForwardIter > first_min_first_max_element(ForwardIter first, ForwardIter last); template<typename ForwardIter, typename BinaryPredicate> std::pair< ForwardIter, ForwardIter > first_min_first_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp); template<typename ForwardIter> std::pair< ForwardIter, ForwardIter > first_min_last_max_element(ForwardIter first, ForwardIter last); template<typename ForwardIter, typename BinaryPredicate> std::pair< ForwardIter, ForwardIter > first_min_last_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp); template<typename ForwardIter> std::pair< ForwardIter, ForwardIter > last_min_first_max_element(ForwardIter first, ForwardIter last); template<typename ForwardIter, typename BinaryPredicate> std::pair< ForwardIter, ForwardIter > last_min_first_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp); template<typename ForwardIter> std::pair< ForwardIter, ForwardIter > last_min_last_max_element(ForwardIter first, ForwardIter last); template<typename ForwardIter, typename BinaryPredicate> std::pair< ForwardIter, ForwardIter > last_min_last_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp); }
namespace boost { namespace algorithm { template<typename patIter, typename traits = detail::BM_traits<patIter> > class boyer_moore; template<typename patIter, typename corpusIter> std::pair< corpusIter, corpusIter > boyer_moore_search(corpusIter, corpusIter, patIter, patIter); template<typename PatternRange, typename corpusIter> std::pair< corpusIter, corpusIter > boyer_moore_search(corpusIter corpus_first, corpusIter corpus_last, const PatternRange & pattern); template<typename patIter, typename CorpusRange> boost::disable_if_c< boost::is_same< CorpusRange, patIter >::value, std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type > >::type boyer_moore_search(CorpusRange & corpus, patIter pat_first, patIter pat_last); template<typename PatternRange, typename CorpusRange> std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type > boyer_moore_search(CorpusRange & corpus, const PatternRange & pattern); template<typename Range> boost::algorithm::boyer_moore< typename boost::range_iterator< const Range >::type > make_boyer_moore(const Range & r); template<typename Range> boost::algorithm::boyer_moore< typename boost::range_iterator< Range >::type > make_boyer_moore(Range & r); } }
namespace boost { namespace algorithm { template<typename patIter, typename traits = detail::BM_traits<patIter> > class boyer_moore_horspool; template<typename patIter, typename corpusIter> std::pair< corpusIter, corpusIter > boyer_moore_horspool_search(corpusIter, corpusIter, patIter, patIter); template<typename PatternRange, typename corpusIter> std::pair< corpusIter, corpusIter > boyer_moore_horspool_search(corpusIter corpus_first, corpusIter corpus_last, const PatternRange & pattern); template<typename patIter, typename CorpusRange> boost::disable_if_c< boost::is_same< CorpusRange, patIter >::value, std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type > >::type boyer_moore_horspool_search(CorpusRange & corpus, patIter pat_first, patIter pat_last); template<typename PatternRange, typename CorpusRange> std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type > boyer_moore_horspool_search(CorpusRange & corpus, const PatternRange & pattern); template<typename Range> boost::algorithm::boyer_moore_horspool< typename boost::range_iterator< const Range >::type > make_boyer_moore_horspool(const Range & r); template<typename Range> boost::algorithm::boyer_moore_horspool< typename boost::range_iterator< Range >::type > make_boyer_moore_horspool(Range & r); } }
namespace boost { namespace algorithm { template<typename patIter> class knuth_morris_pratt; template<typename patIter, typename corpusIter> std::pair< corpusIter, corpusIter > knuth_morris_pratt_search(corpusIter, corpusIter, patIter, patIter); template<typename PatternRange, typename corpusIter> std::pair< corpusIter, corpusIter > knuth_morris_pratt_search(corpusIter corpus_first, corpusIter corpus_last, const PatternRange & pattern); template<typename patIter, typename CorpusRange> boost::disable_if_c< boost::is_same< CorpusRange, patIter >::value, std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type > >::type knuth_morris_pratt_search(CorpusRange & corpus, patIter pat_first, patIter pat_last); template<typename PatternRange, typename CorpusRange> std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type > knuth_morris_pratt_search(CorpusRange & corpus, const PatternRange & pattern); template<typename Range> boost::algorithm::knuth_morris_pratt< typename boost::range_iterator< const Range >::type > make_knuth_morris_pratt(const Range & r); template<typename Range> boost::algorithm::knuth_morris_pratt< typename boost::range_iterator< Range >::type > make_knuth_morris_pratt(Range & r); } }
Sort a subrange.
Marshall Clow
Suggested by Sean Parent in his CppCon 2015 keynote
namespace boost { namespace algorithm { template<typename Iterator, typename Pred> void sort_subrange(Iterator first, Iterator last, Iterator sub_first, Iterator sub_last, Pred p); template<typename Iterator> void sort_subrange(Iterator first, Iterator last, Iterator sub_first, Iterator sub_last); template<typename Iterator, typename Pred> void partition_subrange(Iterator first, Iterator last, Iterator sub_first, Iterator sub_last, Pred p); template<typename Iterator> void partition_subrange(Iterator first, Iterator last, Iterator sub_first, Iterator sub_last); } }
Cumulative include for string_algo library
Cumulative include for string_algo library. In addition to string.hpp contains also regex-related stuff.