dl_math.h

浏览该文件的文档.

#pragma once
 
#include <numeric>
#include <list>
#include <version>
#include <functional>
 
#include "dl_type.h"
#include "io/dl_log.h"
#include "base/dl_concept.h"
#include "dl_algorithm.h"
#include "dl_range.h"
 
 
#include "system/dl_platform.h"
#if (DL_PLATFORM == DL_PLATFORM_WIN32)
#include <numbers>
#endif

namespace dl::Numbers
{
    constexpr Float EARTH_fADIUS = 6371.393_f;     
    constexpr Float GRAVITY = 9.8_f;                
    constexpr Float EULER = 2.718281828459045_f;  
    constexpr Float RATIO_GOLD = 0.618033988749894_f;
    constexpr Float SQRT_2 = 1.41421356237_f;        
    constexpr Float PI = 3.1415926536_f;         
}

namespace dl::Numeric
{
    template<typename T, size_t N>
    void Min(Array<T, N>& container)
    {
        for (size_t i = 0; i < N; ++i)
        {
            container[i] = (std::numeric_limits<T>::min)();
        }
    }
    template<typename T, size_t N>
    void Max(Array<T, N>& container)
    {
        for (size_t i = 0; i < N; ++i)
        {
            container[i] = (std::numeric_limits<T>::max)();
        }
    }
}

