range.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef pRC_CORE_BASIC_RANGE_H
#define pRC_CORE_BASIC_RANGE_H
 
#include <prc/core/basic/basics.hpp>
#include <prc/core/basic/context.hpp>
#include <prc/core/basic/direction.hpp>
#include <prc/core/basic/sequence.hpp>
#include <prc/core/functors/mul.hpp>
 
namespace pRC
{
    template<Context C, Size I, Size L, Direction D = Direction::Forwards,
        Size S = 1, class F, class... Xs>
        requires(D == Direction::Forwards || D == Direction::Backwards) &&
        (C == Context::CompileTime)
    [[gnu::always_inline]] static inline constexpr auto range(F &&f,
        Xs &&...args)
    {
        expand(makeRange<Index, I, L, D, S>(),
            [&f, &args...](auto const... seq)
            {
                (f(args..., seq), ...);
            });
    }
 
    template<Context C, Size I, Size L, Direction D = Direction::Forwards,
        Size S = 1, class F, class... Xs>
        requires(D == Direction::Forwards) && (C == Context::RunTime)
    [[gnu::always_inline]] static inline constexpr auto range(F &&f,
        Xs &&...args)
    {
        for(Index i = I; i < L; i += S)
        {
            f(forward<Xs>(args)..., i);
        }
    }
 
    template<Context C, Size I, Size L, Direction D = Direction::Forwards,
        Size S = 1, class F, class... Xs>
        requires(D == Direction::Backwards) && (C == Context::RunTime)
    [[gnu::always_inline]] static inline constexpr auto range(F &&f,
        Xs &&...args)
    {
        for(Index i = I; i < L; i += S)
        {
            f(forward<Xs>(args)..., ((L - I) / S) * S + I - (i - I));
        }
    }
 
    template<Size I, Size L, Direction D = Direction::Forwards, Size S = 1,
        class F, class... Xs>
        requires(D == Direction::Forwards || D == Direction::Backwards)
    [[gnu::always_inline]] static inline constexpr auto range(F &&f,
        Xs &&...args)
    {
        if constexpr((L - I) / S <= 8)
        {
            range<Context::CompileTime, I, L, D, S>(forward<F>(f),
                forward<Xs>(args)...);
        }
        else
        {
            range<Context::RunTime, I, L, D, S>(forward<F>(f),
                forward<Xs>(args)...);
        }
    }
 
    template<Context C, Size L, Direction D = Direction::Forwards, Size S = 1,
        class F, class... Xs>
        requires(D == Direction::Forwards || D == Direction::Backwards)
    [[gnu::always_inline]] static inline constexpr auto range(F &&f,
        Xs &&...args)
    {
        range<C, 0, L, D, S>(forward<F>(f), forward<Xs>(args)...);
    }
 
    template<Size L, Direction D = Direction::Forwards, Size S = 1, class F,
        class... Xs>
        requires(D == Direction::Forwards || D == Direction::Backwards)
    [[gnu::always_inline]] static inline constexpr auto range(F &&f,
        Xs &&...args)
    {
        range<0, L, D, S>(forward<F>(f), forward<Xs>(args)...);
    }
 
