test/math/basic-test.c

   1 /* Copyright (C) 1999 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Andreas Jaeger <aj@suse.de>, 1999.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 #define _ISOC99_SOURCE
  20
  21 #include <math.h>
  22 #include <float.h>
  23 #include <stdio.h>
  24
  25 static int errors = 0;
  26
  27
  28 static void
  29 check (const char *testname, int result)
  30 {
  31   if (!result) {
  32     printf ("Failure: %s\n", testname);
  33     errors++;
  34   }
  35 }
  36
  37 #define TEST_FUNC(NAME, FLOAT, NANFUNC, EPSILON, HUGEVAL) \
  38 static void                                                                   \
  39 NAME (void)                                                                   \
  40 {                                                                             \
  41   /* Variables are declared volatile to forbid some compiler                  \
  42      optimizations.  */                                                       \
  43   volatile FLOAT Inf_var, NaN_var, zero_var, one_var;                         \
  44   FLOAT x1, x2;                                                               \
  45                                                                               \
  46   zero_var = 0.0;                                                             \
  47   one_var = 1.0;                                                              \
  48   NaN_var = zero_var/zero_var;                                                \
  49   Inf_var = one_var / zero_var;                                               \
  50                                                                               \
  51   (void) &zero_var;                                                           \
  52   (void) &one_var;                                                            \
  53   (void) &NaN_var;                                                            \
  54   (void) &Inf_var;                                                            \
  55                                                                               \
  56                                                                               \
  57   check (#FLOAT " isinf (inf) == 1", isinf (Inf_var) == 1);                   \
  58   check (#FLOAT " isinf (-inf) == -1", isinf (-Inf_var) == -1);               \
  59   check (#FLOAT " !isinf (1)", !(isinf (one_var)));                           \
  60   check (#FLOAT " !isinf (NaN)", !(isinf (NaN_var)));                         \
  61                                                                               \
  62   check (#FLOAT " isnan (NaN)", isnan (NaN_var));                             \
  63   check (#FLOAT " isnan (-NaN)", isnan (-NaN_var));                           \
  64   check (#FLOAT " !isnan (1)", !(isnan (one_var)));                           \
  65   check (#FLOAT " !isnan (inf)", !(isnan (Inf_var)));                         \
  66                                                                               \
  67   /*                                                                          \
  68      the same tests but this time with NAN from <bits/nan.h>                  \
  69      NAN is a double const                                                    \
  70    */                                                                         \
  71   check (#FLOAT " isnan (NAN)", isnan (NAN));                                 \
  72   check (#FLOAT " isnan (-NAN)", isnan (-NAN));                               \
  73   check (#FLOAT " !isinf (NAN)", !(isinf (NAN)));                             \
  74   check (#FLOAT " !isinf (-NAN)", !(isinf (-NAN)));                           \
  75                                                                               \
  76   /*                                                                          \
  77      And again with the value returned by the `nan' function.                 \
  78    */                                                                         \
  79   check (#FLOAT " isnan (NAN)", isnan (NANFUNC ("")));                        \
  80   check (#FLOAT " isnan (-NAN)", isnan (-NANFUNC ("")));                      \
  81   check (#FLOAT " !isinf (NAN)", !(isinf (NANFUNC (""))));                    \
  82   check (#FLOAT " !isinf (-NAN)", !(isinf (-NANFUNC (""))));                  \
  83   check (#FLOAT " NAN != NAN", NANFUNC ("") != NANFUNC (""));                 \
  84                                                                               \
  85   /* test if HUGE_VALx is ok */                                               \
  86   x1 = HUGEVAL;                                                               \
  87   check (#FLOAT " isinf (HUGE_VALx) == +1", isinf (x1) == +1);                \
  88   x1 = - HUGEVAL;                                                             \
  89   check (#FLOAT " isinf (-HUGE_VALx) == -1", isinf (x1) == -1);               \
  90 }
  91 #ifndef DO_C99_MATH
  92 # undef TEST_FUNC
  93 # define TEST_FUNC(NAME, FLOAT, NANFUNC, EPSILON, HUGEVAL) \
  94 static void                                                                   \
  95 NAME(void)                                                                    \
  96 { /* nothing */ }
  97 #endif
  98
  99 #define TEST_VAL(NAME, FLOAT, NANFUNC, EPSILON, HUGEVAL) \
 100 static void                                                                   \
 101 NAME (void)                                                                   \
 102 {                                                                             \
 103   /* Variables are declared volatile to forbid some compiler                  \
 104      optimizations.  */                                                       \
 105   volatile FLOAT Inf_var, NaN_var, zero_var, one_var;                         \
 106   FLOAT x1, x2;                                                               \
 107                                                                               \
 108   zero_var = 0.0;                                                             \
 109   one_var = 1.0;                                                              \
 110   NaN_var = zero_var/zero_var;                                                \
 111   Inf_var = one_var / zero_var;                                               \
 112                                                                               \
 113   (void) &zero_var;                                                           \
 114   (void) &one_var;                                                            \
 115   (void) &NaN_var;                                                            \
 116   (void) &Inf_var;                                                            \
 117                                                                               \
 118                                                                               \
 119   check (#FLOAT " inf == inf", Inf_var == Inf_var);                           \
 120   check (#FLOAT " -inf == -inf", -Inf_var == -Inf_var);                       \
 121   check (#FLOAT " inf != -inf", Inf_var != -Inf_var);                         \
 122   check (#FLOAT " NaN != NaN", NaN_var != NaN_var);                           \
 123                                                                               \
 124   check (#FLOAT " NAN != NAN", NAN != NAN);                                   \
 125                                                                               \
 126                                                                               \
 127   /* test if EPSILON is ok */                                                 \
 128   x1 = 1.0;                                                                   \
 129   x2 = x1 + EPSILON;                                                          \
 130   check (#FLOAT " 1 != 1+EPSILON", x1 != x2);                                 \
 131                                                                               \
 132   x1 = 1.0;                                                                   \
 133   x2 = x1 - EPSILON;                                                          \
 134   check (#FLOAT " 1 != 1-EPSILON", x1 != x2);                                 \
 135                                                                               \
 136 }
 137
 138 TEST_VAL (float_test_value, float, nanf, FLT_EPSILON, HUGE_VALF)
 139 TEST_FUNC (float_test_call, float, nanf, FLT_EPSILON, HUGE_VALF)
 140 TEST_VAL (double_test_value, double, nan, DBL_EPSILON, HUGE_VAL)
 141 TEST_FUNC (double_test_call, double, nan, DBL_EPSILON, HUGE_VAL)
 142 #ifndef NO_LONG_DOUBLE
 143 TEST_VAL (ldouble_test_value, long double, nanl, LDBL_EPSILON, HUGE_VALL)
 144 TEST_FUNC (ldouble_test_call, long double, nanl, LDBL_EPSILON, HUGE_VALL)
 145 #endif
 146
 147 int
 148 main (void)
 149 {
 150   float_test_value ();
 151   float_test_call ();
 152   double_test_value ();
 153   double_test_call ();
 154
 155 #ifndef NO_LONG_DOUBLE
 156   ldouble_test_value ();
 157   ldouble_test_call ();
 158 #endif
 159
 160   return errors != 0;
 161 }