//void RectBinPack(const Size& size, list<>& map_fect, map<size_t, RectU>& map_fet)
//{
//  //0按面积排序
//}
namespace dl::Math
{
template<typename T>
constexpr bool IsOutRange(T x, T a, T b)
{
    return x < a || b < x;
}

constexpr float Radian2Angle(float radin)
{
    return radin * 180.0f / Numbers::PI;
}

constexpr float Angle2Radian(float angle)
{
    return angle * Numbers::PI / 180.0f;
}

constexpr void RangeRadian(std::array<float, 2>& arr)
{
    constexpr float PI_2 = Numbers::PI * 2;
    if (arr[0] > arr[1])
    {
        arr[1] += PI_2 * (std::floor((arr[0] - arr[1]) / PI_2) + 1);
    }
}

 
#if DL_PLATFORM == DL_PLATFORM_WIN32
inline uint32_t ByteReverse(uint32_t x)
{
    return  _byteswap_ulong(x);
}
#else
constexpr uint32_t ByteReverse(uint32_t x)
{
    return __builtin_bswap32(x);
}
#endif
 

template<typename T>
constexpr T Pow(T x, T n)
{
    T ret = 1;
    for (T i = 0; i < n; ++i)
    {
        ret *= x;
    }
    return ret;
}
constexpr uint64_t Pow64(uint64_t x, uint8_t n)
{
    uint64_t ret = 1;
    for (uint8_t i = 0; i < n; ++i)
    {
        ret *= x;
    }
    return ret;
}
constexpr uint32_t Pow32(uint32_t x, uint8_t n)
{
    uint32_t ret = 1;
    for (uint8_t i = 0; i < n; ++i)
    {
        ret *= x;
    }
    return ret;
}

constexpr uint64_t ARRAY_POW2[] = {
    Pow64(2,0),Pow64(2,1),Pow64(2,2),Pow64(2,3),Pow64(2,4),Pow64(2,5),Pow64(2,6),Pow64(2,7),
    Pow64(2,8),Pow64(2,9),Pow64(2,10),Pow64(2,11),Pow64(2,12),Pow64(2,13),Pow64(2,14),Pow64(2,15),
    Pow64(2,16),Pow64(2,17),Pow64(2,18),Pow64(2,19),Pow64(2,20),Pow64(2,21),Pow64(2,22),Pow64(2,23),
    Pow64(2,24),Pow64(2,25),Pow64(2,26),Pow64(2,27),Pow64(2,28),Pow64(2,29),Pow64(2,30),Pow64(2,31),
    Pow64(2,32),Pow64(2,33),Pow64(2,34),Pow64(2,35),Pow64(2,36),Pow64(2,37),Pow64(2,38),Pow64(2,39),
    Pow64(2,40),Pow64(2,41),Pow64(2,42),Pow64(2,43),Pow64(2,44),Pow64(2,45),Pow64(2,46),Pow64(2,47),
    Pow64(2,48),Pow64(2,49),Pow64(2,50),Pow64(2,51),Pow64(2,52),Pow64(2,53),Pow64(2,54),Pow64(2,55),
    Pow64(2,56),Pow64(2,57),Pow64(2,58),Pow64(2,59),Pow64(2,60),Pow64(2,61),Pow64(2,62),Pow64(2,63) };
constexpr uint32_t ARRAY_POW2_32[] = {
    Pow32(2,0),Pow32(2,1),Pow32(2,2),Pow32(2,3),Pow32(2,4),Pow32(2,5),Pow32(2,6),Pow32(2,7),
    Pow32(2,8),Pow32(2,9),Pow32(2,10),Pow32(2,11),Pow32(2,12),Pow32(2,13),Pow32(2,14),Pow32(2,15),
    Pow32(2,16),Pow32(2,17),Pow32(2,18),Pow32(2,19),Pow32(2,20),Pow32(2,21),Pow32(2,22),Pow32(2,23),
    Pow32(2,24),Pow32(2,25),Pow32(2,26),Pow32(2,27),Pow32(2,28),Pow32(2,29),Pow32(2,30),Pow32(2,31) };

#define DND_ARRAY_POW_LINE(index) if (x <= ARRAY_POW2[index])return ARRAY_POW2[index]
constexpr uint64_t CeilToPow2(uint64_t&& x)
{
    DND_ARRAY_POW_LINE(0); DND_ARRAY_POW_LINE(1); DND_ARRAY_POW_LINE(2); DND_ARRAY_POW_LINE(3); DND_ARRAY_POW_LINE(4); DND_ARRAY_POW_LINE(5); DND_ARRAY_POW_LINE(6); DND_ARRAY_POW_LINE(7);
    DND_ARRAY_POW_LINE(8); DND_ARRAY_POW_LINE(9); DND_ARRAY_POW_LINE(10); DND_ARRAY_POW_LINE(11); DND_ARRAY_POW_LINE(12); DND_ARRAY_POW_LINE(13); DND_ARRAY_POW_LINE(14); DND_ARRAY_POW_LINE(15);
    DND_ARRAY_POW_LINE(16); DND_ARRAY_POW_LINE(17); DND_ARRAY_POW_LINE(18); DND_ARRAY_POW_LINE(19); DND_ARRAY_POW_LINE(20); DND_ARRAY_POW_LINE(21); DND_ARRAY_POW_LINE(22); DND_ARRAY_POW_LINE(23);
    DND_ARRAY_POW_LINE(24); DND_ARRAY_POW_LINE(25); DND_ARRAY_POW_LINE(26); DND_ARRAY_POW_LINE(27); DND_ARRAY_POW_LINE(28); DND_ARRAY_POW_LINE(29); DND_ARRAY_POW_LINE(30); DND_ARRAY_POW_LINE(31);
    DND_ARRAY_POW_LINE(32); DND_ARRAY_POW_LINE(33); DND_ARRAY_POW_LINE(34); DND_ARRAY_POW_LINE(35); DND_ARRAY_POW_LINE(36); DND_ARRAY_POW_LINE(37); DND_ARRAY_POW_LINE(38); DND_ARRAY_POW_LINE(39);
    DND_ARRAY_POW_LINE(40); DND_ARRAY_POW_LINE(41); DND_ARRAY_POW_LINE(42); DND_ARRAY_POW_LINE(43); DND_ARRAY_POW_LINE(44); DND_ARRAY_POW_LINE(45); DND_ARRAY_POW_LINE(46); DND_ARRAY_POW_LINE(47);
    DND_ARRAY_POW_LINE(48); DND_ARRAY_POW_LINE(49); DND_ARRAY_POW_LINE(50); DND_ARRAY_POW_LINE(51); DND_ARRAY_POW_LINE(52); DND_ARRAY_POW_LINE(53); DND_ARRAY_POW_LINE(54); DND_ARRAY_POW_LINE(55);
    DND_ARRAY_POW_LINE(56); DND_ARRAY_POW_LINE(57); DND_ARRAY_POW_LINE(58); DND_ARRAY_POW_LINE(59); DND_ARRAY_POW_LINE(60); DND_ARRAY_POW_LINE(61); DND_ARRAY_POW_LINE(62); DND_ARRAY_POW_LINE(63);
 
    log("数值过大，超过2^63：" + std::to_string(x));
    return 0;
}
#define DND_ARRAY_POW_LINE_32(index) if (x <= ARRAY_POW2_32[index])return ARRAY_POW2_32[index]
constexpr uint32_t CeilToPow2(uint32_t&& x)
{
    DND_ARRAY_POW_LINE_32(0); DND_ARRAY_POW_LINE_32(1); DND_ARRAY_POW_LINE_32(2); DND_ARRAY_POW_LINE_32(3); DND_ARRAY_POW_LINE_32(4); DND_ARRAY_POW_LINE_32(5); DND_ARRAY_POW_LINE_32(6); DND_ARRAY_POW_LINE_32(7);
    DND_ARRAY_POW_LINE_32(8); DND_ARRAY_POW_LINE_32(9); DND_ARRAY_POW_LINE_32(10); DND_ARRAY_POW_LINE_32(11); DND_ARRAY_POW_LINE_32(12); DND_ARRAY_POW_LINE_32(13); DND_ARRAY_POW_LINE_32(14); DND_ARRAY_POW_LINE_32(15);
    DND_ARRAY_POW_LINE_32(16); DND_ARRAY_POW_LINE_32(17); DND_ARRAY_POW_LINE_32(18); DND_ARRAY_POW_LINE_32(19); DND_ARRAY_POW_LINE_32(20); DND_ARRAY_POW_LINE_32(21); DND_ARRAY_POW_LINE_32(22); DND_ARRAY_POW_LINE_32(23);
    DND_ARRAY_POW_LINE_32(24); DND_ARRAY_POW_LINE_32(25); DND_ARRAY_POW_LINE_32(26); DND_ARRAY_POW_LINE_32(27); DND_ARRAY_POW_LINE_32(28); DND_ARRAY_POW_LINE_32(29); DND_ARRAY_POW_LINE_32(30); DND_ARRAY_POW_LINE_32(31);
 
    log("数值过大，超过2^31：" + std::to_string(x));
    return 0;
}

template <typename T>
inline T CeilToPow2(const T& x)
{
#if (DL_PLATFORM == DL_PLATFORM_WIN32)
    return std::bit_ceil(x);
#else
    return CeilToPow2(x);
#endif
}
 

inline float RSqrt(float x)
{
    long i;
    float x2, y;
    const float threehalfs = 1.5f;
 
    x2 = x * 0.5f;
    y = x;
    i = *(long*)&y;
    i = 0x5f3759df - (i >> 1);
    y = *(float*)&i;
    y = y * (threehalfs - (x2 * y * y));
    return y;
}
 

template<size_t N>
void NormalizeFast(Array<float, N>& v)
{
    float length = 0;
    for (size_t i = 0; i < N; ++i)
    {
        length += (v[i] * v[i]);
    }
 
    length = RSqrt(length);
    for (size_t i = 0; i < N; ++i)
    {
        v[i] *= length;
    }
}

template <IsUnsigned T0, IsSigned T1>
T0 AddU(T0 a, T1 b)
{
    if (b >= 0)
        return a + (T0)b;
    T0 nag_b = (T0)-b;
    return nag_b < a ? a - nag_b : 0;
}

template <IsUnsigned T0, IsSigned T1, size_t N>
void AddU(Array<T0, N>& a, const Array<T1, N>& b)
{
    for (size_t i = 0; i < N; ++i)
        a[i] = AddU(a[i], b[i]);
}
 
template <IsUnsigned T0, IsSigned T1, size_t N>
[[nodiscard]]
Array<T0, N> AddU(const Array<T0, N>& a, const Array<T1, N>& b)
{
    Array<T0, N> ret = a;
    for (size_t i = 0; i < N; ++i)
        AddU(ret, b[i]);
    return ret;
}

template <IsUnsigned T0, IsSigned T1>
bool AddUCheck(T0 a, T1 b, T0& ret)
{
    if (b >= 0)
        return a + (T0)b;
    T0 nag_b = (T0)-b;
    if (nag_b > a)
        return false;
    ret = a - nag_b;
    return true;
}

template <IsUnsigned T0, IsSigned T1, size_t N>
bool AddUCheck(const Array<T0, N>& a, const Array<T1, N>& b, const Array<T0, N>& ret)
{
    for (size_t i = 0; i < N; ++i)
    {
        if (!AddUCheck(a[i], b[i], ret[i]))
            return false;
    }
    return true;
}

template <IsUnsigned T>
T SubU(T a, T b)
{
    return a > b ? a - b : 0;
}

template <IsUnsigned T0, IsSigned T1>
T0 SubU(T0 a, T1 b)
{
    if (b <= 0)
        return a + -b;
    return SubU(a, (T0)b);
}

template <IsUnsigned T, size_t N>
Array<T, N> SubU(const Array<T, N>& a, const Array<T, N>& b)
{
    Array<T, N> ret;
    for (size_t i = 0; i < N; ++i)
        ret[i] = SubU(a[i], b[i]);
    return ret;
}

template <IsUnsigned T0, IsSigned T1, size_t N>
Array<T0, N> SubU(const Array<T0, N>& a, const Array<T1, N>& b)
{
    Array<T0, N> ret;
    for (size_t i = 0; i < N; ++i)
        ret[i] = SubU(a[i], b[i]);
    return ret;
}

template <IsUnsigned T>
T DisU(T a, T b)
{
    return a < b ? b - a : a - b;
}

template <IsUnsigned T, size_t N>
Array<T, N> DisU(const Array<T, N>& a, const Array<T, N>& b)
{
    Array<T, N> ret;
    for (size_t i = 0; i < N; ++i)
        ret[i] = DisU(a[i], b[i]);
    return ret;
}
 
 
//-------------------------------向量距离-----------------------------
template <typename T>
T DistancePow2(const Array<T, 2>& a)
{
    return a[0] * a[0] + a[1] * a[1];
}
 
template <typename T>
T DistancePow2(const Array<T, 3>& a)
{
    return a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
}
 
template <typename T>
T DistancePow2(const Array<T, 4>& a)
{
    return a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3];
}
template <typename T>
T Distance(const Array<T, 2>& a)
{
    return static_cast<T>(std::sqrt(DistancePow2(a)));
}
template <typename T>
T Distance(const Array<T, 3>& a)
{
    return static_cast<T>(std::sqrt(DistancePow2(a)));
}
template <typename T>
T Distance(const Array<T, 4>& a)
{
    return static_cast<T>(std::sqrt(DistancePow2(a)));
}

