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 #include "test-utils.h"
  45
  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_small, ldbl_eps, ldbl_max;
  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_small = ldexpl(1.0, LDBL_MIN_EXP - LDBL_MANT_DIG);
  93         ldbl_eps = LDBL_EPSILON;
  94         ldbl_max = ldexpl(1.0 - ldbl_eps / 2, LDBL_MAX_EXP);
  95
  96         /*
  97          * Special cases involving zeroes.
  98          */
  99 #define ztest(prec)                                                           \
 100         test##prec(copysign##prec(1.0, nextafter##prec(0.0, -0.0)), -1.0, 0); \
 101         test##prec(copysign##prec(1.0, nextafter##prec(-0.0, 0.0)), 1.0, 0);  \
 102         test##prec(copysign##prec(1.0, nexttoward##prec(0.0, -0.0)), -1.0, 0);\
 103         test##prec(copysign##prec(1.0, nexttoward##prec(-0.0, 0.0)), 1.0, 0)
 104
 105         ztest();
 106         ztest(f);
 107         ztest(l);
 108 #undef  ztest
 109
 110 #define stest(next, eps, prec)                                  \
 111         test##prec(next(-0.0, 42.0), eps, ex_under);            \
 112         test##prec(next(0.0, -42.0), -eps, ex_under);           \
 113         test##prec(next(0.0, INFINITY), eps, ex_under);         \
 114         test##prec(next(-0.0, -INFINITY), -eps, ex_under)
 115
 116         stest(nextafter, 0x1p-1074, );
 117         stest(nextafterf, 0x1p-149f, f);
 118         stest(nextafterl, ldbl_small, l);
 119         stest(nexttoward, 0x1p-1074, );
 120         stest(nexttowardf, 0x1p-149f, f);
 121         stest(nexttowardl, ldbl_small, l);
 122 #undef  stest
 123
 124         printf("ok 1 - next\n");
 125
 126         /*
 127          * `x == y' and NaN tests
 128          */
 129         testall(42.0, 42.0, 42.0, 0);
 130         testall(-42.0, -42.0, -42.0, 0);
 131         testall(INFINITY, INFINITY, INFINITY, 0);
 132         testall(-INFINITY, -INFINITY, -INFINITY, 0);
 133         testall(NAN, 42.0, NAN, 0);
 134         testall(42.0, NAN, NAN, 0);
 135         testall(NAN, NAN, NAN, 0);
 136
 137         printf("ok 2 - next\n");
 138
 139         /*
 140          * Tests where x is an ordinary normalized number
 141          */
 142         testboth(1.0, 2.0, 1.0 + DBL_EPSILON, 0, );
 143         testboth(1.0, -INFINITY, 1.0 - DBL_EPSILON/2, 0, );
 144         testboth(1.0, 2.0, 1.0 + FLT_EPSILON, 0, f);
 145         testboth(1.0, -INFINITY, 1.0 - FLT_EPSILON/2, 0, f);
 146         testboth(1.0, 2.0, 1.0 + ldbl_eps, 0, l);
 147         testboth(1.0, -INFINITY, 1.0 - ldbl_eps/2, 0, l);
 148
 149         testboth(-1.0, 2.0, -1.0 + DBL_EPSILON/2, 0, );
 150         testboth(-1.0, -INFINITY, -1.0 - DBL_EPSILON, 0, );
 151         testboth(-1.0, 2.0, -1.0 + FLT_EPSILON/2, 0, f);
 152         testboth(-1.0, -INFINITY, -1.0 - FLT_EPSILON, 0, f);
 153         testboth(-1.0, 2.0, -1.0 + ldbl_eps/2, 0, l);
 154         testboth(-1.0, -INFINITY, -1.0 - ldbl_eps, 0, l);
 155
 156         /* Cases where nextafter(...) != nexttoward(...) */
 157         test(nexttoward(1.0, 1.0 + ldbl_eps), 1.0 + DBL_EPSILON, 0);
 158         testf(nexttowardf(1.0, 1.0 + ldbl_eps), 1.0 + FLT_EPSILON, 0);
 159         testl(nexttowardl(1.0, 1.0 + ldbl_eps), 1.0 + ldbl_eps, 0);
 160
 161         printf("ok 3 - next\n");
 162
 163         /*
 164          * Tests at word boundaries, normalization boundaries, etc.
 165          */
 166         testboth(0x1.87654ffffffffp+0, INFINITY, 0x1.87655p+0, 0, );
 167         testboth(0x1.87655p+0, -INFINITY, 0x1.87654ffffffffp+0, 0, );
 168         testboth(0x1.fffffffffffffp+0, INFINITY, 0x1p1, 0, );
 169         testboth(0x1p1, -INFINITY, 0x1.fffffffffffffp+0, 0, );
 170         testboth(0x0.fffffffffffffp-1022, INFINITY, 0x1p-1022, 0, );
 171         testboth(0x1p-1022, -INFINITY, 0x0.fffffffffffffp-1022, ex_under, );
 172
 173         testboth(0x1.fffffep0f, INFINITY, 0x1p1, 0, f);
 174         testboth(0x1p1, -INFINITY, 0x1.fffffep0f, 0, f);
 175         testboth(0x0.fffffep-126f, INFINITY, 0x1p-126f, 0, f);
 176         testboth(0x1p-126f, -INFINITY, 0x0.fffffep-126f, ex_under, f);
 177
 178 #if LDBL_MANT_DIG == 53
 179         testboth(0x1.87654ffffffffp+0L, INFINITY, 0x1.87655p+0L, 0, l);
 180         testboth(0x1.87655p+0L, -INFINITY, 0x1.87654ffffffffp+0L, 0, l);
 181         testboth(0x1.fffffffffffffp+0L, INFINITY, 0x1p1L, 0, l);
 182         testboth(0x1p1L, -INFINITY, 0x1.fffffffffffffp+0L, 0, l);
 183         testboth(0x0.fffffffffffffp-1022L, INFINITY, 0x1p-1022L, 0, l);
 184         testboth(0x1p-1022L, -INFINITY, 0x0.fffffffffffffp-1022L, ex_under, l);
 185 #elif LDBL_MANT_DIG == 64 && !defined(__i386)
 186         testboth(0x1.87654321fffffffep+0L, INFINITY, 0x1.87654322p+0L, 0, l);
 187         testboth(0x1.87654322p+0L, -INFINITY, 0x1.87654321fffffffep+0L, 0, l);
 188         testboth(0x1.fffffffffffffffep0L, INFINITY, 0x1p1L, 0, l);
 189         testboth(0x1p1L, -INFINITY, 0x1.fffffffffffffffep0L, 0, l);
 190         testboth(0x0.fffffffffffffffep-16382L, INFINITY, 0x1p-16382L, 0, l);
 191         testboth(0x1p-16382L, -INFINITY,
 192             0x0.fffffffffffffffep-16382L, ex_under, l);
 193 #elif LDBL_MANT_DIG == 113
 194         testboth(0x1.876543210987ffffffffffffffffp+0L, INFINITY,
 195             0x1.876543210988p+0, 0, l);
 196         testboth(0x1.876543210988p+0L, -INFINITY,
 197             0x1.876543210987ffffffffffffffffp+0L, 0, l);
 198         testboth(0x1.ffffffffffffffffffffffffffffp0L, INFINITY, 0x1p1L, 0, l);
 199         testboth(0x1p1L, -INFINITY, 0x1.ffffffffffffffffffffffffffffp0L, 0, l);
 200         testboth(0x0.ffffffffffffffffffffffffffffp-16382L, INFINITY,
 201             0x1p-16382L, 0, l);
 202         testboth(0x1p-16382L, -INFINITY,
 203             0x0.ffffffffffffffffffffffffffffp-16382L, ex_under, l);
 204 #endif
 205
 206         printf("ok 4 - next\n");
 207
 208         /*
 209          * Overflow tests
 210          */
 211         test(idd(nextafter(DBL_MAX, INFINITY)), INFINITY, ex_over);
 212         test(idd(nextafter(INFINITY, 0.0)), DBL_MAX, 0);
 213         test(idd(nexttoward(DBL_MAX, DBL_MAX * 2.0L)), INFINITY, ex_over);
 214 #if LDBL_MANT_DIG > 53
 215         test(idd(nexttoward(INFINITY, DBL_MAX * 2.0L)), DBL_MAX, 0);
 216 #endif
 217
 218         testf(idf(nextafterf(FLT_MAX, INFINITY)), INFINITY, ex_over);
 219         testf(idf(nextafterf(INFINITY, 0.0)), FLT_MAX, 0);
 220         testf(idf(nexttowardf(FLT_MAX, FLT_MAX * 2.0)), INFINITY, ex_over);
 221         testf(idf(nexttowardf(INFINITY, FLT_MAX * 2.0)), FLT_MAX, 0);
 222
 223         testboth(ldbl_max, INFINITY, INFINITY, ex_over, l);
 224         testboth(INFINITY, 0.0, ldbl_max, 0, l);
 225
 226         printf("ok 5 - next\n");
 227
 228         return (0);
 229 }
 230
 231 static void
 232 _testl(const char *exp, int line, long double actual, long double expected,
 233     int except)
 234 {
 235         int actual_except;
 236
 237         actual_except = fetestexcept(ALL_STD_EXCEPT);
 238         if (!fpequal(actual, expected)) {
 239                 fprintf(stderr, "%d: %s returned %La, expecting %La\n",
 240                     line, exp, actual, expected);
 241                 abort();
 242         }
 243         if (actual_except != except) {
 244                 fprintf(stderr, "%d: %s raised 0x%x, expecting 0x%x\n",
 245                     line, exp, actual_except, except);
 246                 abort();
 247         }
 248 }
 249
 250 /*
 251  * The idd() and idf() routines ensure that doubles and floats are
 252  * converted to their respective types instead of stored in the FPU
 253  * with extra precision.
 254  */
 255 static double
 256 idd(double x)
 257 {
 258         return (x);
 259 }
 260
 261 static float
 262 idf(float x)
 263 {
 264         return (x);
 265 }