265 lines
10 KiB
C
265 lines
10 KiB
C
/*
|
|
* vlibc — math.h slice S1 test: fabs/copysign/floor/ceil/trunc (todo 39).
|
|
*
|
|
* Exercises every implemented family in all three precisions plus the
|
|
* <math.h> classification macros and the <tgmath.h> generic dispatch:
|
|
*
|
|
* 1. fabs/fabsf/fabsl of ±1.5 and of ±0.0 (signed-zero flattening);
|
|
* 2. copysign/copysignf/copysignl sign transfer, including from ±0.0
|
|
* and onto a NaN;
|
|
* 3. floor across the sign boundary: floor(-0.5) == -1.0, floor(+0.5)
|
|
* == +0.0, integers and ±0 pass through, and the subnormal
|
|
* floor(5e-324) == 0.0 / floor(-5e-324) == -1.0;
|
|
* 4. ceil with the real negative zero: ceil(-0.5) == -0.0 with signbit
|
|
* set, ceil(+0.5) == 1.0;
|
|
* 5. trunc toward zero: trunc(-1.7) == -1.0, trunc(1.7) == 1.0,
|
|
* trunc(-0.7) == -0.0 (signbit set);
|
|
* 6. NaN and ±Inf passthrough for all three rounding functions and the
|
|
* boundary mantissa-clearing paths (values whose integer part fills
|
|
* the whole significand minus one bit);
|
|
* 7. classification macros (fpclassify/isnan/isinf/isfinite/isnormal/
|
|
* signbit) over the FP_* constants.
|
|
*
|
|
* Values that must survive exactly are fed through volatile objects so the
|
|
* compiler cannot constant-fold the call away and the real library
|
|
* functions run. No host headers are included (-Iinclude shadows GCC's);
|
|
* diagnostics go through raw SYS_write, and errno is never read (vlibc's
|
|
* errno slot collides with the host TCB in this host-linked standalone
|
|
* binary).
|
|
*/
|
|
|
|
#include <math.h>
|
|
#include <tgmath.h>
|
|
|
|
#include "../src/internal/syscall.h"
|
|
|
|
/* Write a NUL-terminated string to fd via the raw syscall layer. The
|
|
* optimize attribute keeps GCC from lowering the length loop into a
|
|
* strlen call, which would leave a vlibc-owned symbol undefined in this
|
|
* host-linked standalone binary (house idiom, see src/string). */
|
|
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");
|
|
}
|
|
|
|
/* 1. fabs family: magnitude of positive and negative inputs. */
|
|
static void
|
|
fabs_scenario(void)
|
|
{
|
|
volatile float xf = -1.5f;
|
|
volatile double xd = -1.5;
|
|
volatile long double xl = -1.5L;
|
|
volatile float zf = -0.0f;
|
|
volatile double zd = -0.0;
|
|
|
|
check(fabsf(xf) == 1.5f, "fabsf(-1.5f) == 1.5f");
|
|
check(fabs(xd) == 1.5, "fabs(-1.5) == 1.5");
|
|
check(fabsl(xl) == 1.5L, "fabsl(-1.5L) == 1.5L");
|
|
check(fabsf(1.5f) == 1.5f, "fabsf(+1.5f) == 1.5f");
|
|
check(fabs(1.5) == 1.5, "fabs(+1.5) == 1.5");
|
|
check(fabsl(1.5L) == 1.5L, "fabsl(+1.5L) == 1.5L");
|
|
check(fabsf(zf) == 0.0f && !signbit(fabsf(zf)), "fabsf(-0.0f) is +0.0");
|
|
check(fabs(zd) == 0.0 && !signbit(fabs(zd)), "fabs(-0.0) is +0.0");
|
|
}
|
|
|
|
/* 2. copysign family: sign follows y, including y == ±0.0 and NaN x. */
|
|
static void
|
|
copysign_scenario(void)
|
|
{
|
|
volatile double negzero = -0.0;
|
|
volatile double poszero = 0.0;
|
|
volatile double nan = NAN;
|
|
|
|
check(copysign(1.0, negzero) == -1.0, "copysign(1.0, -0.0) == -1.0");
|
|
check(copysign(1.0, poszero) == 1.0, "copysign(1.0, +0.0) == +1.0");
|
|
check(copysign(-1.0, poszero) == 1.0, "copysign(-1.0, +0.0) == +1.0");
|
|
check(signbit(copysign(1.0, negzero)), "copysign(1.0, -0.0) has signbit set");
|
|
check(copysignf(-1.0f, -0.0f) == -1.0f, "copysignf(-1.0f, -0.0f) == -1.0f");
|
|
check(copysignl(-1.0L, 0.0L) == 1.0L, "copysignl(-1.0L, +0.0L) == +1.0L");
|
|
check(signbit(copysign(nan, negzero)), "copysign(NaN, -0.0) carries the sign");
|
|
check(!signbit(copysign(nan, poszero)), "copysign(NaN, +0.0) clears the sign");
|
|
}
|
|
|
|
/* 3. floor: toward -Inf, across the sign boundary and the subnormal
|
|
* range. */
|
|
static void
|
|
floor_scenario(void)
|
|
{
|
|
volatile double half = 0.5;
|
|
volatile long double neg_half = -0.5L;
|
|
volatile double two = 2.0;
|
|
volatile float twof = 2.0f;
|
|
volatile double negzero = -0.0;
|
|
volatile double sub = 5e-324; /* the smallest subnormal */
|
|
volatile double big = 2251799813685248.0; /* 2^51 */
|
|
volatile double big_half = 2251799813685248.5; /* 2^51 + 0.5 */
|
|
|
|
check(floor(-0.5) == -1.0, "floor(-0.5) == -1.0");
|
|
check(floor(half) == 0.0 && !signbit(floor(half)), "floor(+0.5) == +0.0");
|
|
check(floorl(neg_half) == -1.0L, "floorl(-0.5L) == -1.0L");
|
|
check(floorf(-0.5f) == -1.0f, "floorf(-0.5f) == -1.0f");
|
|
check(floor(two) == 2.0, "floor(2.0) == 2.0");
|
|
check(floorf(twof) == 2.0f, "floorf(2.0f) == 2.0f");
|
|
check(floor(-two) == -2.0, "floor(-2.0) == -2.0");
|
|
check(floor(negzero) == 0.0 && signbit(floor(negzero)), "floor(-0.0) == -0.0");
|
|
check(floor(sub) == 0.0 && !signbit(floor(sub)), "floor(5e-324) == +0.0");
|
|
check(floor(-sub) == -1.0, "floor(-5e-324) == -1.0");
|
|
check(floor(big_half) == big, "floor(2^51 + 0.5) == 2^51");
|
|
check(floor(-big_half) == -big - 1.0, "floor(-(2^51 + 0.5)) == -2^51 - 1");
|
|
check(floorl((long double)big + 0.5L) == (long double)big, "floorl(2^62 + 0.5L) == 2^62L");
|
|
check(floorl(-((long double)big + 0.5L)) == -((long double)big) - 1.0L,
|
|
"floorl(-(2^62 + 0.5L)) == -2^62L - 1");
|
|
}
|
|
|
|
/* 4. ceil: toward +Inf; ceil(-0.5) must be a real negative zero. */
|
|
static void
|
|
ceil_scenario(void)
|
|
{
|
|
volatile double negzero = -0.0;
|
|
volatile double neg_half = -0.5;
|
|
volatile float pos_half = 0.5f;
|
|
volatile long double pos_half_l = 0.5L;
|
|
volatile double neg_third = -0.3;
|
|
volatile double big = 2251799813685248.0;
|
|
volatile double big_half = 2251799813685248.5;
|
|
|
|
check(ceil(neg_half) == 0.0 && signbit(ceil(neg_half)), "ceil(-0.5) == -0.0 (signbit)");
|
|
check(ceil(-1.5) == -1.0, "ceil(-1.5) == -1.0");
|
|
check(ceilf(pos_half) == 1.0f, "ceilf(+0.5f) == 1.0f");
|
|
check(ceill(pos_half_l) == 1.0L, "ceill(+0.5L) == 1.0L");
|
|
check(ceil(neg_third) == 0.0 && signbit(ceil(neg_third)), "ceil(-0.3) == -0.0 (signbit)");
|
|
check(ceil(negzero) == 0.0 && signbit(ceil(negzero)), "ceil(-0.0) == -0.0");
|
|
check(ceilf(-0.5f) == 0.0f && signbit(ceilf(-0.5f)), "ceilf(-0.5f) == -0.0f (signbit)");
|
|
check(ceill(-0.5L) == 0.0L && signbit(ceill(-0.5L)), "ceill(-0.5L) == -0.0L (signbit)");
|
|
check(ceil(big_half) == big + 1.0, "ceil(2^51 + 0.5) == 2^51 + 1");
|
|
check(ceil(-big_half) == -big, "ceil(-(2^51 + 0.5)) == -2^51");
|
|
}
|
|
|
|
/* 5. trunc: toward zero, with signed-zero results below 1. */
|
|
static void
|
|
trunc_scenario(void)
|
|
{
|
|
volatile double neg = -1.7;
|
|
volatile double pos = 1.7;
|
|
volatile double neg_tiny = -0.7;
|
|
volatile float posf = 1.7f;
|
|
volatile long double negl = -1.7L;
|
|
volatile double negzero = -0.0;
|
|
volatile double big = 2251799813685248.0;
|
|
volatile double big_half = 2251799813685248.5;
|
|
|
|
check(trunc(neg) == -1.0, "trunc(-1.7) == -1.0");
|
|
check(trunc(pos) == 1.0, "trunc(+1.7) == 1.0");
|
|
check(truncf(posf) == 1.0f, "truncf(+1.7f) == 1.0f");
|
|
check(truncl(negl) == -1.0L, "truncl(-1.7L) == -1.0L");
|
|
check(trunc(neg_tiny) == 0.0 && signbit(trunc(neg_tiny)), "trunc(-0.7) == -0.0 (signbit)");
|
|
check(trunc(0.7) == 0.0 && !signbit(trunc(0.7)), "trunc(+0.7) == +0.0");
|
|
check(trunc(negzero) == 0.0 && signbit(trunc(negzero)), "trunc(-0.0) == -0.0");
|
|
check(trunc(big_half) == big, "trunc(2^51 + 0.5) == 2^51");
|
|
check(trunc(-big_half) == -big, "trunc(-(2^51 + 0.5)) == -2^51");
|
|
check(truncl((long double)big + 0.5L) == (long double)big, "truncl(2^62 + 0.5L) == 2^62L");
|
|
}
|
|
|
|
/* 6. NaN and ±Inf passthrough for the three rounding families, plus the
|
|
* boundary value 4194304.5f (2^22 + 0.5, where float clearing drops a
|
|
* single bit). */
|
|
static void
|
|
special_scenario(void)
|
|
{
|
|
volatile double nan = NAN;
|
|
volatile double inf = HUGE_VAL;
|
|
volatile float nanf = NAN;
|
|
volatile long double inf_l = HUGE_VALL;
|
|
volatile float float_bound = 4194304.5f;
|
|
volatile double dbl_bound = 2251799813685248.5;
|
|
|
|
check(isnan(floor(nan)), "floor(NaN) is NaN");
|
|
check(isnan(ceil(nan)), "ceil(NaN) is NaN");
|
|
check(isnan(trunc(nan)), "trunc(NaN) is NaN");
|
|
check(isnan(floorf(nanf)), "floorf(NaN) is NaN");
|
|
check(floor(inf) == inf, "floor(+Inf) == +Inf");
|
|
check(floor(-inf) == -inf, "floor(-Inf) == -Inf");
|
|
check(ceil(inf) == inf, "ceil(+Inf) == +Inf");
|
|
check(ceil(-inf) == -inf, "ceil(-Inf) == -Inf");
|
|
check(trunc(inf) == inf, "trunc(+Inf) == +Inf");
|
|
check(trunc(-inf) == -inf, "trunc(-Inf) == -Inf");
|
|
check(ceill(inf_l) == inf_l, "ceill(+Inf) == +Inf");
|
|
check(truncl(-inf_l) == -inf_l, "truncl(-Inf) == -Inf");
|
|
check(floorf(float_bound) == 4194304.0f, "floorf(2^22 + 0.5f) == 2^22f");
|
|
check(trunc(float_bound) == 4194304.0, "trunc(2^22 + 0.5) == 2^22");
|
|
check(ceilf(float_bound) == 4194305.0f, "ceilf(2^22 + 0.5f) == 2^22 + 1f");
|
|
check(trunc(dbl_bound) == 2251799813685248.0, "trunc(2^51 + 0.5) == 2^51");
|
|
}
|
|
|
|
/* 7. Classification macros over the FP_* constants. */
|
|
static void
|
|
classify_scenario(void)
|
|
{
|
|
volatile double nan = NAN;
|
|
volatile double inf = HUGE_VAL;
|
|
volatile double zero = 0.0;
|
|
volatile double sub = 5e-324;
|
|
volatile double one = 1.0;
|
|
|
|
check(fpclassify(nan) == FP_NAN, "fpclassify(NaN) == FP_NAN");
|
|
check(fpclassify(inf) == FP_INFINITE, "fpclassify(+Inf) == FP_INFINITE");
|
|
check(fpclassify(zero) == FP_ZERO, "fpclassify(0.0) == FP_ZERO");
|
|
check(fpclassify(sub) == FP_SUBNORMAL, "fpclassify(5e-324) == FP_SUBNORMAL");
|
|
check(fpclassify(one) == FP_NORMAL, "fpclassify(1.0) == FP_NORMAL");
|
|
check(isnan(nan) && !isnan(one), "isnan distinguishes NaN");
|
|
check(isinf(inf) && !isinf(one), "isinf distinguishes Inf");
|
|
check(isfinite(one) && !isfinite(inf) && !isfinite(nan), "isfinite is false for Inf/NaN");
|
|
check(isnormal(one) && !isnormal(zero) && !isnormal(sub) && !isnormal(nan),
|
|
"isnormal is false for zero/subnormal/NaN");
|
|
check(signbit(-0.0) && !signbit(zero), "signbit distinguishes -0.0");
|
|
check(fpclassify(1.0f) == FP_NORMAL, "fpclassify works on float");
|
|
check(fpclassify(1.0L) == FP_NORMAL, "fpclassify works on long double");
|
|
}
|
|
|
|
int
|
|
main(void)
|
|
{
|
|
fabs_scenario();
|
|
copysign_scenario();
|
|
floor_scenario();
|
|
ceil_scenario();
|
|
trunc_scenario();
|
|
special_scenario();
|
|
classify_scenario();
|
|
|
|
if (failures == 0)
|
|
{
|
|
say(1, "all math slice S1 tests passed\n");
|
|
}
|
|
else
|
|
{
|
|
say(1, "FAILURES\n");
|
|
}
|
|
return failures == 0 ? 0 : 1;
|
|
}
|