template <IsSigned T>
T DistancePow2(const Array<T, 2>& a, const Array<T, 2>& b)
{
    return DistancePow2(b - a);
}

template <IsUnsigned T>
T DistancePow2U(const Array<T, 2>& a, const Array<T, 2>& b)
{
    unsigned dx = DisU(a[0], b[0]);
    unsigned dy = DisU(a[1], b[1]);
    return dx * dx + dy * dy;
}

template <IsUnsigned T>
T DistanceU(const Array<T, 2>& a, const Array<T, 2>& b)
{
    return static_cast<T>(std::sqrt(DistancePow2U(a, b)));
}

template <IsSigned T, size_t N>
void Normalize(Array<T, N>& v)
{
    T length = DistancePow2(v);
    length = sqrt(length);
 
    v /= length;
}
 
template <IsSigned T, size_t N>
[[nodiscard]]
Array<T, N> Normalize(const Array<T, N>& v)
{
    Array<T, N> ret = v;
    Normalize(ret);
    return ret;
}

std::vector<PointU> GetCircle(const Size& size, const PointU& xy, unsigned rad);
 

std::vector<Point> GetCircle(const Point& xy, unsigned rad);
 

constexpr double PI(unsigned n = 1, unsigned d = 1)
{
#ifdef false
    return std::numbers::pi * n / d;
#else
    return 3.1415926535897932384626433832795 * n / d;
#endif
}
constexpr float PIF(unsigned n = 1, unsigned d = 1)
{
#ifdef false
    return (float)std::numbers::pi * n / d;
#else
    return 3.1415926535897932384626433832795f * n / d;
#endif
}

