dl_range_each.h

浏览该文件的文档.

#pragma once
 
#include "dl_concept.h"
#include "base/dl_array.h"

namespace dl::Each
{
template<typename T, size_t N>
Array<T, N> Min(const Array<T, N>& a, const Array<T, N>& b)
{
    Array<T, N> ret;
    for (size_t i = 0; i < N; ++i)
    {
        ret[i] = (std::min)(a[i], b[i]);
    }
    return ret;
}

template<typename T, size_t N>
Array<T, N> Max(const Array<T, N>& a, const Array<T, N>& b)
{
    Array<T, N> ret;
    for (size_t i = 0; i < N; ++i)
    {
        ret[i] = (std::max)(a[i], b[i]);
    }
    return ret;
}

template<IsInteger T, size_t N>
void Limit(Array<T, N>& a, const Array<T, N>& min, const Array<T, N>& max)
{
    for (size_t i = 0; i < N; ++i)
    {
        if (a[i] < min[i])
            a[i] = min[i];
        else if (a[i] >= max[i])
            a[i] = max[i] - 1;
    }
}
 
template<IsInteger T, size_t N>
[[nodiscard]]
Array<T, N> Limit(const Array<T, N>& a, const Array<T, N>& min, const Array<T, N>& max)
{
    Array<T, N> ret = a;
    Limit(ret, min, max);
    return ret;
}

template<typename T, size_t N>
constexpr bool Less(const Array<T, N>& a, const Array<T, N>& b)
{
    for (size_t i = 0; i < N; ++i)
    {
        if (!(a[i] < b[i]))
            return false;
    }
    return true;
}

template<IsReal T, size_t N>
Array<T, N> Lerp(const Array<T, N>& a, const Array<T, N>& b, T t)
{
    Array<T, N> ret;
    for (size_t i = 0; i < N; ++i)
    {
        ret[i] = std::lerp(a[i], b[i], t);
    }
    return ret;
}

template<typename T, size_t N, IsReal R>
Array<T, N> Lerp(const Array<T, N>& a, const Array<T, N>& b, R t, R(*func)(R))
{
    Array<T, N> ret;
    for (size_t i = 0; i < N; ++i)
    {
        ret[i] = (T)func(std::lerp((R)a[i], (R)b[i], t));
    }
    return ret;
}

template<typename T, size_t N>
Array<T, N> FMod(const Array<T, N>& a, const Array<T, N>& b)
{
    Array<T, N> ret;
    for (size_t i = 0; i < N; ++i)
    {
        ret[i] = std::fmod(a[i], b[i]);
    }
    return ret;
}

template<typename C0, typename C1, typename F>
bool Yes(const C0& container0, const C1& container1, F func)
{
    if (container0.size() != container1.size())
        return false;
    auto iter0 = container0.begin();
    auto iter1 = container1.begin();
    while (iter0 != container0.end())
    {
        if (!func(*iter0, *iter1))
            return false;
        ++iter0;
        ++iter1;
    }
    return true;
}

template<typename C0, typename C1>
void Clone(C1& tar, const C0& src)
{
    tar.resize(src.size());
    auto iter0 = src.begin();
    auto iter1 = tar.begin();
    while (iter0 != src.end())
    {
        *iter1++ = *iter0++;
    }
}

template<typename C0, typename C1>
void Copy(C1& tar, const C0& src)
{
    std::size_t num = (std::min)(tar.size(), src.size());
    auto iter0 = src.begin();
    auto iter1 = tar.begin();
    while (num--)
    {
        *iter1++ = *iter0++;
    }
}
 
 
}