Algorithm.hpp

Go to the documentation of this file.

//          Copyright Dominic Koepke 2021 - 2022.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef SIMPLE_VECTOR_ALGORITHM_HPP
#define SIMPLE_VECTOR_ALGORITHM_HPP
 
#pragma once
 
#include "Concepts.hpp"
 
#include <algorithm>
#include <concepts>
#include <execution>
#include <ranges>
 
namespace sl::vec
{
    template
    <
        std::ranges::input_range TRange,
        std::weakly_incrementable TOut,
        std::copy_constructible TUnaryOp
    >
        requires std::indirectly_writable
        <
            TOut,
            std::indirect_result_t<TUnaryOp&, std::ranges::iterator_t<TRange>>
        >
    constexpr void transform_unseq(TRange&& range, TOut result, TUnaryOp unaryOp)
    {
        if (std::is_constant_evaluated())
        {
            std::ranges::transform(std::forward<TRange>(range), result, std::ref(unaryOp));
        }
        else // ReSharper disable once CppUnreachableCode
        {
            std::transform
            (
                std::execution::unseq,
                std::ranges::cbegin(range),
                std::ranges::cend(range),
                result,
                std::ref(unaryOp)
            );
        }
    }
 
    template
    <
        std::ranges::input_range TRange1,
        std::ranges::input_range TRange2,
        std::weakly_incrementable TOut,
        std::copy_constructible TBinaryOp
    >
        requires std::indirectly_writable
        <
            TOut,
            std::indirect_result_t<TBinaryOp&, std::ranges::iterator_t<TRange1>, std::ranges::iterator_t<TRange2>>
        >
    constexpr void transform_unseq
    (
        TRange1&& range1,
        TRange2&& range2,
        TOut result,
        TBinaryOp binaryOp
    )
    {
        if (std::is_constant_evaluated())
        {
            std::ranges::transform(std::forward<TRange1>(range1), std::forward<TRange2>(range2), result, std::ref(binaryOp));
        }
        else // ReSharper disable once CppUnreachableCode
        {
            std::transform
            (
                std::execution::unseq,
                std::ranges::cbegin(range1),
                std::ranges::cend(range1),
                std::ranges::cbegin(range2),
                result,
                std::ref(binaryOp)
            );
        }
    }
 
    template
    <
        std::ranges::input_range TRange,
        std::move_constructible T,
        std::copy_constructible TBinaryOp,
        std::copy_constructible TUnaryOp
    >
        requires std::indirectly_unary_invocable
                <
                    TUnaryOp&,
                    std::ranges::iterator_t<TRange>
                > &&
                binary_invokable_with_all_overloads_implicit_convertible_to
                <
                    TBinaryOp&,
                    T,
                    T,
                    std::indirect_result_t<TUnaryOp&, std::ranges::iterator_t<TRange>>
                >
    [[nodiscard]]
    constexpr T transform_reduce_unseq
    (
        TRange&& range,
        T init,
        TBinaryOp binaryOp,
        TUnaryOp unaryOp
    )
    {
        if (std::is_constant_evaluated())
        {
            return std::transform_reduce
            (
                std::ranges::cbegin(range),
                std::ranges::cend(range),
                init,
                std::ref(binaryOp),
                std::ref(unaryOp)
            );
        }
        // ReSharper disable once CppUnreachableCode
        return std::transform_reduce
        (
            std::execution::unseq,
            std::ranges::cbegin(range),
            std::ranges::cend(range),
            init,
            std::ref(binaryOp),
            std::ref(unaryOp)
        );
    }
 
    template
    <
        std::ranges::input_range TRange1,
        std::ranges::input_range TRange2,
        std::move_constructible T,
        std::copy_constructible TBinaryOp1,
        std::copy_constructible TBinaryOp2
    >
        requires std::invocable
                <
                    TBinaryOp2&,
                    std::iter_reference_t<std::ranges::iterator_t<TRange1>>,
                    std::iter_reference_t<std::ranges::iterator_t<TRange2>>
                > &&
                binary_invokable_with_all_overloads_implicit_convertible_to
                <
                    TBinaryOp1&,
                    T,
                    T,
                    std::indirect_result_t<TBinaryOp2&, std::ranges::iterator_t<TRange1>, std::ranges::iterator_t<TRange2>>
                >
    [[nodiscard]]
    constexpr T transform_reduce_unseq
    (
        TRange1&& range1,
        TRange2&& range2,
        T init,
        TBinaryOp1 binaryOp1,
        TBinaryOp2 binaryOp2
    )
    {
        if (std::is_constant_evaluated())
        {
            return std::transform_reduce
            (
                std::ranges::cbegin(range1),
                std::ranges::cend(range1),
                std::ranges::cbegin(range2),
                init,
                std::ref(binaryOp1),
                std::ref(binaryOp2)
            );
        }
        // ReSharper disable once CppUnreachableCode
        return std::transform_reduce
        (
            std::execution::unseq,
            std::ranges::cbegin(range1),
            std::ranges::cend(range1),
            std::ranges::cbegin(range2),
            init,
            std::ref(binaryOp1),
            std::ref(binaryOp2)
        );
    }
 
}
 
#endif