/*dnd::Direction IndexRpg2Direction(size_t index)
{
    if (index == 0)
        return Direction::DOWN;
    if (index == 1)
        return Direction::LEFT;
    if (index == 2)
        return Direction::RIGHT;
    if (index == 3)
        return Direction::UP;
 
    debug_warn("错误的下标！[0, 3]");
    return Direction::DOWN;
}*/

//DirectionMask::Var Dir2Mask(const Vector2& dir)
//{
//  if (Every::Zero(dir))
//      return DirectionMask::NONE;
//  double r = atan2(dir[1], dir[0]);//返回(-pi, pi]，从正x轴向正y轴旋转
//  if (r < 0)//变换到(0, 2pi]，x轴不变
//      r += (std::numbers::pi * 2.0);
//  r += (std::numbers::pi / 8.0);//四舍五入 加pi/8
//  size_t index = r / (std::numbers::pi / 4.0);//2pi分为8个方向为pi/4
 
//  dnd_assert(index >= 0 && index <= 7);
//  //x为0
//  if (index == 0)
//      return DirectionMask::RIGHT;
//  else if (index == 1)
//      return DirectionMask::RIGHT_DOWN;
//  else if (index == 2)
//      return DirectionMask::DOWN;
//  else if (index == 3)
//      return DirectionMask::LEFT_DOWN;
//  else if (index == 4)
//      return DirectionMask::LEFT;
//  else if (index == 5)
//      return DirectionMask::LEFT_UP;
//  else if (index == 6)
//      return DirectionMask::UP;
//  else if (index == 7)
//      return DirectionMask::RIGHT_UP;
//  return DirectionMask::NONE;
//}

