dl_range_every.h

浏览该文件的文档.

#pragma once
 
#include <algorithm>
#include <cmath>
 
#include "math/dl_algorithm.h"
namespace dl::Every
{
template<typename C, typename T>
void Add(C& c, const T& v)
{
    for (auto& iter : c)
        iter += v;
}
template<typename C, typename T>
[[nodiscard]]
C Add(const C& c, const T& v)
{
    C ret = c;
    Add(ret, v);
    return ret;
}

template<typename C, typename T>
void Sub(C& c, const T& v)
{
    for (auto& iter : c)
        iter -= v;
}
template<typename C, typename T>
[[nodiscard]]
C Sub(const C& c, const T& v)
{
    C ret = c;
    Sub(ret, v);
    return ret;
}

template<typename C, typename T>
void Mul(C& c, const T& v)
{
    for (auto& iter : c)
        iter *= v;
}
template<typename C, typename T>
[[nodiscard]]
C Mul(const C& c, const T& v)
{
    C ret = c;
    Mul(ret, v);
    return ret;
}

template<typename C>
void Round(C& c)
{
    for (auto& iter : c)
        iter = std::round(iter);
}
template<typename C>
[[nodiscard]]
C Round(const C& c)
{
    C ret = c;
    Round(ret);
    return ret;
}
 

template<typename C>
void Floor(C& c)
{
    for (auto& iter : c)
        iter = std::floor(iter);
}
template<typename C>
[[nodiscard]]
C Floor(const C& c)
{
    C ret = c;
    Floor(ret);
    return ret;
}

template<typename C>
void Ceil(C& c)
{
    for (auto& iter : c)
        iter = std::ceil(iter);
}
template<typename C>
[[nodiscard]]
C Ceil(const C& c)
{
    C ret = c;
    Ceil(ret);
    return ret;
}

template<typename C, typename T>
constexpr void Clamp(C& c, const T& v_min, const T& v_max)
{
    for (auto& iter : c)
        iter = std::clamp(iter, v_min, v_max);
}
template<typename C, typename T>
[[nodiscard]]
constexpr C Clamp(const C& c, const T& v_min, const T& v_max)
{
    C ret = c;
    Clamp(ret, v_min, v_max);
    return ret;
}

template<typename C, typename T>
constexpr void ClampFloor(C& c, const T& v_min)
{
    for (auto& iter : c)
    {
        if (iter < v_min)
            iter = v_min;
    }
}
template<typename C, typename T>
[[nodiscard]]
constexpr C ClampFloor(const C& c, const T& v_min)
{
    C ret = c;
    ClampFloor(ret, v_min);
    return ret;
}

template<typename C>
void Saturate(C& c)
{
    for (auto& iter : c)
        iter = saturate(iter);
}
template<typename C>
[[nodiscard]]
C Saturate(const C& c)
{
    C ret = c;
    Saturate(ret);
    return ret;
}

template<typename C>
void Abs(C& c)
{
    for (auto& iter : c)
        iter = std::abs(iter);
}
template<typename C>
[[nodiscard]]
C Abs(const C& c)
{
    C ret = c;
    Abs(ret);
    return ret;
}
 

template<typename C, typename V>
bool Equal(const C& c, const V& v)
{
    for (auto& iter : c)
    {
        if (iter != v)
            return false;
    }
    return true;
}

template<typename C, typename V>
bool NotEqual(const C& container, const V& v)
{
    for (auto& iter : container)
    {
        if (iter == v)
            return false;
    }
    return true;
}
 
 
template<typename C>
bool Zero(const C& c)
{
    return Equal(c, 0);
}

template<typename C, typename V>
void Erase(C& container, const V& v)
{
    for (auto iter = container.begin(); iter != container.end();)
    {
        if (*iter == v)
            iter = container.erase(iter);
        else
            ++iter;
    }
}

template<typename C, typename V>
[[nodiscard]]
C Erase(const C& c, const V& v)
{
    C ret;
    for (auto& iter : c)
    {
        if (iter != v)
            ret.push_back(iter);
    }
    return ret;
}

template<typename C, typename C1>
size_t EraseNot(C& container, const C1& c_compare)
{
    size_t ret = 0;
    for (auto iter = container.begin(); iter != container.end();)
    {
        auto iter1 = find(c_compare.begin(), c_compare.end(), *iter);
        if (iter1 == c_compare.end())
        {
            iter = container.erase(iter);
            ++ret;
        }
        else
            ++iter;
    }
    return ret;
}

template<typename C, typename V>
void Replace(C& c, const V& v, const V& v_new)
{
    for (auto& iter : c)
    {
        if (iter == v)
            iter = v_new;
    }
}

template<typename C, typename V>
[[nodiscard]]
C Replace(const C& c, const V& v, const V& v_new)
{
    C ret = c;
    Replace(ret, v, v_new);
    return ret;
}

template<typename C>
void Delete(C& c, bool clear = true)
{
    for (auto& iter : c)
    {
        delete iter;
    }
    if (clear)
        c.clear();
}
}