algorithm.hpp

// Copyright 2019 Pokitec
// All rights reserved.
 
#pragma once
 
#include "TTauri/Foundation/required.hpp"
#include <algorithm>
#include <tuple>
#include <cmath>
 
namespace tt {
 
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, size_t N, typename F>
constexpr std::array<T, N> generate_array(F operation)
{
    std::array<T, N> a{};
 
    for (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) {
        ttlet 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, [&](ttlet &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, [&](ttlet &x) { return x == value; });
}
 
template<typename ConstIt, typename It, typename UnaryPredicate>
constexpr It find_cluster(ConstIt last, It start, UnaryPredicate predicate)
{
    ttlet 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)
{
    ttlet 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;
    }
    tt_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>
inline bool starts_with(InputIt1 haystack_first, InputIt1 haystack_last, InputIt2 needle_first, InputIt2 needle_last) noexcept
{
    ttlet [haystack_result, needle_result] = std::mismatch(haystack_first, haystack_last, needle_first, needle_last);
    return needle_result == needle_last;
}
 
template<typename Container1, typename Container2>
inline bool starts_with(Container1 haystack, Container2 needle) noexcept
{
    return starts_with(haystack.begin(), haystack.end(), needle.begin(), needle.end());
}
 
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 InputIt1, typename InputIt2>
inline bool ends_with(InputIt1 haystack_first, InputIt1 haystack_last, InputIt2 needle_first, InputIt2 needle_last) noexcept
{
    ttlet [haystack_result, needle_result] = rmismatch(haystack_first, haystack_last, needle_first, needle_last);
    return needle_result == needle_last;
}
 
template<typename Container1, typename Container2>
inline bool ends_with(Container1 haystack, Container2 needle) noexcept
{
    return ends_with(haystack.begin(), haystack.end(), needle.begin(), needle.end());
}
 
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});
}
 
template<typename T, typename MixType, std::enable_if_t<std::is_floating_point_v<MixType>, int> = 0>
T mix(MixType mix_value, T const &lhs, T const &rhs) noexcept
{
    if (mix_value >= MixType(1.0)) {
        return rhs;
    } else if (mix_value <= MixType(0.0)) {
        return lhs;
    } else {
        return lhs + (rhs - lhs) * mix_value;
    }
}
 
 
}