template<IsReal T>
constexpr T AlignF(T x, T align)
{
    assert(align > 0);
 
    if (x < 0)
    {
        T ret = -align;
        while (x < ret)
        {
            ret -= align;
        }
        return ret + align;
    }
    else
    {
        T ret = align;
        while (x > ret)
        {
            ret += align;
        }
        return ret;
    }
}

template<IsUnsigned T>
constexpr T Align(T x, T align)
{
    assert(align != 0);
 
    T ret = align;
    while (x > ret)
    {
        ret += align;
    }
    return ret;
}

constexpr unsigned IsPow2(unsigned x)
{
    return x && !(x & (x - 1));
}

constexpr unsigned AlignPow2(unsigned x, unsigned align)
{
    if (!IsPow2(align))
        return 0;
 
    return (x + align - 1) & ~(align - 1);
}

constexpr unsigned div_found(unsigned n, unsigned d)
{
    unsigned q = n / d;
    unsigned r = n % d;
    return r >= (d >> 1) ? q + 1 : q;
}

constexpr unsigned div_found_fast(unsigned n, unsigned d)
{
    return (n + (d >> 1)) / d;
}

constexpr float OffsetOrder(float order, int u = 1, int v = 0, int w = 0)
{
    constexpr int NUM_ORDER_DT = 100;
    float ret = order + (w + v * NUM_ORDER_DT + u * NUM_ORDER_DT * NUM_ORDER_DT)
        * std::numeric_limits<float>::epsilon();
    if (!is_saturate(ret))
    {
        log_("order超出范围：{}", ret);
        return saturate(ret);
    }
    return ret;
}

constexpr Float CrossProduct(const Position2& a, const Position2& b)
{
    return a[0] * b[1] - a[1] * b[0];
}
 
constexpr Position3 CrossProduct(const Position3& a, const Position3& b)
{
    return {
        a[1] * b[2] - b[1] * a[2],
        a[2] * b[0] - b[2] * a[0],
        a[0] * b[1] - b[0] * a[1]
    };
}

template<typename T, size_t N>
constexpr T DotProduct(const Array<T, N>& a, const Array<T, N>& b)
{
    T ret = 0;
    for (size_t i = 0; i < N; ++i)
        ret += a[i] * b[i];
    return ret;
}

Position4 Slerp(const Position4& q0, const Position4& q1, const Float& t);

//constexpr void Rect2Uv(const Size& tex_size, const RectU& rect, floatx2* uv)
//{
//  floatx4 ltrb;
//  ltrb[LTRB::LEFT] = float(rect[LTRB::LEFT]) / tex_size[0];
//  ltrb[LTRB::TOP] = float(rect[LTRB::TOP]) / tex_size[1];
//  ltrb[LTRB::RIGHT] = float(rect[LTRB::RIGHT]) / tex_size[0];
//  ltrb[LTRB::BUTTOM] = float(rect[LTRB::BUTTOM]) / tex_size[1];
//
//      
//  uv[Corner::LT] = { ltrb[LTRB::LEFT], ltrb[LTRB::TOP] };
//  uv[Corner::RT] = { ltrb[LTRB::RIGHT], ltrb[LTRB::TOP] };
//  uv[Corner::LB] = { ltrb[LTRB::LEFT], ltrb[LTRB::BUTTOM] };
//  uv[Corner::RB] = { ltrb[LTRB::RIGHT], ltrb[LTRB::BUTTOM] };
//}

