tests/test-fenv-round.c

   1 /* Test of floating-point rounding direction.
   2    Copyright (C) 2023-2024 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Bruno Haible <bruno@clisp.org>, 2023.  */
  18
  19 #include <config.h>
  20
  21 /* Specification.  */
  22 #include <fenv.h>
  23
  24 #include "macros.h"
  25
  26 /* Check the FE_TOWARDZERO rounding direction.  */
  27 _GL_UNUSED static void
  28 test_towardzero ()
  29 {
  30   {
  31     float volatile a, b, q, p;
  32
  33     a = 1; b = 3; q = a / b; p = b * q;
  34     ASSERT (p < a);
  35
  36     a = -1; b = 3; q = a / b; p = b * q;
  37     ASSERT (p > a);
  38   }
  39   {
  40     double volatile a, b, q, p;
  41
  42     a = 1; b = 3; q = a / b; p = b * q;
  43     ASSERT (p < a);
  44
  45     a = -1; b = 3; q = a / b; p = b * q;
  46     ASSERT (p > a);
  47   }
  48 #if !(((defined __FreeBSD__ || defined __OpenBSD__) && defined __aarch64__) || (defined __NetBSD__ && defined __sparcv9 /* sparc64 */) || (defined __OpenBSD__ && defined __mips64))
  49   {
  50     long double volatile a, b, q, p;
  51
  52     a = 1; b = 3; q = a / b; p = b * q;
  53     ASSERT (p < a);
  54
  55     a = -1; b = 3; q = a / b; p = b * q;
  56     ASSERT (p > a);
  57   }
  58 #endif
  59 }
  60
  61 /* Check the FE_UPWARD rounding direction.  */
  62 _GL_UNUSED static void
  63 test_upward ()
  64 {
  65   {
  66     float volatile a, b, q, p;
  67
  68     a = 1; b = 3; q = a / b; p = b * q;
  69     ASSERT (p > a);
  70
  71     a = -1; b = 3; q = a / b; p = b * q;
  72     ASSERT (p > a);
  73   }
  74   {
  75     double volatile a, b, q, p;
  76
  77     a = 1; b = 3; q = a / b; p = b * q;
  78     ASSERT (p > a);
  79
  80     a = -1; b = 3; q = a / b; p = b * q;
  81     ASSERT (p > a);
  82   }
  83 #if !(((defined __FreeBSD__ || defined __OpenBSD__) && defined __aarch64__) || (defined __NetBSD__ && defined __sparcv9 /* sparc64 */) || (defined __OpenBSD__ && defined __mips64))
  84   {
  85     long double volatile a, b, q, p;
  86
  87     a = 1; b = 3; q = a / b; p = b * q;
  88     ASSERT (p > a);
  89
  90     a = -1; b = 3; q = a / b; p = b * q;
  91     ASSERT (p > a);
  92   }
  93 #endif
  94 }
  95
  96 /* Check the FE_DOWNWARD rounding direction.  */
  97 _GL_UNUSED static void
  98 test_downward ()
  99 {
 100   {
 101     float volatile a, b, q, p;
 102
 103     a = 1; b = 3; q = a / b; p = b * q;
 104     ASSERT (p < a);
 105
 106     a = -1; b = 3; q = a / b; p = b * q;
 107     ASSERT (p < a);
 108   }
 109   {
 110     double volatile a, b, q, p;
 111
 112     a = 1; b = 3; q = a / b; p = b * q;
 113     ASSERT (p < a);
 114
 115     a = -1; b = 3; q = a / b; p = b * q;
 116     ASSERT (p < a);
 117   }
 118 #if !(((defined __FreeBSD__ || defined __OpenBSD__) && defined __aarch64__) || (defined __NetBSD__ && defined __sparcv9 /* sparc64 */) || (defined __OpenBSD__ && defined __mips64))
 119   {
 120     long double volatile a, b, q, p;
 121
 122     a = 1; b = 3; q = a / b; p = b * q;
 123     ASSERT (p < a);
 124
 125     a = -1; b = 3; q = a / b; p = b * q;
 126     ASSERT (p < a);
 127   }
 128 #endif
 129 }
 130
 131 /* Check the FE_TONEAREST rounding direction.  */
 132 static void
 133 test_tonearest ()
 134 {
 135   {
 136     float volatile a, b, q, p;
 137
 138     a = 1; b = 3; q = a / b; p = b * q;
 139     ASSERT (p == a);
 140
 141     a = -1; b = 3; q = a / b; p = b * q;
 142     ASSERT (p == a);
 143   }
 144   {
 145     double volatile a, b, q, p;
 146
 147     a = 1; b = 3; q = a / b; p = b * q;
 148     ASSERT (p == a);
 149
 150     a = -1; b = 3; q = a / b; p = b * q;
 151     ASSERT (p == a);
 152   }
 153   {
 154     long double volatile a, b, q, p;
 155
 156     a = 1; b = 3; q = a / b; p = b * q;
 157     ASSERT (p == a);
 158
 159     a = -1; b = 3; q = a / b; p = b * q;
 160     ASSERT (p == a);
 161   }
 162 }
 163
 164 int
 165 main ()
 166 {
 167   /* Check that the default rounding direction is FE_TONEAREST.  */
 168   test_tonearest ();
 169
 170 /* On alpha, this test works only when compiled with the GCC option
 171    '-mfp-rounding-mode=d'.  */
 172 #if !((defined __arm__ && defined __SOFTFP__) || defined __alpha)
 173 # if defined FE_TOWARDZERO
 174   ASSERT (fesetround (FE_TOWARDZERO) == 0);
 175   test_towardzero ();
 176   ASSERT (fegetround () == FE_TOWARDZERO);
 177 # endif
 178
 179 # if defined FE_UPWARD
 180   ASSERT (fesetround (FE_UPWARD) == 0);
 181   test_upward ();
 182   ASSERT (fegetround () == FE_UPWARD);
 183 # endif
 184
 185 # if defined FE_DOWNWARD
 186   ASSERT (fesetround (FE_DOWNWARD) == 0);
 187   test_downward ();
 188   ASSERT (fegetround () == FE_DOWNWARD);
 189 # endif
 190 #endif
 191
 192   ASSERT (fesetround (FE_TONEAREST) == 0);
 193   test_tonearest ();
 194   ASSERT (fegetround () == FE_TONEAREST);
 195
 196   return test_exit_status;
 197 }