mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2024-11-21 23:20:20 +00:00
AK: Move rounding function to the top of AK/Math.h
These are useful in other algorithms, so lets move them up
This commit is contained in:
Hediadyoin1
Andreas Kling
parent
47c074ab11
commit
6573ace8f1
Notes:
sideshowbarker
2024-07-17 05:58:46 +09:00
Author: https://github.com/Hendiadyoin1 Commit: https://github.com/SerenityOS/serenity/commit/6573ace8f1 Pull-request: https://github.com/SerenityOS/serenity/pull/18998 Reviewed-by: https://github.com/kleinesfilmroellchen ✅ Reviewed-by: https://github.com/linusg ✅
1 changed files with 208 additions and 200 deletions
408
AK/Math.h
408
AK/Math.h
|
|
@ -81,6 +81,214 @@ constexpr size_t product_odd() { return value * product_odd<value - 2>(); }
|
|||
return res; \
|
||||
}
|
||||
|
||||
namespace Rounding {
|
||||
template<FloatingPoint T>
|
||||
constexpr T ceil(T num)
|
||||
{
|
||||
if (is_constant_evaluated()) {
|
||||
if (num < NumericLimits<i64>::min() || num > NumericLimits<i64>::max())
|
||||
return num;
|
||||
return (static_cast<T>(static_cast<i64>(num)) == num)
|
||||
? static_cast<i64>(num)
|
||||
: static_cast<i64>(num) + ((num > 0) ? 1 : 0);
|
||||
}
|
||||
#if ARCH(AARCH64)
|
||||
AARCH64_INSTRUCTION(frintp, num);
|
||||
#else
|
||||
return __builtin_ceil(num);
|
||||
#endif
|
||||
}
|
||||
|
||||
template<FloatingPoint T>
|
||||
constexpr T floor(T num)
|
||||
{
|
||||
if (is_constant_evaluated()) {
|
||||
if (num < NumericLimits<i64>::min() || num > NumericLimits<i64>::max())
|
||||
return num;
|
||||
return (static_cast<T>(static_cast<i64>(num)) == num)
|
||||
? static_cast<i64>(num)
|
||||
: static_cast<i64>(num) - ((num > 0) ? 0 : 1);
|
||||
}
|
||||
#if ARCH(AARCH64)
|
||||
AARCH64_INSTRUCTION(frintm, num);
|
||||
#else
|
||||
return __builtin_floor(num);
|
||||
#endif
|
||||
}
|
||||
|
||||
template<FloatingPoint T>
|
||||
constexpr T round(T x)
|
||||
{
|
||||
CONSTEXPR_STATE(round, x);
|
||||
// Note: This is break-tie-away-from-zero, so not the hw's understanding of
|
||||
// "nearest", which would be towards even.
|
||||
if (x == 0.)
|
||||
return x;
|
||||
if (x > 0.)
|
||||
return floor(x + .5);
|
||||
return ceil(x - .5);
|
||||
}
|
||||
|
||||
template<Integral I, FloatingPoint P>
|
||||
ALWAYS_INLINE I round_to(P value);
|
||||
|
||||
#if ARCH(X86_64)
|
||||
template<Integral I>
|
||||
ALWAYS_INLINE I round_to(long double value)
|
||||
{
|
||||
// Note: fistps outputs into a signed integer location (i16, i32, i64),
|
||||
// so lets be nice and tell the compiler that.
|
||||
Conditional<sizeof(I) >= sizeof(i16), MakeSigned<I>, i16> ret;
|
||||
if constexpr (sizeof(I) == sizeof(i64)) {
|
||||
asm("fistpll %0"
|
||||
: "=m"(ret)
|
||||
: "t"(value)
|
||||
: "st");
|
||||
} else if constexpr (sizeof(I) == sizeof(i32)) {
|
||||
asm("fistpl %0"
|
||||
: "=m"(ret)
|
||||
: "t"(value)
|
||||
: "st");
|
||||
} else {
|
||||
asm("fistps %0"
|
||||
: "=m"(ret)
|
||||
: "t"(value)
|
||||
: "st");
|
||||
}
|
||||
return static_cast<I>(ret);
|
||||
}
|
||||
|
||||
template<Integral I>
|
||||
ALWAYS_INLINE I round_to(float value)
|
||||
{
|
||||
// FIXME: round_to<u64> might will cause issues, aka the indefinite value being set,
|
||||
// if the value surpasses the i64 limit, even if the result could fit into an u64
|
||||
// To solve this we would either need to detect that value or do a range check and
|
||||
// then do a more specialized conversion, which might include a division (which is expensive)
|
||||
if constexpr (sizeof(I) == sizeof(i64) || IsSame<I, u32>) {
|
||||
i64 ret;
|
||||
asm("cvtss2si %1, %0"
|
||||
: "=r"(ret)
|
||||
: "xm"(value));
|
||||
return static_cast<I>(ret);
|
||||
}
|
||||
i32 ret;
|
||||
asm("cvtss2si %1, %0"
|
||||
: "=r"(ret)
|
||||
: "xm"(value));
|
||||
return static_cast<I>(ret);
|
||||
}
|
||||
|
||||
template<Integral I>
|
||||
ALWAYS_INLINE I round_to(double value)
|
||||
{
|
||||
// FIXME: round_to<u64> might will cause issues, aka the indefinite value being set,
|
||||
// if the value surpasses the i64 limit, even if the result could fit into an u64
|
||||
// To solve this we would either need to detect that value or do a range check and
|
||||
// then do a more specialized conversion, which might include a division (which is expensive)
|
||||
if constexpr (sizeof(I) == sizeof(i64) || IsSame<I, u32>) {
|
||||
i64 ret;
|
||||
asm("cvtsd2si %1, %0"
|
||||
: "=r"(ret)
|
||||
: "xm"(value));
|
||||
return static_cast<I>(ret);
|
||||
}
|
||||
i32 ret;
|
||||
asm("cvtsd2si %1, %0"
|
||||
: "=r"(ret)
|
||||
: "xm"(value));
|
||||
return static_cast<I>(ret);
|
||||
}
|
||||
|
||||
#elif ARCH(AARCH64)
|
||||
template<Signed I>
|
||||
ALWAYS_INLINE I round_to(float value)
|
||||
{
|
||||
if constexpr (sizeof(I) <= sizeof(u32)) {
|
||||
i32 res;
|
||||
asm("fcvtns %w0, %s1"
|
||||
: "=r"(res)
|
||||
: "w"(value));
|
||||
return static_cast<I>(res);
|
||||
}
|
||||
i64 res;
|
||||
asm("fcvtns %0, %s1"
|
||||
: "=r"(res)
|
||||
: "w"(value));
|
||||
return static_cast<I>(res);
|
||||
}
|
||||
|
||||
template<Signed I>
|
||||
ALWAYS_INLINE I round_to(double value)
|
||||
{
|
||||
if constexpr (sizeof(I) <= sizeof(u32)) {
|
||||
i32 res;
|
||||
asm("fcvtns %w0, %d1"
|
||||
: "=r"(res)
|
||||
: "w"(value));
|
||||
return static_cast<I>(res);
|
||||
}
|
||||
i64 res;
|
||||
asm("fcvtns %0, %d1"
|
||||
: "=r"(res)
|
||||
: "w"(value));
|
||||
return static_cast<I>(res);
|
||||
}
|
||||
|
||||
template<Unsigned U>
|
||||
ALWAYS_INLINE U round_to(float value)
|
||||
{
|
||||
if constexpr (sizeof(U) <= sizeof(u32)) {
|
||||
u32 res;
|
||||
asm("fcvtnu %w0, %s1"
|
||||
: "=r"(res)
|
||||
: "w"(value));
|
||||
return static_cast<U>(res);
|
||||
}
|
||||
i64 res;
|
||||
asm("fcvtnu %0, %s1"
|
||||
: "=r"(res)
|
||||
: "w"(value));
|
||||
return static_cast<U>(res);
|
||||
}
|
||||
|
||||
template<Unsigned U>
|
||||
ALWAYS_INLINE U round_to(double value)
|
||||
{
|
||||
if constexpr (sizeof(U) <= sizeof(u32)) {
|
||||
u32 res;
|
||||
asm("fcvtns %w0, %d1"
|
||||
: "=r"(res)
|
||||
: "w"(value));
|
||||
return static_cast<U>(res);
|
||||
}
|
||||
i64 res;
|
||||
asm("fcvtns %0, %d1"
|
||||
: "=r"(res)
|
||||
: "w"(value));
|
||||
return static_cast<U>(res);
|
||||
}
|
||||
|
||||
#else
|
||||
template<Integral I, FloatingPoint P>
|
||||
ALWAYS_INLINE I round_to(P value)
|
||||
{
|
||||
if constexpr (IsSame<P, long double>)
|
||||
return static_cast<I>(__builtin_llrintl(value));
|
||||
if constexpr (IsSame<P, double>)
|
||||
return static_cast<I>(__builtin_llrint(value));
|
||||
if constexpr (IsSame<P, float>)
|
||||
return static_cast<I>(__builtin_llrintf(value));
|
||||
}
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
using Rounding::ceil;
|
||||
using Rounding::floor;
|
||||
using Rounding::round;
|
||||
using Rounding::round_to;
|
||||
|
||||
namespace Division {
|
||||
template<FloatingPoint T>
|
||||
constexpr T fmod(T x, T y)
|
||||
|
|
@ -680,159 +888,6 @@ using Hyperbolic::cosh;
|
|||
using Hyperbolic::sinh;
|
||||
using Hyperbolic::tanh;
|
||||
|
||||
template<Integral I, FloatingPoint P>
|
||||
ALWAYS_INLINE I round_to(P value);
|
||||
|
||||
#if ARCH(X86_64)
|
||||
template<Integral I>
|
||||
ALWAYS_INLINE I round_to(long double value)
|
||||
{
|
||||
// Note: fistps outputs into a signed integer location (i16, i32, i64),
|
||||
// so lets be nice and tell the compiler that.
|
||||
Conditional<sizeof(I) >= sizeof(i16), MakeSigned<I>, i16> ret;
|
||||
if constexpr (sizeof(I) == sizeof(i64)) {
|
||||
asm("fistpll %0"
|
||||
: "=m"(ret)
|
||||
: "t"(value)
|
||||
: "st");
|
||||
} else if constexpr (sizeof(I) == sizeof(i32)) {
|
||||
asm("fistpl %0"
|
||||
: "=m"(ret)
|
||||
: "t"(value)
|
||||
: "st");
|
||||
} else {
|
||||
asm("fistps %0"
|
||||
: "=m"(ret)
|
||||
: "t"(value)
|
||||
: "st");
|
||||
}
|
||||
return static_cast<I>(ret);
|
||||
}
|
||||
|
||||
template<Integral I>
|
||||
ALWAYS_INLINE I round_to(float value)
|
||||
{
|
||||
// FIXME: round_to<u64> might will cause issues, aka the indefinite value being set,
|
||||
// if the value surpasses the i64 limit, even if the result could fit into an u64
|
||||
// To solve this we would either need to detect that value or do a range check and
|
||||
// then do a more specialized conversion, which might include a division (which is expensive)
|
||||
if constexpr (sizeof(I) == sizeof(i64) || IsSame<I, u32>) {
|
||||
i64 ret;
|
||||
asm("cvtss2si %1, %0"
|
||||
: "=r"(ret)
|
||||
: "xm"(value));
|
||||
return static_cast<I>(ret);
|
||||
}
|
||||
i32 ret;
|
||||
asm("cvtss2si %1, %0"
|
||||
: "=r"(ret)
|
||||
: "xm"(value));
|
||||
return static_cast<I>(ret);
|
||||
}
|
||||
|
||||
template<Integral I>
|
||||
ALWAYS_INLINE I round_to(double value)
|
||||
{
|
||||
// FIXME: round_to<u64> might will cause issues, aka the indefinite value being set,
|
||||
// if the value surpasses the i64 limit, even if the result could fit into an u64
|
||||
// To solve this we would either need to detect that value or do a range check and
|
||||
// then do a more specialized conversion, which might include a division (which is expensive)
|
||||
if constexpr (sizeof(I) == sizeof(i64) || IsSame<I, u32>) {
|
||||
i64 ret;
|
||||
asm("cvtsd2si %1, %0"
|
||||
: "=r"(ret)
|
||||
: "xm"(value));
|
||||
return static_cast<I>(ret);
|
||||
}
|
||||
i32 ret;
|
||||
asm("cvtsd2si %1, %0"
|
||||
: "=r"(ret)
|
||||
: "xm"(value));
|
||||
return static_cast<I>(ret);
|
||||
}
|
||||
|
||||
#elif ARCH(AARCH64)
|
||||
template<Signed I>
|
||||
ALWAYS_INLINE I round_to(float value)
|
||||
{
|
||||
if constexpr (sizeof(I) <= sizeof(u32)) {
|
||||
i32 res;
|
||||
asm("fcvtns %w0, %s1"
|
||||
: "=r"(res)
|
||||
: "w"(value));
|
||||
return static_cast<I>(res);
|
||||
}
|
||||
i64 res;
|
||||
asm("fcvtns %0, %s1"
|
||||
: "=r"(res)
|
||||
: "w"(value));
|
||||
return static_cast<I>(res);
|
||||
}
|
||||
|
||||
template<Signed I>
|
||||
ALWAYS_INLINE I round_to(double value)
|
||||
{
|
||||
if constexpr (sizeof(I) <= sizeof(u32)) {
|
||||
i32 res;
|
||||
asm("fcvtns %w0, %d1"
|
||||
: "=r"(res)
|
||||
: "w"(value));
|
||||
return static_cast<I>(res);
|
||||
}
|
||||
i64 res;
|
||||
asm("fcvtns %0, %d1"
|
||||
: "=r"(res)
|
||||
: "w"(value));
|
||||
return static_cast<I>(res);
|
||||
}
|
||||
|
||||
template<Unsigned U>
|
||||
ALWAYS_INLINE U round_to(float value)
|
||||
{
|
||||
if constexpr (sizeof(U) <= sizeof(u32)) {
|
||||
u32 res;
|
||||
asm("fcvtnu %w0, %s1"
|
||||
: "=r"(res)
|
||||
: "w"(value));
|
||||
return static_cast<U>(res);
|
||||
}
|
||||
i64 res;
|
||||
asm("fcvtnu %0, %s1"
|
||||
: "=r"(res)
|
||||
: "w"(value));
|
||||
return static_cast<U>(res);
|
||||
}
|
||||
|
||||
template<Unsigned U>
|
||||
ALWAYS_INLINE U round_to(double value)
|
||||
{
|
||||
if constexpr (sizeof(U) <= sizeof(u32)) {
|
||||
u32 res;
|
||||
asm("fcvtns %w0, %d1"
|
||||
: "=r"(res)
|
||||
: "w"(value));
|
||||
return static_cast<U>(res);
|
||||
}
|
||||
i64 res;
|
||||
asm("fcvtns %0, %d1"
|
||||
: "=r"(res)
|
||||
: "w"(value));
|
||||
return static_cast<U>(res);
|
||||
}
|
||||
|
||||
#else
|
||||
template<Integral I, FloatingPoint P>
|
||||
ALWAYS_INLINE I round_to(P value)
|
||||
{
|
||||
if constexpr (IsSame<P, long double>)
|
||||
return static_cast<I>(__builtin_llrintl(value));
|
||||
if constexpr (IsSame<P, double>)
|
||||
return static_cast<I>(__builtin_llrint(value));
|
||||
if constexpr (IsSame<P, float>)
|
||||
return static_cast<I>(__builtin_llrintf(value));
|
||||
}
|
||||
#endif
|
||||
|
||||
template<FloatingPoint T>
|
||||
constexpr T pow(T x, T y)
|
||||
{
|
||||
|
|
@ -859,53 +914,6 @@ constexpr T pow(T x, T y)
|
|||
return exp2<T>(y * log2<T>(x));
|
||||
}
|
||||
|
||||
template<FloatingPoint T>
|
||||
constexpr T ceil(T num)
|
||||
{
|
||||
if (is_constant_evaluated()) {
|
||||
if (num < NumericLimits<i64>::min() || num > NumericLimits<i64>::max())
|
||||
return num;
|
||||
return (static_cast<T>(static_cast<i64>(num)) == num)
|
||||
? static_cast<i64>(num)
|
||||
: static_cast<i64>(num) + ((num > 0) ? 1 : 0);
|
||||
}
|
||||
#if ARCH(AARCH64)
|
||||
AARCH64_INSTRUCTION(frintp, num);
|
||||
#else
|
||||
return __builtin_ceil(num);
|
||||
#endif
|
||||
}
|
||||
|
||||
template<FloatingPoint T>
|
||||
constexpr T floor(T num)
|
||||
{
|
||||
if (is_constant_evaluated()) {
|
||||
if (num < NumericLimits<i64>::min() || num > NumericLimits<i64>::max())
|
||||
return num;
|
||||
return (static_cast<T>(static_cast<i64>(num)) == num)
|
||||
? static_cast<i64>(num)
|
||||
: static_cast<i64>(num) - ((num > 0) ? 0 : 1);
|
||||
}
|
||||
#if ARCH(AARCH64)
|
||||
AARCH64_INSTRUCTION(frintm, num);
|
||||
#else
|
||||
return __builtin_floor(num);
|
||||
#endif
|
||||
}
|
||||
|
||||
template<FloatingPoint T>
|
||||
constexpr T round(T x)
|
||||
{
|
||||
CONSTEXPR_STATE(round, x);
|
||||
// Note: This is break-tie-away-from-zero, so not the hw's understanding of
|
||||
// "nearest", which would be towards even.
|
||||
if (x == 0.)
|
||||
return x;
|
||||
if (x > 0.)
|
||||
return floor(x + .5);
|
||||
return ceil(x - .5);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr int clamp_to_int(T value)
|
||||
{
|
||||
|
|
|
|||
Loading…
Reference in a new issue