template<typename C>
constexpr auto DistanceDiagonal(const C& p0, const C& p1)
{
    C dt = p1 - p0;
    Every::Abs(dt);
    return Select::Max(dt);
}
 

std::vector<Point> DrawLineLerp(const Point& p0, const Point& p1);

std::vector<Point> DrawLineBresenham(const Point& p0, const Point& p1);

std::vector<Point> DrawLineOrth(const Point& p0, const Point& p1);

std::vector<Point> DrawLineCover(const Point& p0, const Point& p1);

void MergePath(std::list<Point>& list_pos);

template<typename F>
void MergePathDirect(std::list<Point>& list_pos, F func_pass)
{
    if (list_pos.size() < 3)
        return;
    auto iter_last = list_pos.end();//最后一个点总是有效的
    --iter_last;
    for (auto iter_0 = list_pos.begin(); iter_0 != iter_last;)
    {//直到前一个点到 iter_last（最后一个点）
        //iter_0的下一个点
        auto iter_0_next = iter_0;
        ++iter_0_next;
        //是否删除了节点
        bool b_del = false;
        for (auto iter_1 = iter_last; iter_1 != iter_0_next; --iter_1)
        {//后一个点 从后往前遍历，直到iter_0_next
            if (func_pass(*iter_0, *iter_1))
            {//如果可通行 删除中间的节点
                for (auto iter = iter_0_next; iter != iter_1;)
                    iter = list_pos.erase(iter);
                iter_0 = iter_1;//后一个点此时成为起点
                b_del = true;
                break;
            }
        }
        if (!b_del)
            ++iter_0;
    }
}
 
 
//----------------Quad和Rect的操作不同，Quad需要加名字-------
template<typename T>
constexpr T GetQuadSize(const Array<T, 4>& quad)
{
    return quad[2] - quad[0];
}

template<typename T>
constexpr Array<T, 3> GetQuadTriangle0(const Array<T, 4>& quad)
{
    return { quad[0], quad[1], quad[2] };
}
template<typename T>
constexpr Array<T, 3> GetQuadTriangle1(const Array<T, 4>& quad)
{
    return { quad[0], quad[2], quad[3] };
}

template<typename T>
constexpr bool IsRectValid(const Array<T, 4>& rect)
{
    return rect[0] <= rect[2]
        && rect[1] <= rect[3];
}

template<typename T>
constexpr bool IsRectEmpty(const Array<T, 4>& rect)
{
    return rect[0] == rect[2]
        && rect[1] == rect[3];
}

template<typename T>
constexpr bool IsRectInSize(const Array<T, 4>& rect, const Size& size)
{
    if (!IsRectValid(rect))
        return false;
    return rect[0] >= 0
        && rect[1] >= 0
        && rect[2] <= size[0]
        && rect[3] <= size[1];
}

constexpr bool IsXyInSize(const Point& xy, const Size& size)
{
    if (Each::Less(xy, {}))
        return false;
    return unsigned(xy[0]) < size[0]
        && unsigned(xy[1]) < size[1];
}

constexpr bool IsXyInRect(const Point& xy, const Rect& rect)
{
    return xy[0] >= rect[0]
        && xy[1] >= rect[1]
        && xy[0] < rect[2]
        && xy[1] < rect[3];
}

constexpr bool IsTriangle(const Triangle& triangle)
{
    Position ab = triangle[0] - triangle[1];
    Position ac = triangle[0] - triangle[2];
 
    return CrossProduct(ab, ac) != 0;
}

constexpr bool IsDotInTriangle(const Position& dot, const Triangle& triangle)
{
    if (!IsTriangle(triangle))
        return false;
    Position pa = triangle[0] - dot;
    Position pb = triangle[1] - dot;
    Position pc = triangle[2] - dot;
    Float t1 = CrossProduct(pa, pb);
    Float t2 = CrossProduct(pb, pc);
    Float t3 = CrossProduct(pc, pa);
    return t1 * t2 >= 0 &&
        t1 * t3 >= 0 &&
        t2 * t3 >= 0;
}

constexpr bool IsDotInQuad(const Position& dot, const Quad& quad)
{
    return Math::IsDotInTriangle(dot, GetQuadTriangle0(quad))
        || Math::IsDotInTriangle(dot, GetQuadTriangle1(quad));
}

