algorithm.hpp

// Copyright Take Vos 2019-2021.
// 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)
 
#pragma once
 
#include "required.hpp"
#include "assert.hpp"
#include "cast.hpp"
#include <algorithm>
#include <tuple>
#include <cmath>
#include <iterator>
 
namespace hi::inline v1 {
 
template<typename T, typename U, typename F>
inline T transform(const U &input, F operation)
{
    T result = {};
    result.reserve(input.size());
    std::transform(input.begin(), input.end(), std::back_inserter(result), operation);
    return result;
}
 
template<typename T, std::size_t N, typename F>
constexpr std::array<T, N> generate_array(F operation)
{
    std::array<T, N> a{};
 
    for (std::size_t i = 0; i < N; i++) {
        a.at(i) = operation(i);
    }
 
    return a;
}
 
template<typename T, typename F>
inline void erase_if(T &v, F predicate)
{
    while (true) {
        hilet i = std::find_if(v.begin(), v.end(), predicate);
        if (i == v.end()) {
            return;
        }
        v.erase(i);
    }
}
 
template<typename It, typename UnaryPredicate>
constexpr It rfind_if(It const first, It const last, UnaryPredicate predicate)
{
    auto i = last;
    do {
        i--;
        if (predicate(*i)) {
            return i;
        }
    } while (i != first);
    return last;
}
 
template<typename It, typename UnaryPredicate>
constexpr It rfind_if_not(It const first, It const last, UnaryPredicate predicate)
{
    return rfind_if(first, last, [&](hilet &x) {
        return !predicate(x);
    });
}
 
template<typename It, typename T>
constexpr It rfind(It const first, It const last, T const &value)
{
    return rfind_if(first, last, [&](hilet &x) {
        return x == value;
    });
}
 
template<typename It, typename ItAny>
[[nodiscard]] constexpr It find_any(It data_first, It data_last, ItAny value_first, ItAny value_last) noexcept
{
    return std::find_if(data_first, data_last, [value_first, value_last](hilet &data) {
        return std::any_of(value_first, value_last, [&data](hilet &value) {
            return data == value;
        });
    });
}
 
template<typename ConstIt, typename It, typename UnaryPredicate>
constexpr It find_cluster(ConstIt last, It start, UnaryPredicate predicate)
{
    hilet cluster_id = predicate(*start);
 
    for (auto i = start + 1; i != last; ++i) {
        if (predicate(*i) != cluster_id) {
            return i;
        }
    }
    return last;
}
 
template<typename ConstIt, typename It, typename UnaryPredicate>
constexpr It rfind_cluster(ConstIt first, It start, UnaryPredicate predicate)
{
    hilet cluster_id = predicate(*start);
 
    if (start == first) {
        return first;
    }
 
    auto i = start - 1;
    while (true) {
        if (predicate(*i) != cluster_id) {
            return (i + 1);
        }
 
        if (i == first) {
            return i;
        }
        --i;
    }
    hi_unreachable();
}
 
template<typename ConstIt, typename It, typename UnaryPredicate>
constexpr std::pair<It, It> bifind_cluster(ConstIt first, ConstIt last, It start, UnaryPredicate predicate)
{
    return {rfind_cluster(first, start, predicate), find_cluster(last, start, predicate)};
}
 
template<typename It, typename S, typename F>
inline void for_each_cluster(It first, It last, S IsClusterSeperator, F Function)
{
    if (first == last) {
        return;
    }
 
    // If the first item is a cluster seperator skip over it.
    if (IsClusterSeperator(*first)) {
        first++;
    }
 
    for (auto i = first; i != last;) {
        auto j = std::find_if(i, last, IsClusterSeperator);
        Function(i, j);
 
        auto skipOverSeperator = (j == last) ? 0 : 1;
        i = j + skipOverSeperator;
    }
}
 
template<typename InputIt1, typename InputIt2, typename BinaryPredicate>
inline std::pair<InputIt1, InputIt2>
rmismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPredicate predicate) noexcept
{
    auto i1 = last1;
    auto i2 = last2;
 
    while (true) {
        if (i1 == first1 && i2 == first2) {
            return {last1, last2};
        } else if (i1 == first1) {
            return {last1, --i2};
        } else if (i2 == first2) {
            return {--i1, last2};
        }
 
        if (!predicate(*(--i1), *(--i2))) {
            return {i1, i2};
        }
    }
}
 
template<typename InputIt1, typename InputIt2>
inline std::pair<InputIt1, InputIt2> rmismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2) noexcept
{
    return rmismatch(first1, last1, first2, last2, [&](auto a, auto b) {
        return a == b;
    });
}
 
template<typename T>
T smoothstep(T x) noexcept
{
    x = std::clamp(x, T{0.0}, T{1.0});
    return x * x * (3 - 2 * x);
}
 
template<typename T>
T inverse_smoothstep(T x)
{
    return T{0.5} - std::sin(std::asin(T{1.0} - T{2.0} * x) / T{3.0});
}
 
auto shuffle_by_index(auto first, auto last, auto indices_first, auto indices_last, auto index_op) noexcept
{
    std::size_t src_size = std::distance(first, last);
 
    // Keep track of index locations during shuffling of items.
    auto src_indices = std::vector<std::size_t>{};
    src_indices.reserve(src_size);
    for (std::size_t i = 0; i != src_size; ++i) {
        src_indices.push_back(i);
    }
 
    std::size_t dst = 0;
    for (auto it = indices_first; it != indices_last; ++it, ++dst) {
        hilet index = index_op(*it);
        hi_axiom(index < size(src_indices));
 
        auto src = [&src_indices, index]() {
            auto src = index;
            do {
                src = src_indices[src];
            } while (src_indices[src] != index);
            return src;
        }();
 
        if (src != dst) {
            std::iter_swap(first + src, first + dst);
            std::iter_swap(begin(src_indices) + src, begin(src_indices) + dst);
        }
    }
 
    return first + dst;
}
 
auto shuffle_by_index(auto first, auto last, auto indices_first, auto indices_last) noexcept
{
    return shuffle_by_index(first, last, indices_first, indices_last, [](hilet &x) {
        return narrow_cast<std::size_t>(x);
    });
}
 
template<typename DataIt, typename ValueIt>
DataIt front_strip(DataIt data_first, DataIt data_last, ValueIt value_first, ValueIt value_last) noexcept
{
    for (auto it = data_first; it != data_last; ++it) {
        if (std::find(value_first, value_last, *it) == value_last) {
            // Return the iterator pointing to the data that is not part of the value set.
            return it;
        }
    }
 
    return data_last;
}
 
template<typename DataIt, typename ValueIt>
DataIt back_strip(DataIt data_first, DataIt data_last, ValueIt value_first, ValueIt value_last) noexcept
{
    auto it = data_last;
    while (it != data_first) {
        if (std::find(value_first, value_last, *(--it)) == value_last) {
            // Return an iterator one beyond the data that is not part of the value set.
            return it + 1;
        }
    }
 
    return data_first;
}
 
} // namespace hi::inline v1