StlAlgorithms.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <complex>
#include <iterator>
#include <numeric>
#include <utility>
 
#if defined(__cpp_lib_parallel_algorithm) && defined(NUMCPP_USE_MULTITHREAD)
#define PARALLEL_ALGORITHMS_SUPPORTED
#define CONDITIONAL_NO_EXCEPT
#include <execution>
#else
#define CONDITIONAL_NO_EXCEPT noexcept
#endif
 
namespace nc::stl_algorithms
{
    //============================================================================
    // Method Description:
    template<class InputIt, class UnaryPredicate>
    bool all_of(InputIt first, InputIt last, UnaryPredicate p) CONDITIONAL_NO_EXCEPT
    {
        return std::all_of(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            p);
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt, class UnaryPredicate>
    bool any_of(InputIt first, InputIt last, UnaryPredicate p) CONDITIONAL_NO_EXCEPT
    {
        return std::any_of(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            p);
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt, class OutputIt>
    OutputIt copy(InputIt first, InputIt last, OutputIt destination) CONDITIONAL_NO_EXCEPT
    {
        return std::copy(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            destination);
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt, class T>
    typename std::iterator_traits<InputIt>::difference_type
        count(InputIt first, InputIt last, const T& value) CONDITIONAL_NO_EXCEPT
    {
        return std::count(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            value);
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt1, class InputIt2>
    bool equal(InputIt1 first1, InputIt1 last1, InputIt2 first2) CONDITIONAL_NO_EXCEPT
    {
        return std::equal(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first1,
            last1,
            first2);
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt1, class InputIt2, class BinaryPredicate>
    bool equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPredicate p) CONDITIONAL_NO_EXCEPT
    {
        return std::equal(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first1,
            last1,
            first2,
            p);
    }
 
    //============================================================================
    // Method Description:
    template<class ForwardIt, class T>
    void fill(ForwardIt first, ForwardIt last, const T& value) CONDITIONAL_NO_EXCEPT
    {
        return std::fill(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            value);
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt, class T>
    InputIt find(InputIt first, InputIt last, const T& value) CONDITIONAL_NO_EXCEPT
    {
        return std::find(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            value);
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt, class UnaryFunction>
    void for_each(InputIt first, InputIt last, UnaryFunction f)
    {
        std::for_each(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            f);
    }
 
    //============================================================================
    // Method Description:
    template<class ForwardIt>
    bool is_sorted(ForwardIt first, ForwardIt last) CONDITIONAL_NO_EXCEPT
    {
        return std::is_sorted(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last);
    }
 
    //============================================================================
    // Method Description:
    template<class ForwardIt, class Compare>
    bool is_sorted(ForwardIt first, ForwardIt last, Compare comp) CONDITIONAL_NO_EXCEPT
    {
        return std::is_sorted(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            comp);
    }
 
    //============================================================================
    // Method Description:
    template<class ForwardIt>
    ForwardIt max_element(ForwardIt first, ForwardIt last) CONDITIONAL_NO_EXCEPT
    {
        return std::max_element(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last);
    }
 
    //============================================================================
    // Method Description:
    template<class ForwardIt, class Compare>
    ForwardIt max_element(ForwardIt first, ForwardIt last, Compare comp) CONDITIONAL_NO_EXCEPT
    {
        return std::max_element(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            comp);
    }
 
    //============================================================================
    // Method Description:
    template<class ForwardIt>
    ForwardIt min_element(ForwardIt first, ForwardIt last) CONDITIONAL_NO_EXCEPT
    {
        return std::min_element(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last);
    }
 
    //============================================================================
    // Method Description:
    template<class ForwardIt, class Compare>
    ForwardIt min_element(ForwardIt first, ForwardIt last, Compare comp) CONDITIONAL_NO_EXCEPT
    {
        return std::min_element(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            comp);
    }
 
    //============================================================================
    // Method Description:
    template<class ForwardIt>
    std::pair<ForwardIt, ForwardIt> minmax_element(ForwardIt first, ForwardIt last) CONDITIONAL_NO_EXCEPT
    {
        return std::minmax_element(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last);
    }
 
    //============================================================================
    // Method Description:
    template<class ForwardIt, class Compare>
    std::pair<ForwardIt, ForwardIt> minmax_element(ForwardIt first, ForwardIt last, Compare comp) CONDITIONAL_NO_EXCEPT
    {
        return std::minmax_element(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            comp);
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt, class UnaryPredicate>
    bool none_of(InputIt first, InputIt last, UnaryPredicate p) CONDITIONAL_NO_EXCEPT
    {
        return std::none_of(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            p);
    }
 
    //============================================================================
    // Method Description:
    template<class RandomIt>
    void nth_element(RandomIt first, RandomIt nth, RandomIt last) CONDITIONAL_NO_EXCEPT
    {
        std::nth_element(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            nth,
            last);
    }
 
    //============================================================================
    // Method Description:
    template<class RandomIt, class Compare>
    void nth_element(RandomIt first, RandomIt nth, RandomIt last, Compare comp) CONDITIONAL_NO_EXCEPT
    {
        std::nth_element(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            nth,
            last,
            comp);
    }
 
    //============================================================================
    // Method Description:
    template<class ForwardIt, class T>
    void replace(ForwardIt first, ForwardIt last, const T& oldValue, const T& newValue) CONDITIONAL_NO_EXCEPT
    {
        std::replace(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            oldValue,
            newValue);
    }
 
    //============================================================================
    // Method Description:
    template<class BidirIt>
    void reverse(BidirIt first, BidirIt last) CONDITIONAL_NO_EXCEPT
    {
        std::reverse(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last);
    }
 
    //============================================================================
    // Method Description:
    template<class ForwardIt>
    void rotate(ForwardIt first, ForwardIt firstN, ForwardIt last) CONDITIONAL_NO_EXCEPT
    {
        std::rotate(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            firstN,
            last);
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt1, class InputIt2, class OutputIt>
    OutputIt set_difference(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination)
    {
        return std::set_difference(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first1,
            last1,
            first2,
            last2,
            destination);
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt1, class InputIt2, class OutputIt, class Compare>
    OutputIt set_difference(InputIt1 first1,
                            InputIt1 last1,
                            InputIt2 first2,
                            InputIt2 last2,
                            OutputIt destination,
                            Compare  comp) CONDITIONAL_NO_EXCEPT
    {
        return std::set_difference(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first1,
            last1,
            first2,
            last2,
            destination,
            comp);
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt1, class InputIt2, class OutputIt>
    OutputIt set_intersection(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination)
        CONDITIONAL_NO_EXCEPT
    {
        return std::set_intersection(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first1,
            last1,
            first2,
            last2,
            destination);
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt1, class InputIt2, class OutputIt, class Compare>
    OutputIt set_intersection(InputIt1 first1,
                              InputIt1 last1,
                              InputIt2 first2,
                              InputIt2 last2,
                              OutputIt destination,
                              Compare  comp) CONDITIONAL_NO_EXCEPT
    {
        return std::set_intersection(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first1,
            last1,
            first2,
            last2,
            destination,
            comp);
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt1, class InputIt2, class OutputIt>
    OutputIt set_union(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination)
        CONDITIONAL_NO_EXCEPT
    {
        return std::set_union(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first1,
            last1,
            first2,
            last2,
            destination);
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt1, class InputIt2, class OutputIt, class Compare>
    OutputIt
        set_union(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt destination, Compare comp)
            CONDITIONAL_NO_EXCEPT
    {
        return std::set_union(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first1,
            last1,
            first2,
            last2,
            destination,
            comp);
    }
 
    //============================================================================
    // Method Description:
    template<class RandomIt>
    void sort(RandomIt first, RandomIt last) CONDITIONAL_NO_EXCEPT
    {
        return std::sort(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last);
    }
 
    //============================================================================
    // Method Description:
    template<class RandomIt, class Compare>
    void sort(RandomIt first, RandomIt last, Compare comp) CONDITIONAL_NO_EXCEPT
    {
        return std::sort(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            comp);
    }
 
    //============================================================================
    // Method Description:
    template<class RandomIt>
    void stable_sort(RandomIt first, RandomIt last) CONDITIONAL_NO_EXCEPT
    {
        std::stable_sort(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last);
    }
 
    //============================================================================
    // Method Description:
    template<class RandomIt, class Compare>
    void stable_sort(RandomIt first, RandomIt last, Compare comp) CONDITIONAL_NO_EXCEPT
    {
        std::stable_sort(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            comp);
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt, class OutputIt, class UnaryOperation>
    OutputIt transform(InputIt first, InputIt last, OutputIt destination, UnaryOperation unaryFunction)
    {
        return std::transform(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            destination,
            unaryFunction);
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt1, class InputIt2, class OutputIt, class BinaryOperation>
    OutputIt
        transform(InputIt1 first1, InputIt1 last1, InputIt2 first2, OutputIt destination, BinaryOperation unaryFunction)
    {
        return std::transform(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first1,
            last1,
            first2,
            destination,
            unaryFunction);
    }
 
    //============================================================================
    // Method Description:
    template<class ForwardIt1, class ForwardIt2, class T>
    T transform_reduce(ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, T init)
    {
        return std::transform_reduce(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first1,
            last1,
            first2,
            init);
    }
 
    //============================================================================
    // Method Description:
    template<class ForwardIt1, class ForwardIt2, class T>
    std::complex<T>
        transform_reduce(ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, const std::complex<T>& init)
    {
        return std::transform_reduce(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first1,
            last1,
            first2,
            init,
            std::plus<std::complex<T>>(),
            [](const auto a, const auto& b) { return std::complex<T>(a * b); });
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt, class OutputIt>
    constexpr OutputIt unique_copy(InputIt first, InputIt last, OutputIt destination) CONDITIONAL_NO_EXCEPT
    {
        return std::unique_copy(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            destination);
    }
 
    //============================================================================
    // Method Description:
    template<class InputIt, class OutputIt, class BinaryPredicate>
    constexpr OutputIt unique_copy(InputIt first, InputIt last, OutputIt destination, BinaryPredicate binaryFunction)
        CONDITIONAL_NO_EXCEPT
    {
        return std::unique_copy(
#ifdef PARALLEL_ALGORITHMS_SUPPORTED
            std::execution::par_unseq,
#endif
            first,
            last,
            destination,
            binaryFunction);
    }
} // namespace nc::stl_algorithms