//constexpr bool IsDotInQuadConvex(const Position& dot, const Quad& quad)
//{
//  
//}

constexpr Position CreatePositionByRatioGoldW(Float w)
{
    return { w, w * Numbers::RATIO_GOLD };
}

template<typename T, typename F>
void GetRectTrim(F func, Array<T, 4>& rect)
{
    if (!IsRectValid(rect) || IsRectEmpty(rect))
    {
        return;
    }
    // 向下移动y
    while (rect.top < rect.bottom)
    {
        bool can_trim = true;
        for (T x = rect.left; x < rect.right; ++x)
        {
            if (func(x, rect.top))
            {
                can_trim = false;
                break;
            }
        }
        if (can_trim)
            ++rect.top;
        else
            break;
    }
    // 向上移动y
    while (rect.bottom - 1 > rect.top)
    {
        bool can_trim = true;
        for (T x = rect.left; x < rect.right; ++x)
        {
            if (func(x, rect.bottom - 1))
            {
                can_trim = false;
                break;
            }
        }
        if (can_trim)
            --rect.bottom;
        else
            break;
    }
    // 向右移动x
    while (rect.left < rect.right)
    {
        bool can_trim = true;
        for (T y = rect.top; y < rect.bottom; ++y)
        {
            if (func(rect.left, y))
            {
                can_trim = false;
                break;
            }
        }
        if (can_trim)
            ++rect.left;
        else
            break;
    }
    // 向左移动
    while (rect.right - 1 > rect.left)
    {
        bool can_trim = true;
        for (T y = rect.top; y < rect.bottom; ++y)
        {
            if (func(rect.right - 1, y))
            {
                can_trim = false;
                break;
            }
        }
        if (can_trim)
            --rect.right;
        else
            break;
    }
}

template<typename T>
void ExtendRectLeft(T min_left, Array<T, 4>& rect, T extend = 1)
{
    if (rect.left >= min_left + extend)
        rect.left -= extend;
}

template<typename T>
void ExtendRectTop(T min_top, Array<T, 4>& rect, T extend = 1)
{
    if (rect.top >= min_top + extend)
        rect.top -= extend;
}

template<typename T>
void ExtendRectRight(T max_right, Array<T, 4>& rect, T extend = 1)
{
    if (rect.right + extend <= max_right)
        rect.right += extend;
}

template<typename T>
void ExtendRectBottom(T max_bottom, Array<T, 4>& rect, T extend = 1)
{
    if (rect.bottom + extend <= max_bottom)
        rect.bottom += extend;
}

template<typename T>
void ExtendRect(const Array<T, 4>& rect_big, Array<T, 4>& rect, T extend = 1)
{
    ExtendRectLeft(rect_big.left, rect, extend);
    ExtendRectTop(rect_big.top, rect, extend);
    ExtendRectRight(rect_big.right, rect, extend);
    ExtendRectBottom(rect_big.bottom, rect, extend);
}

template<typename T>
void ExtendRect(const Array<T, 2>& size, Array<T, 4>& rect, T extend = 1)
{
    ExtendRectLeft((T)0, rect, extend);
    ExtendRectTop((T)0, rect, extend);
    ExtendRectRight(size.w, rect, extend);
    ExtendRectBottom(size.h, rect, extend);
}

template<typename T>
void ExtendRectRB(const Array<T, 2>& size, Array<T, 4>& rect, T extend = 1)
{
    ExtendRectRight(size.w, rect, extend);
    ExtendRectBottom(size.h, rect, extend);
}
 

inline unsigned GetCircleNumMax(unsigned rad)
{
    // todo 待证明更优的公式
    return (unsigned)std::ceil(PI() * (rad + 1) * (rad + 1));
}
 
namespace RingX
{
    // size不能为0

    inline void Clamp(const Size& size, PointU& xy)
    {
        if (xy.y >= size.h)
            xy.y = size.h - 1;
        while (xy.x >= size.w)
            xy.x -= size.w;
    }

    inline bool Clamp(const Size& size, Point xy, PointU& out_xy)
    {
        if (xy.y < 0 || xy.y >= (int)size.h)
            return false;
        while (xy.x < 0)
            xy.x += size.w;
        while (xy.x >= (int)size.w)
            xy.x -= size.w;
        out_xy = toSizeDefault(xy);
        return true;
    }