    template<Context C, IsSizes I, IsSizes L,
        Direction O = Direction::LeftToRight,
        IsSequence D = decltype(makeConstantSequence<Direction, L::Dimension,
            Direction::Forwards>()),
        IsSizes S = decltype(makeConstantSequence<Size, L::Dimension, 1>()),
        class F, class... Xs>
        requires IsSame<Direction, typename D::Type> &&
        (L::Dimension == I::Dimension) && (L::Dimension == D::Dimension) &&
        (L::Dimension == S::Dimension) &&
        (O == Direction::LeftToRight || O == Direction::RightToLeft)
    [[gnu::always_inline]] static inline constexpr auto range(F &&f,
        Xs &&...args)
    {
        if constexpr(L::Dimension > 0)
        {
            if constexpr(O == Direction::RightToLeft)
            {
                auto g = [&f, &args...](auto const... indices)
                {
                    expand(
                        reverse(makeSeries<Index, L::Dimension>()),
                        [&f, &args...](auto const &indices, auto const... seq)
                        {
                            f(forward<Xs>(args)..., get<seq>(indices)...);
                        },
                        Tuple(indices...));
                };
 
                using RI = decltype(reverse(I()));
                using RL = decltype(reverse(L()));
                using RD = decltype(reverse(D()));
                using RS = decltype(reverse(S()));
 
                range<C, RI, RL, Direction::LeftToRight, RD, RS>(g);
            }
            if constexpr(O == Direction::LeftToRight)
            {
                auto g = [&f, &args...](auto const... indices)
                {
                    range<C, I::size(0), L::size(0), D::value(0), S::size(0)>(
                        [&f, &args..., &indices...](auto const i)
                        {
                            f(forward<Xs>(args)..., i, indices...);
                        });
                };
 
                using NI = decltype(chip<0>(I()));
                using NL = decltype(chip<0>(L()));
                using ND = decltype(chip<0>(D()));
                using NS = decltype(chip<0>(S()));
                range<C, NI, NL, Direction::LeftToRight, ND, NS>(g);
            }
        }
        else
        {
            forward<F>(f)(forward<Xs>(args)...);
        }
    }
 
    template<IsSizes I, IsSizes L, Direction O = Direction::LeftToRight,
        IsSequence D = decltype(makeConstantSequence<Direction, L::Dimension,
            Direction::Forwards>()),
        IsSizes S = decltype(makeConstantSequence<Size, L::Dimension, 1>()),
        class F, class... Xs>
        requires IsSame<Direction, typename D::Type> &&
        (L::Dimension == I::Dimension) && (L::Dimension == D::Dimension) &&
        (L::Dimension == S::Dimension) &&
        (O == Direction::LeftToRight || O == Direction::RightToLeft)
    [[gnu::always_inline]] static inline constexpr auto range(F &&f,
        Xs &&...args)
    {
        if constexpr(reduce<Mul>((L() - I()) / S()) <= 8)
        {
            range<Context::CompileTime, I, L, O, D, S>(forward<F>(f),
                forward<Xs>(args)...);
        }
        else
        {
            range<Context::RunTime, I, L, O, D, S>(forward<F>(f),
                forward<Xs>(args)...);
        }
    }
 
    template<Context C, IsSizes L, Direction O = Direction::LeftToRight,
        IsSequence D = decltype(makeConstantSequence<Direction, L::Dimension,
            Direction::Forwards>()),
        IsSizes S = decltype(makeConstantSequence<Size, L::Dimension, 1>()),
        class F, class... Xs>
        requires IsSame<Direction, typename D::Type> &&
        (L::Dimension == D::Dimension) && (L::Dimension == S::Dimension) &&
        (O == Direction::LeftToRight || O == Direction::RightToLeft)
    [[gnu::always_inline]] static inline constexpr auto range(F &&f,
        Xs &&...args)
    {
        using I = decltype(makeConstantSequence<Size, L::Dimension, 0>());
        range<C, I, L, O, D, S>(forward<F>(f), forward<Xs>(args)...);
    }
 
    template<IsSizes L, Direction O = Direction::LeftToRight,
        IsSequence D = decltype(makeConstantSequence<Direction, L::Dimension,
            Direction::Forwards>()),
        IsSizes S = decltype(makeConstantSequence<Size, L::Dimension, 1>()),
        class F, class... Xs>
        requires IsSame<Direction, typename D::Type> &&
        (L::Dimension == D::Dimension) && (L::Dimension == S::Dimension) &&
        (O == Direction::LeftToRight || O == Direction::RightToLeft)
    [[gnu::always_inline]] static inline constexpr auto range(F &&f,
        Xs &&...args)
    {
        using I = decltype(makeConstantSequence<Size, L::Dimension, 0>());
        range<I, L, O, D, S>(forward<F>(f), forward<Xs>(args)...);
    }
}
#endif // pRC_CORE_BASIC_RANGE_H