343 lines
15 KiB
C
343 lines
15 KiB
C
/*
|
|
* vlibc — math.h todo-39 consolidated final test: slices S1..S4.
|
|
*
|
|
* One pass over every implemented todo-39 family, in all three
|
|
* precisions, as a final smoke of the whole arithmetic slice:
|
|
*
|
|
* S1 fabs/fabsf/fabsl, copysign, floor, ceil, trunc
|
|
* S2 round, rint, nearbyint, lrint, llrint, ilogb, logb
|
|
* S3 frexp, ldexp, modf, scalbn, scalbln
|
|
* S4 fmin, fmax, fdim, lround, llround, fmod, remainder, remquo
|
|
*
|
|
* Expected values follow IEEE 754-2008 / C23 semantics by hand and, for
|
|
* the S4 families, the byte-exact host glibc 2.44 behavior that the
|
|
* differential probe checks (the remquo quotient rows, in particular, are
|
|
* glibc's tracked-low-bits values, e.g. remquo(100.0, 3.0) reports 1, the
|
|
* low quotient bits, not 33). Inputs travel through volatile objects so
|
|
* the compiler cannot constant-fold the calls away; diagnostics go
|
|
* through raw SYS_write and no host headers are included.
|
|
*/
|
|
|
|
#include <math.h>
|
|
|
|
#include "../src/internal/syscall.h"
|
|
|
|
/* Write a NUL-terminated string to fd via the raw syscall layer. */
|
|
static __attribute__((optimize("no-tree-loop-distribute-patterns"))) void
|
|
say(int fd, const char *s)
|
|
{
|
|
long n = 0;
|
|
|
|
while (s[n] != '\0')
|
|
{
|
|
n++;
|
|
}
|
|
__syscall3(SYS_write, fd, (long)s, n);
|
|
}
|
|
|
|
static int failures;
|
|
|
|
static void
|
|
check(int ok, const char *msg)
|
|
{
|
|
if (ok)
|
|
{
|
|
say(1, "ok ");
|
|
}
|
|
else
|
|
{
|
|
say(1, "FAIL ");
|
|
failures++;
|
|
}
|
|
say(1, msg);
|
|
say(1, "\n");
|
|
}
|
|
|
|
/* S1: fabs, copysign, floor, ceil, trunc. */
|
|
static void
|
|
s1_scenario(void)
|
|
{
|
|
volatile double negzero = -0.0;
|
|
volatile double nan = NAN;
|
|
volatile double big = 1e300;
|
|
volatile float nanf = NAN;
|
|
volatile long double nanl = NAN;
|
|
|
|
check(fabs(-3.5) == 3.5, "fabs(-3.5) == 3.5");
|
|
check(fabs(negzero) == 0.0 && !signbit(fabs(negzero)), "fabs(-0.0) == +0.0");
|
|
check(fabs(nan) != nan, "fabs(NaN) is NaN");
|
|
check(copysign(3.0, -1.0) == -3.0, "copysign(3,-1) == -3");
|
|
check(copysign(-3.0, 1.0) == 3.0, "copysign(-3,1) == 3");
|
|
check(copysign(negzero, 1.0) == 0.0 && !signbit(copysign(negzero, 1.0)),
|
|
"copysign(-0,+1) == +0");
|
|
check(floor(3.7) == 3.0, "floor(3.7) == 3");
|
|
check(floor(-3.7) == -4.0, "floor(-3.7) == -4");
|
|
check(floor(negzero) == 0.0 && signbit(floor(negzero)), "floor(-0.0) == -0.0");
|
|
check(ceil(3.2) == 4.0, "ceil(3.2) == 4");
|
|
check(ceil(-3.2) == -3.0, "ceil(-3.2) == -3");
|
|
check(trunc(3.7) == 3.0, "trunc(3.7) == 3");
|
|
check(trunc(-3.7) == -3.0, "trunc(-3.7) == -3");
|
|
check(fabsf(-2.5f) == 2.5f, "fabsf(-2.5f) == 2.5f");
|
|
check(fabsf(nanf) != nanf, "fabsf(NaN) is NaN");
|
|
check(copysignf(1.0f, -0.0f) == -1.0f, "copysignf(1,-0) == -1");
|
|
check(floorf(2.9f) == 2.0f, "floorf(2.9f) == 2");
|
|
check(ceilf(-2.1f) == -2.0f, "ceilf(-2.1f) == -2");
|
|
check(truncf(2.9f) == 2.0f, "truncf(2.9f) == 2");
|
|
check(fabsl(-3.5L) == 3.5L, "fabsl(-3.5L) == 3.5L");
|
|
check(fabsl(nanl) != nanl, "fabsl(NaN) is NaN");
|
|
check(copysignl(-4.0L, -2.0L) == -4.0L, "copysignl(-4,-2) == -4");
|
|
check(floorl(-3.7L) == -4.0L, "floorl(-3.7L) == -4");
|
|
check(ceill(3.2L) == 4.0L, "ceill(3.2L) == 4");
|
|
check(truncl(-3.7L) == -3.0L, "truncl(-3.7L) == -3");
|
|
check(floor(big) == big, "floor(1e300) == 1e300");
|
|
}
|
|
|
|
/* S2: round, rint, nearbyint, lrint, llrint, ilogb, logb. */
|
|
static void
|
|
s2_scenario(void)
|
|
{
|
|
volatile double negzero = -0.0;
|
|
volatile double nan = NAN;
|
|
volatile double sub = 0x1p-1074;
|
|
volatile double two40 = 0x1p40;
|
|
|
|
check(round(0.5) == 1.0, "round(0.5) == 1");
|
|
check(round(-0.5) == -1.0, "round(-0.5) == -1");
|
|
check(round(2.5) == 3.0, "round(2.5) == 3");
|
|
check(round(negzero) == 0.0 && signbit(round(negzero)), "round(-0.0) == -0.0");
|
|
check(round(sub) == 0.0 && !signbit(round(sub)), "round(5e-324) == +0");
|
|
check(isnan(round(nan)), "round(NaN) is NaN");
|
|
check(rint(0.5) == 0.0, "rint(0.5) == 0 (ties to even)");
|
|
check(rint(2.5) == 2.0, "rint(2.5) == 2 (ties to even)");
|
|
check(rint(negzero) == 0.0 && signbit(rint(negzero)), "rint(-0.0) == -0.0");
|
|
check(nearbyint(2.5) == 2.0, "nearbyint(2.5) == 2 (ties to even)");
|
|
check(nearbyint(1.5) == 2.0, "nearbyint(1.5) == 2");
|
|
check(lrint(2.5) == 2L, "lrint(2.5) == 2");
|
|
check(lrint(two40) == 1099511627776L, "lrint(2^40) == 2^40");
|
|
check(llrint(-2.5) == -2LL, "llrint(-2.5) == -2");
|
|
check(llrint(1.5) == 2LL, "llrint(1.5) == 2");
|
|
check(ilogb(8.0) == 3, "ilogb(8) == 3");
|
|
check(ilogb(0.5) == -1, "ilogb(0.5) == -1");
|
|
check(ilogb(sub) == -1074, "ilogb(min subnormal) == -1074");
|
|
check(ilogb(0.0) == FP_ILOGB0, "ilogb(0.0) == FP_ILOGB0");
|
|
check(logb(8.0) == 3.0, "logb(8) == 3");
|
|
check(logb(0.5) == -1.0, "logb(0.5) == -1");
|
|
check(logb(0.0) == -HUGE_VAL, "logb(0.0) == -Inf");
|
|
check(roundf(-0.5f) == -1.0f, "roundf(-0.5f) == -1");
|
|
check(rintf(2.5f) == 2.0f, "rintf(2.5f) == 2 (ties to even)");
|
|
check(nearbyintf(-2.5f) == -2.0f, "nearbyintf(-2.5f) == -2");
|
|
check(lrintf(1.5f) == 2L, "lrintf(1.5f) == 2");
|
|
check(llrintf(2.5f) == 2LL, "llrintf(2.5f) == 2");
|
|
check(ilogbf(0x1p-149f) == -149, "ilogbf(min subnormal) == -149");
|
|
check(logbf(8.0f) == 3.0f, "logbf(8) == 3");
|
|
check(roundl(2.5L) == 3.0L, "roundl(2.5L) == 3");
|
|
check(rintl(-0.5L) == 0.0L && signbit(rintl(-0.5L)), "rintl(-0.5L) == -0.0L");
|
|
check(nearbyintl(1.5L) == 2.0L, "nearbyintl(1.5L) == 2");
|
|
check(lrintl(2.5L) == 2L, "lrintl(2.5L) == 2");
|
|
check(llrintl(-2.5L) == -2LL, "llrintl(-2.5L) == -2");
|
|
check(ilogbl(0x1p-16445L) == -16445, "ilogbl(min subnormal) == -16445");
|
|
check(logbl(0.5L) == -1.0L, "logbl(0.5L) == -1");
|
|
}
|
|
|
|
/* S3: frexp, ldexp, modf, scalbn, scalbln. */
|
|
static void
|
|
s3_scenario(void)
|
|
{
|
|
volatile double negzero = -0.0;
|
|
int e;
|
|
double ip;
|
|
double fp;
|
|
float ipf;
|
|
float fpf;
|
|
long double ipl;
|
|
long double fpl;
|
|
|
|
check(frexp(8.0, &e) == 0.5 && e == 4, "frexp(8) == (0.5, 4)");
|
|
check(frexp(-6.0, &e) == -0.75 && e == 3, "frexp(-6) == (-0.75, 3)");
|
|
check(frexp(0.0, &e) == 0.0 && e == 0, "frexp(0) == (0, 0)");
|
|
check(frexp(negzero, &e) == 0.0 && e == 0, "frexp(-0) == (-0, 0)");
|
|
check(ldexp(1.0, 10) == 1024.0, "ldexp(1,10) == 1024");
|
|
check(ldexp(1.0, -1075) == 0.0, "ldexp(1,-1075) == +0");
|
|
check(scalbn(1.0, 10) == 1024.0, "scalbn(1,10) == 1024");
|
|
check(scalbln(1.0, 10L) == 1024.0, "scalbln(1,10) == 1024");
|
|
fp = modf(3.75, &ip);
|
|
check(ip == 3.0 && fp == 0.75, "modf(3.75) == (3, 0.75)");
|
|
fp = modf(-3.75, &ip);
|
|
check(ip == -3.0 && fp == -0.75, "modf(-3.75) == (-3, -0.75)");
|
|
check(frexpf(8.0f, &e) == 0.5f && e == 4, "frexpf(8) == (0.5, 4)");
|
|
check(ldexpf(1.0f, 10) == 1024.0f, "ldexpf(1,10) == 1024");
|
|
check(scalbnf(1.0f, -10) == 0.0009765625f, "scalbnf(1,-10) == 2^-10");
|
|
fpf = modff(3.75f, &ipf);
|
|
check(ipf == 3.0f && fpf == 0.75f, "modff(3.75f) == (3, 0.75)");
|
|
check(frexpl(8.0L, &e) == 0.5L && e == 4, "frexpl(8) == (0.5, 4)");
|
|
check(ldexpl(1.0L, 10) == 1024.0L, "ldexpl(1,10) == 1024");
|
|
check(scalbnl(1.0L, 10) == 1024.0L, "scalbnl(1,10) == 1024");
|
|
fpl = modfl(3.75L, &ipl);
|
|
check(ipl == 3.0L && fpl == 0.75L, "modfl(3.75L) == (3, 0.75)");
|
|
}
|
|
|
|
/* S4a: fmin, fmax, fdim, lround, llround. */
|
|
static void
|
|
s4_minmax_scenario(void)
|
|
{
|
|
volatile double negzero = -0.0;
|
|
volatile double nan = NAN;
|
|
volatile double inf = HUGE_VAL;
|
|
volatile float nanf = NAN;
|
|
volatile long double nanl = NAN;
|
|
volatile double big = 1e300;
|
|
volatile double huge = 1.7e308;
|
|
volatile float bigf = 1e30f;
|
|
|
|
check(fmin(3.0, 5.0) == 3.0, "fmin(3,5) == 3");
|
|
check(fmin(5.0, 3.0) == 3.0, "fmin(5,3) == 3");
|
|
check(fmin(3.0, 5.0) == 3.0, "fmin(3,5) == 3");
|
|
check(fmin(negzero, 0.0) == 0.0 && signbit(fmin(negzero, 0.0)), "fmin(-0,+0) == -0");
|
|
check(fmin(0.0, negzero) == 0.0 && signbit(fmin(0.0, negzero)), "fmin(+0,-0) == -0");
|
|
check(fmin(nan, 5.0) == 5.0, "fmin(NaN,5) == 5");
|
|
check(fmin(5.0, nan) == 5.0, "fmin(5,NaN) == 5");
|
|
check(isnan(fmin(nan, nan)), "fmin(NaN,NaN) is NaN");
|
|
check(fmax(3.0, 5.0) == 5.0, "fmax(3,5) == 5");
|
|
check(fmax(5.0, 3.0) == 5.0, "fmax(5,3) == 5");
|
|
check(fmax(negzero, 0.0) == 0.0 && !signbit(fmax(negzero, 0.0)), "fmax(-0,+0) == +0");
|
|
check(fmax(0.0, negzero) == 0.0 && !signbit(fmax(0.0, negzero)), "fmax(+0,-0) == +0");
|
|
check(fmax(nan, 5.0) == 5.0, "fmax(NaN,5) == 5");
|
|
check(fmax(5.0, nan) == 5.0, "fmax(5,NaN) == 5");
|
|
check(fmin(-inf, -5.0) == -inf, "fmin(-Inf,-5) == -Inf");
|
|
check(fmax(inf, 5.0) == inf, "fmax(+Inf,5) == +Inf");
|
|
check(fminf(3.0f, 5.0f) == 3.0f, "fminf(3,5) == 3");
|
|
check(fminf(nanf, 5.0f) == 5.0f, "fminf(NaN,5) == 5");
|
|
check(fmaxf(3.0f, 5.0f) == 5.0f, "fmaxf(3,5) == 5");
|
|
check(fminl(3.0L, 5.0L) == 3.0L, "fminl(3,5) == 3");
|
|
check(fminl(nanl, 5.0L) == 5.0L, "fminl(NaN,5) == 5");
|
|
check(fmaxl(3.0L, 5.0L) == 5.0L, "fmaxl(3,5) == 5");
|
|
check(fmaxl(nanl, 5.0L) == 5.0L, "fmaxl(NaN,5) == 5");
|
|
|
|
check(fdim(5.0, 3.0) == 2.0, "fdim(5,3) == 2");
|
|
check(fdim(3.0, 5.0) == 0.0 && !signbit(fdim(3.0, 5.0)), "fdim(3,5) == +0");
|
|
check(fdim(3.0, 3.0) == 0.0, "fdim(3,3) == +0");
|
|
check(fdim(inf, -inf) == inf, "fdim(+Inf,-Inf) == +Inf");
|
|
check(isnan(fdim(nan, 5.0)), "fdim(NaN,5) is NaN");
|
|
check(isnan(fdim(5.0, nan)), "fdim(5,NaN) is NaN");
|
|
check(fdim(big, -big) == 2.0 * big, "fdim(1e300,-1e300) == 2e300");
|
|
check(fdim(huge, -huge) == inf, "fdim(1.7e308,-1.7e308) == +Inf");
|
|
check(fdimf(5.0f, 3.0f) == 2.0f, "fdimf(5,3) == 2");
|
|
check(fdimf(3.0f, 5.0f) == 0.0f, "fdimf(3,5) == +0");
|
|
check(fdiml(5.0L, 3.0L) == 2.0L, "fdiml(5,3) == 2");
|
|
check(fdiml(3.0L, 5.0L) == 0.0L, "fdiml(3,5) == +0");
|
|
|
|
check(lround(0.5) == 1L, "lround(0.5) == 1");
|
|
check(lround(-0.5) == -1L, "lround(-0.5) == -1");
|
|
check(lround(2.5) == 3L, "lround(2.5) == 3");
|
|
check(lround(-2.5) == -3L, "lround(-2.5) == -3");
|
|
check(lround(big) == LONG_MIN, "lround(1e300) == LONG_MIN");
|
|
check(lround(-big) == LONG_MIN, "lround(-1e300) == LONG_MIN");
|
|
check(lroundf(2.5f) == 3L, "lroundf(2.5f) == 3");
|
|
check(lroundf(bigf) == LONG_MIN, "lroundf(1e30f) == LONG_MIN");
|
|
check(lroundl(2.5L) == 3L, "lroundl(2.5L) == 3");
|
|
check(llround(0.5) == 1LL, "llround(0.5) == 1");
|
|
check(llround(-0.5) == -1LL, "llround(-0.5) == -1");
|
|
check(llround(2.5) == 3LL, "llround(2.5) == 3");
|
|
check(llround(big) == LLONG_MIN, "llround(1e300) == LLONG_MIN");
|
|
check(llround(nan) == LLONG_MIN, "llround(NaN) == LLONG_MIN");
|
|
check(llroundf(2.5f) == 3LL, "llroundf(2.5f) == 3");
|
|
check(llroundl(2.5L) == 3LL, "llroundl(2.5L) == 3");
|
|
}
|
|
|
|
/* S4b: fmod, remainder, remquo (glibc-verified rows). */
|
|
static void
|
|
s4_rem_scenario(void)
|
|
{
|
|
volatile double negzero = -0.0;
|
|
volatile double nan = NAN;
|
|
volatile double inf = HUGE_VAL;
|
|
volatile float nanf = NAN;
|
|
volatile long double nanl = NAN;
|
|
volatile double a100 = 100.0;
|
|
volatile double a34 = 34.0;
|
|
volatile double a40 = 40.0;
|
|
volatile double a3 = 3.0;
|
|
volatile double a5 = 5.0;
|
|
volatile float f100 = 100.0f;
|
|
volatile long double l100 = 100.0L;
|
|
volatile long double l40 = 40.0L;
|
|
int q;
|
|
|
|
check(fmod(5.0, 3.0) == 2.0, "fmod(5,3) == 2");
|
|
check(fmod(-5.0, 3.0) == -2.0, "fmod(-5,3) == -2");
|
|
check(fmod(5.0, -3.0) == 2.0, "fmod(5,-3) == 2");
|
|
check(fmod(-5.0, -3.0) == -2.0, "fmod(-5,-3) == -2");
|
|
check(fmod(6.0, 3.0) == 0.0 && !signbit(fmod(6.0, 3.0)), "fmod(6,3) == +0");
|
|
check(fmod(-6.0, 3.0) == 0.0 && signbit(fmod(-6.0, 3.0)), "fmod(-6,3) == -0");
|
|
check(fmod(3.0, 5.0) == 3.0, "fmod(3,5) == 3");
|
|
check(fmod(negzero, 5.0) == 0.0 && signbit(fmod(negzero, 5.0)), "fmod(-0,5) == -0");
|
|
check(fmod(5.0, inf) == 5.0, "fmod(5,+Inf) == 5");
|
|
check(isnan(fmod(5.0, 0.0)), "fmod(5,0) is NaN");
|
|
check(isnan(fmod(inf, 3.0)), "fmod(+Inf,3) is NaN");
|
|
check(isnan(fmod(nan, 3.0)), "fmod(NaN,3) is NaN");
|
|
check(fmodf(5.0f, 3.0f) == 2.0f, "fmodf(5,3) == 2");
|
|
check(fmodf(-5.0f, 3.0f) == -2.0f, "fmodf(-5,3) == -2");
|
|
check(fmodf(5.0f, 0.0f) != 0 && !(fmodf(5.0f, 0.0f) == fmodf(5.0f, 0.0f)), "fmodf(5,0) is NaN");
|
|
check(isnan(fmodf(nanf, 3.0f)), "fmodf(NaN,3) is NaN");
|
|
check(fmodl(5.0L, 3.0L) == 2.0L, "fmodl(5,3) == 2");
|
|
check(fmodl(-5.0L, 3.0L) == -2.0L, "fmodl(-5,3) == -2");
|
|
check(fmodl(5.0L, 0.0L) != fmodl(5.0L, 0.0L), "fmodl(5,0) is NaN");
|
|
check(isnan(fmodl(nanl, 3.0L)), "fmodl(NaN,3) is NaN");
|
|
|
|
check(remainder(5.0, 3.0) == -1.0, "remainder(5,3) == -1");
|
|
check(remainder(5.0, 2.0) == 1.0, "remainder(5,2) == 1");
|
|
check(remainder(6.0, 4.0) == -2.0, "remainder(6,4) == -2");
|
|
check(remainder(7.0, 4.0) == -1.0, "remainder(7,4) == -1");
|
|
check(remainder(5.0, 5.0) == 0.0, "remainder(5,5) == +0");
|
|
check(remainder(-5.0, 3.0) == 1.0, "remainder(-5,3) == 1");
|
|
check(remainder(5.0, -3.0) == -1.0, "remainder(5,-3) == -1");
|
|
check(isnan(remainder(5.0, 0.0)), "remainder(5,0) is NaN");
|
|
check(isnan(remainder(inf, 3.0)), "remainder(+Inf,3) is NaN");
|
|
check(isnan(remainder(nan, 3.0)), "remainder(NaN,3) is NaN");
|
|
check(remainderf(5.0f, 3.0f) == -1.0f, "remainderf(5,3) == -1");
|
|
check(isnan(remainderf(5.0f, 0.0f)), "remainderf(5,0) is NaN");
|
|
check(remainderl(5.0L, 3.0L) == -1.0L, "remainderl(5,3) == -1");
|
|
check(isnan(remainderl(5.0L, 0.0L)), "remainderl(5,0) is NaN");
|
|
check(remainderl(-5.0L, 3.0L) == 1.0L, "remainderl(-5,3) == 1");
|
|
|
|
check(remquo(5.0, 3.0, &q) == -1.0 && q == 2, "remquo(5,3): r=-1 q=2");
|
|
check(remquo(-5.0, 3.0, &q) == 1.0 && q == -2, "remquo(-5,3): r=1 q=-2");
|
|
check(remquo(5.0, -3.0, &q) == -1.0 && q == -2, "remquo(5,-3): r=-1 q=-2");
|
|
check(remquo(a100, a3, &q) == 1.0 && q == 1, "remquo(100,3): r=1 q=1");
|
|
check(remquo(a34, a3, &q) == 1.0 && q == 3, "remquo(34,3): r=1 q=3");
|
|
check(remquo(a40, a3, &q) == 1.0 && q == 5, "remquo(40,3): r=1 q=5");
|
|
check(remquo(7.0, 2.0, &q) == -1.0 && q == 4, "remquo(7,2): r=-1 q=4");
|
|
check(remquo(6.0, 3.0, &q) == 0.0 && q == 2, "remquo(6,3): r=0 q=2");
|
|
check(remquo(2.0, 3.0, &q) == -1.0 && q == 1, "remquo(2,3): r=-1 q=1");
|
|
check(remquo(1.0, 3.0, &q) == 1.0 && q == 0, "remquo(1,3): r=1 q=0");
|
|
check(remquo(a5, a5, &q) == 0.0 && q == 1, "remquo(5,5): r=0 q=1");
|
|
check(isnan(remquo(a5, 0.0, &q)), "remquo(5,0) is NaN");
|
|
check(isnan(remquo(inf, a3, &q)), "remquo(+Inf,3) is NaN");
|
|
check(remquof(f100, 3.0f, &q) == 1.0f && q == 1, "remquof(100,3): q=1");
|
|
check(remquof(5.0f, 3.0f, &q) == -1.0f && q == 2, "remquof(5,3): q=2");
|
|
check(remquol(l100, 3.0L, &q) == 1.0L && q == 1, "remquol(100,3): q=1");
|
|
check(remquol(5.0L, 3.0L, &q) == -1.0L && q == 2, "remquol(5,3): q=2");
|
|
check(remquol(l40, 3.0L, &q) == 1.0L && q == 5, "remquol(40,3): q=5");
|
|
check(isnan(remquol(nanl, 3.0L, &q)), "remquol(NaN,3) is NaN");
|
|
}
|
|
|
|
int
|
|
main(void)
|
|
{
|
|
s1_scenario();
|
|
s2_scenario();
|
|
s3_scenario();
|
|
s4_minmax_scenario();
|
|
s4_rem_scenario();
|
|
|
|
if (failures == 0)
|
|
{
|
|
say(1, "all math todo-39 (S1-S4) tests passed\n");
|
|
}
|
|
else
|
|
{
|
|
say(1, "FAILURES\n");
|
|
}
|
|
return failures == 0 ? 0 : 1;
|
|
}
|