    inline unsigned DistancePow2NoCheck(const Size& size, const PointU& a, const PointU& b)
    {
        PointU dt;
        dt.x = DisU(a.x, b.x);
        if (dt.x > size.w / 2)
            dt.x = size.w - dt.x;
        dt.y = DisU(a.y, b.y);
        return Math::DistancePow2(dt);
    }

    inline unsigned Distance(const Size& size, const PointU& a, const PointU& b)
    {
        PointU aa = a;
        Clamp(size, aa);
        PointU bb = b;
        Clamp(size, bb);
        PointU dt;
        dt.x = DisU(aa.x, bb.x);
        if (dt.x > size.w / 2)
            dt.x = size.w / 2 - dt.x;
        dt.y = DisU(aa.y, bb.y);
        return Math::Distance(dt);
    }

    std::vector<PointU> GetCircle(const Size& size, const PointU& xy, unsigned rad);
 

    class MapLimit
    {
    public:
        void SetSize(const Size& size)
        {
            _size = size;
        }

        //  失败会修改原值
 
        bool Left(PointU& xy)
        {
            if (!CheckVaildY(xy))
                return false;
            if (xy.x == 0)
                xy.x = _size.w - 1;
            else
            {
                if (xy.x - 1 >= _size.w)
                    return false;
                --xy.x;
            }
            return true;
        }
        bool Right(PointU& xy)
        {
            if (!CheckVaildY(xy))
                return false;
            if (xy.x + 1 > _size.w)
                return false;
 
            if (xy.x + 1 == _size.w)
                xy.x = 0;
            else
                ++xy.x;
            return true;
        }
        bool Top(PointU& xy)
        {
            if (!CheckVaildX(xy))
                return false;
            if (xy.y == 0)
                return false;
            if (xy.y - 1 >= _size.h)
                return false;
            --xy.y;
            return true;
        }
        bool Bottom(PointU& xy)
        {
            if (!CheckVaildX(xy))
                return false;
            if (xy.y + 1 >= _size.h)
                return false;
            ++xy.y;
            return true;
        }
        bool LeftTop(PointU& xy)
        {
            if (!Top(xy))
                return false;
            return Left(xy);
        }
        bool LeftBottom(PointU& xy)
        {
            if (!Bottom(xy))
                return false;
            return Left(xy);
        }
        bool RightTop(PointU& xy)
        {
            if (!Top(xy))
                return false;
            return Right(xy);
        }
        bool RightBottom(PointU& xy)
        {
            if (!Bottom(xy))
                return false;
            return Right(xy);
        }
        bool CheckVaild(const PointU& xy)
        {
            return xy.x < _size.w && xy.y < _size.h;
        }
        bool CheckVaildX(const PointU& xy)
        {
            return xy.x < _size.w;
        }
        bool CheckVaildY(const PointU& xy)
        {
            return xy.y < _size.h;
        }
    private:
        Size _size;
    };
 
 
    using FnDiffusionCheck = std::function<bool(const PointU& xy)>;
    using FnDiffusionCb = std::function<void(unsigned, const std::list<PointU>& xy)>;

    std::vector<PointU> Diffusion(const Size& size, const PointU& xy, unsigned count,
        FnDiffusionCheck func_valid, FnDiffusionCb func_cb);
}
 
 

constexpr double DegreesToRadians(double deg)
{
    return deg * PI() / 180.0;
}

constexpr double RadiansToDegrees(double rad)
{
    return rad * 180.0f / PI();
}
 
//！ 判断是否是闰年
constexpr bool IsLeapYear(int year)
{
    // 本质是一个无限的判断，但在短时间（几万年）内精度够用
    return (year % 4 == 0 && year % 100 != 0)
        || year % 400 == 0;
}
 
//！ 获取某月的天数
constexpr int GetMouthDayNum(int year, int mouth)
{
    switch (mouth)
    {
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12:
        return 31;
    case 2:
        return IsLeapYear(year) ? 29 : 28;
    default:
        break;
    }
    return 30;
}
 
//--------------------------------地理相关函数由ai生成，简单整理而成，非专业函数

double GetSolarDeclination(int day);

double GetSolarElevation(double latitude, double declination);

int GetSeason(int day, double latitude);
double GetBaseTemperature(double latitude, int day);
 
}