RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 20:17:44 +00:00
Code Issues Activity Actions

LibM: Fix Lagom build

Browse source 
isnormal really messes up the build. Just remove it for now; it can be
addressed in a seperate commit. Additionally, conditionally add
`noexcept` to the math functions if we are in a C++ context.
This commit is contained in:
Matthew Olsson 2020-07-23 18:32:46 -07:00 • committed by Andreas Kling
parent b1299f972c
commit 49c5acaa3d
2 changed files with 129 additions and 131 deletions
Download patch file Download diff file Expand all files Collapse all files

124
Libraries/LibM/math.cpp
View file

@ -59,17 +59,17 @@ constexpr size_t product_odd() { return value * product_odd<value - 2>(); }
extern "C" { extern "C" {
double trunc(double x) double trunc(double x) NOEXCEPT
{ {
return (int64_t)x; return (int64_t)x;
} }
double cos(double angle) double cos(double angle) NOEXCEPT
{ {
return sin(angle + M_PI_2); return sin(angle + M_PI_2);
} }
float cosf(float angle) float cosf(float angle) NOEXCEPT
{ {
return sinf(angle + M_PI_2); return sinf(angle + M_PI_2);
} }
@ -78,7 +78,7 @@ float cosf(float angle)
// now this works pretty well (and doesn't mess anything up // now this works pretty well (and doesn't mess anything up
// in quake in particular, which is very Floating-Point precision // in quake in particular, which is very Floating-Point precision
// heavy) // heavy)
double sin(double angle) double sin(double angle) NOEXCEPT
{ {
double ret = 0.0; double ret = 0.0;
__asm__( __asm__(
@ -89,7 +89,7 @@ double sin(double angle)
return ret; return ret;
} }
float sinf(float angle) float sinf(float angle) NOEXCEPT
{ {
float ret = 0.0f; float ret = 0.0f;
__asm__( __asm__(
@ -99,7 +99,7 @@ float sinf(float angle)
return ret; return ret;
} }
double pow(double x, double y) double pow(double x, double y) NOEXCEPT
{ {
// FIXME: Please fix me. I am naive. // FIXME: Please fix me. I am naive.
if (y == 0) if (y == 0)
@ -109,7 +109,7 @@ double pow(double x, double y)
int y_as_int = (int)y; int y_as_int = (int)y;
if (y == (double)y_as_int) { if (y == (double)y_as_int) {
double result = x; double result = x;
for (int i = 0; i < abs(y) - 1; ++i) for (int i = 0; i < fabs(y) - 1; ++i)
result *= x; result *= x;
if (y < 0) if (y < 0)
result = 1.0 / result; result = 1.0 / result;
@ -118,7 +118,7 @@ double pow(double x, double y)
return exp(y * log(x)); return exp(y * log(x));
} }
float powf(float x, float y) float powf(float x, float y) NOEXCEPT
{ {
// FIXME: Please fix me. I am naive. // FIXME: Please fix me. I am naive.
if (y == 0) if (y == 0)
@ -128,7 +128,7 @@ float powf(float x, float y)
int y_as_int = (int)y; int y_as_int = (int)y;
if (y == (float)y_as_int) { if (y == (float)y_as_int) {
float result = x; float result = x;
for (int i = 0; i < abs(y) - 1; ++i) for (int i = 0; i < fabs(y) - 1; ++i)
result *= x; result *= x;
if (y < 0) if (y < 0)
result = 1.0 / result; result = 1.0 / result;
@ -137,14 +137,14 @@ float powf(float x, float y)
return (float)exp((double)y * log((double)x)); return (float)exp((double)y * log((double)x));
} }
double ldexp(double x, int exp) double ldexp(double x, int exp) NOEXCEPT
{ {
// FIXME: Please fix me. I am naive. // FIXME: Please fix me. I am naive.
double val = pow(2, exp); double val = pow(2, exp);
return x * val; return x * val;
} }
double tanh(double x) double tanh(double x) NOEXCEPT
{ {
if (x > 0) { if (x > 0) {
double exponentiated = exp(2 * x); double exponentiated = exp(2 * x);
@ -155,7 +155,7 @@ double tanh(double x)
return (plusX - minusX) / (plusX + minusX); return (plusX - minusX) / (plusX + minusX);
} }
double ampsin(double angle) double ampsin(double angle) NOEXCEPT
{ {
double looped_angle = fmod(M_PI + angle, M_TAU) - M_PI; double looped_angle = fmod(M_PI + angle, M_TAU) - M_PI;
double looped_angle_squared = looped_angle * looped_angle; double looped_angle_squared = looped_angle * looped_angle;
@ -172,12 +172,12 @@ double ampsin(double angle)
return quadratic_term + linear_term; return quadratic_term + linear_term;
} }
double tan(double angle) double tan(double angle) NOEXCEPT
{ {
return ampsin(angle) / ampsin(M_PI_2 + angle); return ampsin(angle) / ampsin(M_PI_2 + angle);
} }
double sqrt(double x) double sqrt(double x) NOEXCEPT
{ {
double res; double res;
__asm__("fsqrt" __asm__("fsqrt"
@ -186,7 +186,7 @@ double sqrt(double x)
return res; return res;
} }
float sqrtf(float x) float sqrtf(float x) NOEXCEPT
{ {
float res; float res;
__asm__("fsqrt" __asm__("fsqrt"
@ -195,7 +195,7 @@ float sqrtf(float x)
return res; return res;
} }
double sinh(double x) double sinh(double x) NOEXCEPT
{ {
double exponentiated = exp(x); double exponentiated = exp(x);
if (x > 0) if (x > 0)
@ -203,12 +203,12 @@ double sinh(double x)
return (exponentiated - 1 / exponentiated) / 2; return (exponentiated - 1 / exponentiated) / 2;
} }
double log10(double x) double log10(double x) NOEXCEPT
{ {
return log(x) / M_LN10; return log(x) / M_LN10;
} }
double log(double x) double log(double x) NOEXCEPT
{ {
if (x < 0) if (x < 0)
return NAN; return NAN;
@ -223,22 +223,22 @@ double log(double x)
return y + 2 * (x - exponentiated) / (x + exponentiated); return y + 2 * (x - exponentiated) / (x + exponentiated);
} }
float logf(float x) float logf(float x) NOEXCEPT
{ {
return (float)log(x); return (float)log(x);
} }
double fmod(double index, double period) double fmod(double index, double period) NOEXCEPT
{ {
return index - trunc(index / period) * period; return index - trunc(index / period) * period;
} }
float fmodf(float index, float period) float fmodf(float index, float period) NOEXCEPT
{ {
return index - trunc(index / period) * period; return index - trunc(index / period) * period;
} }
double exp(double exponent) double exp(double exponent) NOEXCEPT
{ {
double result = 1; double result = 1;
if (exponent >= 1) { if (exponent >= 1) {
@ -274,22 +274,22 @@ double exp(double exponent)
return result * taylor_series_result; return result * taylor_series_result;
} }
float expf(float exponent) float expf(float exponent) NOEXCEPT
{ {
return (float)exp(exponent); return (float)exp(exponent);
} }
double exp2(double exponent) double exp2(double exponent) NOEXCEPT
{ {
return pow(2.0, exponent); return pow(2.0, exponent);
} }
float exp2f(float exponent) float exp2f(float exponent) NOEXCEPT
{ {
return pow(2.0f, exponent); return pow(2.0f, exponent);
} }
double cosh(double x) double cosh(double x) NOEXCEPT
{ {
double exponentiated = exp(-x); double exponentiated = exp(-x);
if (x < 0) if (x < 0)
@ -297,7 +297,7 @@ double cosh(double x)
return (1 / exponentiated + exponentiated) / 2; return (1 / exponentiated + exponentiated) / 2;
} }
double atan2(double y, double x) double atan2(double y, double x) NOEXCEPT
{ {
if (x > 0) if (x > 0)
return atan(y / x); return atan(y / x);
@ -313,12 +313,12 @@ double atan2(double y, double x)
return atan(y / x) - M_PI; return atan(y / x) - M_PI;
} }
float atan2f(float y, float x) float atan2f(float y, float x) NOEXCEPT
{ {
return (float)atan2(y, x); return (float)atan2(y, x);
} }
double atan(double x) double atan(double x) NOEXCEPT
{ {
if (x < 0) if (x < 0)
return -atan(-x); return -atan(-x);
@ -328,7 +328,7 @@ double atan(double x)
return x / (1 + 1 * 1 * squared / (3 + 2 * 2 * squared / (5 + 3 * 3 * squared / (7 + 4 * 4 * squared / (9 + 5 * 5 * squared / (11 + 6 * 6 * squared / (13 + 7 * 7 * squared))))))); return x / (1 + 1 * 1 * squared / (3 + 2 * 2 * squared / (5 + 3 * 3 * squared / (7 + 4 * 4 * squared / (9 + 5 * 5 * squared / (11 + 6 * 6 * squared / (13 + 7 * 7 * squared)))))));
} }
double asin(double x) double asin(double x) NOEXCEPT
{ {
if (x > 1 || x < -1) if (x > 1 || x < -1)
return NAN; return NAN;
@ -351,60 +351,60 @@ double asin(double x)
return value; return value;
} }
float asinf(float x) float asinf(float x) NOEXCEPT
{ {
return (float)asin(x); return (float)asin(x);
} }
double acos(double x) double acos(double x) NOEXCEPT
{ {
return M_PI_2 - asin(x); return M_PI_2 - asin(x);
} }
float acosf(float x) float acosf(float x) NOEXCEPT
{ {
return M_PI_2 - asinf(x); return M_PI_2 - asinf(x);
} }
double fabs(double value) double fabs(double value) NOEXCEPT
{ {
return value < 0 ? -value : value; return value < 0 ? -value : value;
} }
double log2(double x) double log2(double x) NOEXCEPT
{ {
return log(x) / M_LN2; return log(x) / M_LN2;
} }
float log2f(float x) float log2f(float x) NOEXCEPT
{ {
return log2(x); return log2(x);
} }
long double log2l(long double x) long double log2l(long double x) NOEXCEPT
{ {
return log2(x); return log2(x);
} }
double frexp(double, int*) double frexp(double, int*) NOEXCEPT
{ {
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
return 0; return 0;
} }
float frexpf(float, int*) float frexpf(float, int*) NOEXCEPT
{ {
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
return 0; return 0;
} }
long double frexpl(long double, int*) long double frexpl(long double, int*) NOEXCEPT
{ {
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
return 0; return 0;
} }
double round(double value) double round(double value) NOEXCEPT
{ {
// FIXME: Please fix me. I am naive. // FIXME: Please fix me. I am naive.
if (value >= 0.0) if (value >= 0.0)
@ -412,7 +412,7 @@ double round(double value)
return (double)(int)(value - 0.5); return (double)(int)(value - 0.5);
} }
float roundf(float value) float roundf(float value) NOEXCEPT
{ {
// FIXME: Please fix me. I am naive. // FIXME: Please fix me. I am naive.
if (value >= 0.0f) if (value >= 0.0f)
@ -420,7 +420,7 @@ float roundf(float value)
return (float)(int)(value - 0.5f); return (float)(int)(value - 0.5f);
} }
float floorf(float value) float floorf(float value) NOEXCEPT
{ {
if (value >= 0) if (value >= 0)
return (int)value; return (int)value;
@ -428,7 +428,7 @@ float floorf(float value)
return ((float)intvalue == value) ? intvalue : intvalue - 1; return ((float)intvalue == value) ? intvalue : intvalue - 1;
} }
double floor(double value) double floor(double value) NOEXCEPT
{ {
if (value >= 0) if (value >= 0)
return (int)value; return (int)value;
@ -436,12 +436,12 @@ double floor(double value)
return ((double)intvalue == value) ? intvalue : intvalue - 1; return ((double)intvalue == value) ? intvalue : intvalue - 1;
} }
double rint(double value) double rint(double value) NOEXCEPT
{ {
return (int)roundf(value); return (int)roundf(value);
} }
float ceilf(float value) float ceilf(float value) NOEXCEPT
{ {
// FIXME: Please fix me. I am naive. // FIXME: Please fix me. I am naive.
int as_int = (int)value; int as_int = (int)value;
@ -455,7 +455,7 @@ float ceilf(float value)
return as_int + 1; return as_int + 1;
} }
double ceil(double value) double ceil(double value) NOEXCEPT
{ {
// FIXME: Please fix me. I am naive. // FIXME: Please fix me. I am naive.
int as_int = (int)value; int as_int = (int)value;
@ -469,24 +469,24 @@ double ceil(double value)
return as_int + 1; return as_int + 1;
} }
double modf(double x, double* intpart) double modf(double x, double* intpart) NOEXCEPT
{ {
*intpart = (double)((int)(x)); *intpart = (double)((int)(x));
return x - (int)x; return x - (int)x;
} }
double gamma(double x) double gamma(double x) NOEXCEPT
{ {
// Stirling approximation // Stirling approximation
return sqrt(2.0 * M_PI / x) * pow(x / M_E, x); return sqrt(2.0 * M_PI / x) * pow(x / M_E, x);
} }
double expm1(double x) double expm1(double x) NOEXCEPT
{ {
return pow(M_E, x) - 1; return pow(M_E, x) - 1;
} }
double cbrt(double x) double cbrt(double x) NOEXCEPT
{ {
if (x > 0) { if (x > 0) {
return pow(x, 1.0 / 3.0); return pow(x, 1.0 / 3.0);
@ -495,35 +495,35 @@ double cbrt(double x)
return -pow(-x, 1.0 / 3.0); return -pow(-x, 1.0 / 3.0);
} }
double log1p(double x) double log1p(double x) NOEXCEPT
{ {
return log(1 + x); return log(1 + x);
} }
double acosh(double x) double acosh(double x) NOEXCEPT
{ {
return log(x + sqrt(x * x - 1)); return log(x + sqrt(x * x - 1));
} }
double asinh(double x) double asinh(double x) NOEXCEPT
{ {
return log(x + sqrt(x * x + 1)); return log(x + sqrt(x * x + 1));
} }
double atanh(double x) double atanh(double x) NOEXCEPT
{ {
return log((1 + x) / (1 - x)) / 2.0; return log((1 + x) / (1 - x)) / 2.0;
} }
double hypot(double x, double y) double hypot(double x, double y) NOEXCEPT
{ {
return sqrt(x * x + y * y); return sqrt(x * x + y * y);
} }
double erf(double x) double erf(double x) NOEXCEPT
{ {
// algorithm taken from Abramowitz and Stegun (no. 26.2.17) // algorithm taken from Abramowitz and Stegun (no. 26.2.17)
double t = 1 / (1 + 0.47047 * abs(x)); double t = 1 / (1 + 0.47047 * fabs(x));
double poly = t * (0.3480242 + t * (-0.958798 + t * 0.7478556)); double poly = t * (0.3480242 + t * (-0.958798 + t * 0.7478556));
double answer = 1 - poly * exp(-x * x); double answer = 1 - poly * exp(-x * x);
if (x < 0) if (x < 0)
@ -532,15 +532,9 @@ double erf(double x)
return answer; return answer;
} }
double erfc(double x) double erfc(double x) NOEXCEPT
{ {
return 1 - erf(x); return 1 - erf(x);
} }
int isnormal(double x)
{
if (x < 0)
x = -x;
return x >= DOUBLE_MIN && x <= DOUBLE_MAX;
}
} }

136
Libraries/LibM/math.h
View file

@ -28,6 +28,12 @@
#include <sys/cdefs.h> #include <sys/cdefs.h>
#if __cplusplus >= 201103L
#define NOEXCEPT noexcept
#else
#define NOEXCEPT
#endif
__BEGIN_DECLS __BEGIN_DECLS
#define HUGE_VAL 1e10000 #define HUGE_VAL 1e10000
@ -47,74 +53,72 @@ __BEGIN_DECLS
#define DOUBLE_MAX ((double)0b0111111111101111111111111111111111111111111111111111111111111111) #define DOUBLE_MAX ((double)0b0111111111101111111111111111111111111111111111111111111111111111)
#define DOUBLE_MIN ((double)0b0000000000010000000000000000000000000000000000000000000000000000) #define DOUBLE_MIN ((double)0b0000000000010000000000000000000000000000000000000000000000000000)
double acos(double); double acos(double) NOEXCEPT;
float acosf(float); float acosf(float) NOEXCEPT;
double asin(double); double asin(double) NOEXCEPT;
float asinf(float); float asinf(float) NOEXCEPT;
double atan(double); double atan(double) NOEXCEPT;
float atanf(float); float atanf(float) NOEXCEPT;
double atan2(double, double); double atan2(double, double) NOEXCEPT;
float atan2f(float, float); float atan2f(float, float) NOEXCEPT;
double cos(double); double cos(double) NOEXCEPT;
float cosf(float); float cosf(float) NOEXCEPT;
double cosh(double); double cosh(double) NOEXCEPT;
float coshf(float); float coshf(float) NOEXCEPT;
double sin(double); double sin(double) NOEXCEPT;
float sinf(float); float sinf(float) NOEXCEPT;
double sinh(double); double sinh(double) NOEXCEPT;
float sinhf(float); float sinhf(float) NOEXCEPT;
double tan(double); double tan(double) NOEXCEPT;
float tanf(float); float tanf(float) NOEXCEPT;
double tanh(double); double tanh(double) NOEXCEPT;
float tanhf(float); float tanhf(float) NOEXCEPT;
double ceil(double); double ceil(double) NOEXCEPT;
float ceilf(float); float ceilf(float) NOEXCEPT;
double floor(double); double floor(double) NOEXCEPT;
float floorf(float); float floorf(float) NOEXCEPT;
double round(double); double round(double) NOEXCEPT;
float roundf(float); float roundf(float) NOEXCEPT;
double fabs(double); double fabs(double) NOEXCEPT;
float fabsf(float); float fabsf(float) NOEXCEPT;
double fmod(double, double); double fmod(double, double) NOEXCEPT;
float fmodf(float, float); float fmodf(float, float) NOEXCEPT;
double exp(double); double exp(double) NOEXCEPT;
float expf(float); float expf(float) NOEXCEPT;
double exp2(double); double exp2(double) NOEXCEPT;
float exp2f(float); float exp2f(float) NOEXCEPT;
double frexp(double, int* exp); double frexp(double, int* exp) NOEXCEPT;
float frexpf(float, int* exp); float frexpf(float, int* exp) NOEXCEPT;
double log(double); double log(double) NOEXCEPT;
float logf(float); float logf(float) NOEXCEPT;
double log10(double); double log10(double) NOEXCEPT;
float log10f(float); float log10f(float) NOEXCEPT;
double sqrt(double); double sqrt(double) NOEXCEPT;
float sqrtf(float); float sqrtf(float) NOEXCEPT;
double modf(double, double*); double modf(double, double*) NOEXCEPT;
float modff(float, float*); float modff(float, float*) NOEXCEPT;
double ldexp(double, int exp); double ldexp(double, int exp) NOEXCEPT;
float ldexpf(float, int exp); float ldexpf(float, int exp) NOEXCEPT;
double pow(double x, double y); double pow(double x, double y) NOEXCEPT;
float powf(float x, float y); float powf(float x, float y) NOEXCEPT;
double log2(double); double log2(double) NOEXCEPT;
float log2f(float); float log2f(float) NOEXCEPT;
long double log2l(long double); long double log2l(long double) NOEXCEPT;
double frexp(double, int*); double frexp(double, int*) NOEXCEPT;
float frexpf(float, int*); float frexpf(float, int*) NOEXCEPT;
long double frexpl(long double, int*); long double frexpl(long double, int*) NOEXCEPT;
double gamma(double); double gamma(double) NOEXCEPT;
double expm1(double); double expm1(double) NOEXCEPT;
double cbrt(double); double cbrt(double) NOEXCEPT;
double log1p(double); double log1p(double) NOEXCEPT;
double acosh(double); double acosh(double) NOEXCEPT;
double asinh(double); double asinh(double) NOEXCEPT;
double atanh(double); double atanh(double) NOEXCEPT;
double hypot(double, double); double hypot(double, double) NOEXCEPT;
double erf(double); double erf(double) NOEXCEPT;
double erfc(double); double erfc(double) NOEXCEPT;
int isnormal(double);
__END_DECLS __END_DECLS