tools/regression/lib/msun/test-next.c

   1 /*-
   2  * Copyright (c) 2005 David Schultz <das@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 /*
  28  * Test the correctness of nextafter{,f,l} and nexttoward{,f,l}.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <fenv.h>
  35 #include <float.h>
  36 #include <math.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39
  40 #ifdef  __i386__
  41 #include <ieeefp.h>
  42 #endif
  43
  44 #define ALL_STD_EXCEPT  (FE_DIVBYZERO | FE_INEXACT | FE_INVALID |\
  45                          FE_OVERFLOW | FE_UNDERFLOW)
  46 #define test(exp, ans, ex)      do {                    \
  47         double __ans = (ans);                           \
  48         feclearexcept(ALL_STD_EXCEPT);                  \
  49         _testl(#exp, __LINE__, (exp), __ans, (ex));     \
  50 } while (0)
  51 #define testf(exp, ans, ex)     do {                    \
  52         float __ans = (ans);                            \
  53         feclearexcept(ALL_STD_EXCEPT);                  \
  54         _testl(#exp, __LINE__, (exp), __ans, (ex));     \
  55 } while (0)
  56 #define testl(exp, ans, ex)     do {                    \
  57         long double __ans = (ans);                      \
  58         feclearexcept(ALL_STD_EXCEPT);                  \
  59         _testl(#exp, __LINE__, (exp), __ans, (ex));     \
  60 } while (0)
  61 #define testboth(arg1, arg2, ans, ex, prec)     do {                    \
  62         test##prec(nextafter##prec((arg1), (arg2)), (ans), (ex));       \
  63         test##prec(nexttoward##prec((arg1), (arg2)), (ans), (ex));      \
  64 } while (0)
  65 #define testall(arg1, arg2, ans, ex)    do {            \
  66         testboth((arg1), (arg2), (ans), (ex), );        \
  67         testboth((arg1), (arg2), (ans), (ex), f);       \
  68         testboth((arg1), (arg2), (ans), (ex), l);       \
  69 } while (0)
  70
  71 static void _testl(const char *, int, long double, long double, int);
  72 static double idd(double);
  73 static float idf(float);
  74
  75 int
  76 main(int argc, char *argv[])
  77 {
  78         static const int ex_under = FE_UNDERFLOW | FE_INEXACT;  /* shorthand */
  79         static const int ex_over = FE_OVERFLOW | FE_INEXACT;
  80         long double ldbl_eps;
  81
  82         printf("1..5\n");
  83
  84 #ifdef  __i386__
  85         fpsetprec(FP_PE);
  86 #endif
  87         /*
  88          * We can't use a compile-time constant here because gcc on
  89          * FreeBSD/i386 assumes long doubles are truncated to the
  90          * double format.
  91          */
  92         ldbl_eps = ldexpl(1.0, LDBL_MIN_EXP - LDBL_MANT_DIG);
  93
  94         /*
  95          * Special cases involving zeroes.
  96          */
  97 #define ztest(prec)                                                           \
  98         test##prec(copysign##prec(1.0, nextafter##prec(0.0, -0.0)), -1.0, 0); \
  99         test##prec(copysign##prec(1.0, nextafter##prec(-0.0, 0.0)), 1.0, 0);  \
 100         test##prec(copysign##prec(1.0, nexttoward##prec(0.0, -0.0)), -1.0, 0);\
 101         test##prec(copysign##prec(1.0, nexttoward##prec(-0.0, 0.0)), 1.0, 0)
 102
 103         ztest();
 104         ztest(f);
 105         ztest(l);
 106 #undef  ztest
 107
 108 #define stest(next, eps, prec)                                  \
 109         test##prec(next(-0.0, 42.0), eps, ex_under);            \
 110         test##prec(next(0.0, -42.0), -eps, ex_under);           \
 111         test##prec(next(0.0, INFINITY), eps, ex_under);         \
 112         test##prec(next(-0.0, -INFINITY), -eps, ex_under)
 113
 114         stest(nextafter, 0x1p-1074, );
 115         stest(nextafterf, 0x1p-149f, f);
 116         stest(nextafterl, ldbl_eps, l);
 117         stest(nexttoward, 0x1p-1074, );
 118         stest(nexttowardf, 0x1p-149f, f);
 119         stest(nexttowardl, ldbl_eps, l);
 120 #undef  stest
 121
 122         printf("ok 1 - next\n");
 123
 124         /*
 125          * `x == y' and NaN tests
 126          */
 127         testall(42.0, 42.0, 42.0, 0);
 128         testall(-42.0, -42.0, -42.0, 0);
 129         testall(INFINITY, INFINITY, INFINITY, 0);
 130         testall(-INFINITY, -INFINITY, -INFINITY, 0);
 131         testall(NAN, 42.0, NAN, 0);
 132         testall(42.0, NAN, NAN, 0);
 133         testall(NAN, NAN, NAN, 0);
 134
 135         printf("ok 2 - next\n");
 136
 137         /*
 138          * Tests where x is an ordinary normalized number
 139          */
 140         testboth(1.0, 2.0, 1.0 + DBL_EPSILON, 0, );
 141         testboth(1.0, -INFINITY, 1.0 - DBL_EPSILON/2, 0, );
 142         testboth(1.0, 2.0, 1.0 + FLT_EPSILON, 0, f);
 143         testboth(1.0, -INFINITY, 1.0 - FLT_EPSILON/2, 0, f);
 144         testboth(1.0, 2.0, 1.0 + LDBL_EPSILON, 0, l);
 145         testboth(1.0, -INFINITY, 1.0 - LDBL_EPSILON/2, 0, l);
 146
 147         testboth(-1.0, 2.0, -1.0 + DBL_EPSILON/2, 0, );
 148         testboth(-1.0, -INFINITY, -1.0 - DBL_EPSILON, 0, );
 149         testboth(-1.0, 2.0, -1.0 + FLT_EPSILON/2, 0, f);
 150         testboth(-1.0, -INFINITY, -1.0 - FLT_EPSILON, 0, f);
 151         testboth(-1.0, 2.0, -1.0 + LDBL_EPSILON/2, 0, l);
 152         testboth(-1.0, -INFINITY, -1.0 - LDBL_EPSILON, 0, l);
 153
 154         /* Cases where nextafter(...) != nexttoward(...) */
 155         test(nexttoward(1.0, 1.0 + LDBL_EPSILON), 1.0 + DBL_EPSILON, 0);
 156         testf(nexttowardf(1.0, 1.0 + LDBL_EPSILON), 1.0 + FLT_EPSILON, 0);
 157         testl(nexttowardl(1.0, 1.0 + LDBL_EPSILON), 1.0 + LDBL_EPSILON, 0);
 158
 159         printf("ok 3 - next\n");
 160
 161         /*
 162          * Tests at word boundaries, normalization boundaries, etc.
 163          */
 164         testboth(0x1.87654ffffffffp+0, INFINITY, 0x1.87655p+0, 0, );
 165         testboth(0x1.87655p+0, -INFINITY, 0x1.87654ffffffffp+0, 0, );
 166         testboth(0x1.fffffffffffffp+0, INFINITY, 0x1p1, 0, );
 167         testboth(0x1p1, -INFINITY, 0x1.fffffffffffffp+0, 0, );
 168         testboth(0x0.fffffffffffffp-1022, INFINITY, 0x1p-1022, 0, );
 169         testboth(0x1p-1022, -INFINITY, 0x0.fffffffffffffp-1022, ex_under, );
 170
 171         testboth(0x1.fffffep0f, INFINITY, 0x1p1, 0, f);
 172         testboth(0x1p1, -INFINITY, 0x1.fffffep0f, 0, f);
 173         testboth(0x0.fffffep-126f, INFINITY, 0x1p-126f, 0, f);
 174         testboth(0x1p-126f, -INFINITY, 0x0.fffffep-126f, ex_under, f);
 175
 176 #if LDBL_MANT_DIG == 53
 177         testboth(0x1.87654ffffffffp+0L, INFINITY, 0x1.87655p+0L, 0, l);
 178         testboth(0x1.87655p+0L, -INFINITY, 0x1.87654ffffffffp+0L, 0, l);
 179         testboth(0x1.fffffffffffffp+0L, INFINITY, 0x1p1L, 0, l);
 180         testboth(0x1p1L, -INFINITY, 0x1.fffffffffffffp+0L, 0, l);
 181         testboth(0x0.fffffffffffffp-1022L, INFINITY, 0x1p-1022L, 0, l);
 182         testboth(0x1p-1022L, -INFINITY, 0x0.fffffffffffffp-1022L, ex_under, l);
 183 #elif LDBL_MANT_DIG == 64
 184         testboth(0x1.87654321fffffffep+0L, INFINITY, 0x1.87654322p+0L, 0, l);
 185         testboth(0x1.87654322p+0L, -INFINITY, 0x1.87654321fffffffep+0L, 0, l);
 186         testboth(0x1.fffffffffffffffep0L, INFINITY, 0x1p1L, 0, l);
 187         testboth(0x1p1L, -INFINITY, 0x1.fffffffffffffffep0L, 0, l);
 188         testboth(0x0.fffffffffffffffep-16382L, INFINITY, 0x1p-16382L, 0, l);
 189         testboth(0x1p-16382L, -INFINITY,
 190             0x0.fffffffffffffffep-16382L, ex_under, l);
 191 #elif LDBL_MANT_DIG == 113
 192         testboth(0x1.876543210987ffffffffffffffffp+0L, INFINITY,
 193             0x1.876543210988p+0, 0, l);
 194         testboth(0x1.876543210988p+0L, -INFINITY,
 195             0x1.876543210987ffffffffffffffffp+0L, 0, l);
 196         testboth(0x1.ffffffffffffffffffffffffffffp0L, INFINITY, 0x1p1L, 0, l);
 197         testboth(0x1p1L, -INFINITY, 0x1.ffffffffffffffffffffffffffffp0L, 0, l);
 198         testboth(0x0.ffffffffffffffffffffffffffffp-16382L, INFINITY,
 199             0x1p-16382L, 0, l);
 200         testboth(0x1p-16382L, -INFINITY,
 201             0x0.ffffffffffffffffffffffffffffp-16382L, ex_under, l);
 202 #endif
 203
 204         printf("ok 4 - next\n");
 205
 206         /*
 207          * Overflow tests
 208          */
 209         test(idd(nextafter(DBL_MAX, INFINITY)), INFINITY, ex_over);
 210         test(idd(nextafter(INFINITY, 0.0)), DBL_MAX, 0);
 211         test(idd(nexttoward(DBL_MAX, DBL_MAX * 2.0L)), INFINITY, ex_over);
 212         test(idd(nexttoward(INFINITY, DBL_MAX * 2.0L)), DBL_MAX, 0);
 213
 214         testf(idf(nextafterf(FLT_MAX, INFINITY)), INFINITY, ex_over);
 215         testf(idf(nextafterf(INFINITY, 0.0)), FLT_MAX, 0);
 216         testf(idf(nexttowardf(FLT_MAX, FLT_MAX * 2.0)), INFINITY, ex_over);
 217         testf(idf(nexttowardf(INFINITY, FLT_MAX * 2.0)), FLT_MAX, 0);
 218
 219         testboth(LDBL_MAX, INFINITY, INFINITY, ex_over, l);
 220         testboth(INFINITY, 0.0, LDBL_MAX, 0, l);
 221
 222         printf("ok 5 - next\n");
 223
 224         return (0);
 225 }
 226
 227 static void
 228 _testl(const char *exp, int line, long double actual, long double expected,
 229     int except)
 230 {
 231         int actual_except;
 232
 233         actual_except = fetestexcept(ALL_STD_EXCEPT);
 234         if (actual != expected && !(isnan(actual) && isnan(expected))) {
 235                 fprintf(stderr, "%d: %s returned %La, expecting %La\n",
 236                     line, exp, actual, expected);
 237                 abort();
 238         }
 239         if (actual_except != except) {
 240                 fprintf(stderr, "%d: %s raised 0x%x, expecting 0x%x\n",
 241                     line, exp, actual_except, except);
 242                 abort();
 243         }
 244 }
 245
 246 /*
 247  * The idd() and idf() routines ensure that doubles and floats are
 248  * converted to their respective types instead of stored in the FPU
 249  * with extra precision.
 250  */
 251 static double
 252 idd(double x)
 253 {
 254         return (x);
 255 }
 256
 257 static float
 258 idf(float x)
 259 {
 260         return (x);
 261 }