tests/mpz/t-cmp_d.c

   1 /* Test mpz_cmp_d and mpz_cmpabs_d.
   2
   3 Copyright 2001-2003, 2005 Free Software Foundation, Inc.
   4
   5 This file is part of the GNU MP Library test suite.
   6
   7 The GNU MP Library test suite is free software; you can redistribute it
   8 and/or modify it under the terms of the GNU General Public License as
   9 published by the Free Software Foundation; either version 3 of the License,
  10 or (at your option) any later version.
  11
  12 The GNU MP Library test suite is distributed in the hope that it will be
  13 useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
  15 Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License along with
  18 the GNU MP Library test suite.  If not, see https://www.gnu.org/licenses/.  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23
  24 #include "gmp.h"
  25 #include "gmp-impl.h"
  26 #include "tests.h"
  27
  28
  29 /* FIXME: Not sure if the tests here are exhaustive.  Ought to try to get
  30    each possible exit from mpz_cmp_d (and mpz_cmpabs_d) exercised.  */
  31
  32
  33 #define SGN(n)  ((n) > 0 ? 1 : (n) < 0 ? -1 : 0)
  34
  35
  36 void
  37 check_one (const char *name, mpz_srcptr x, double y, int cmp, int cmpabs)
  38 {
  39   int   got;
  40
  41   got = mpz_cmp_d (x, y);
  42   if (SGN(got) != cmp)
  43     {
  44       int i;
  45       printf    ("mpz_cmp_d wrong (from %s)\n", name);
  46       printf    ("  got  %d\n", got);
  47       printf    ("  want %d\n", cmp);
  48     fail:
  49       mpz_trace ("  x", x);
  50       printf    ("  y %g\n", y);
  51       mp_trace_base=-16;
  52       mpz_trace ("  x", x);
  53       printf    ("  y %g\n", y);
  54       printf    ("  y");
  55       for (i = 0; i < sizeof(y); i++)
  56         printf (" %02X", (unsigned) ((unsigned char *) &y)[i]);
  57       printf ("\n");
  58       abort ();
  59     }
  60
  61   got = mpz_cmpabs_d (x, y);
  62   if (SGN(got) != cmpabs)
  63     {
  64       printf    ("mpz_cmpabs_d wrong\n");
  65       printf    ("  got  %d\n", got);
  66       printf    ("  want %d\n", cmpabs);
  67       goto fail;
  68     }
  69 }
  70
  71
  72 void
  73 check_data (void)
  74 {
  75   static const struct {
  76     const char  *x;
  77     double      y;
  78     int         cmp, cmpabs;
  79
  80   } data[] = {
  81
  82     {  "0",  0.0,  0,  0 },
  83
  84     {  "1",  0.0,  1,  1 },
  85     { "-1",  0.0, -1,  1 },
  86
  87     {  "1",  0.5,  1,  1 },
  88     { "-1", -0.5, -1,  1 },
  89
  90     {  "0",  1.0, -1, -1 },
  91     {  "0", -1.0,  1, -1 },
  92
  93     {  "0x1000000000000000000000000000000000000000000000000", 1.0,  1, 1 },
  94     { "-0x1000000000000000000000000000000000000000000000000", 1.0, -1, 1 },
  95
  96     {  "0",  1e100, -1, -1 },
  97     {  "0", -1e100,  1, -1 },
  98
  99     {  "2",  1.5,   1,  1 },
 100     {  "2", -1.5,   1,  1 },
 101     { "-2",  1.5,  -1,  1 },
 102     { "-2", -1.5,  -1,  1 },
 103   };
 104
 105   mpz_t  x;
 106   int    i;
 107
 108   mpz_init (x);
 109
 110   for (i = 0; i < numberof (data); i++)
 111     {
 112       mpz_set_str_or_abort (x, data[i].x, 0);
 113       check_one ("check_data", x, data[i].y, data[i].cmp, data[i].cmpabs);
 114     }
 115
 116   mpz_clear (x);
 117 }
 118
 119
 120 /* Equality of integers with up to 53 bits */
 121 void
 122 check_onebits (void)
 123 {
 124   mpz_t   x, x2;
 125   double  y;
 126   int     i;
 127
 128   mpz_init_set_ui (x, 0L);
 129   mpz_init (x2);
 130
 131   for (i = 0; i < 512; i++)
 132     {
 133       mpz_mul_2exp (x, x, 1);
 134       mpz_add_ui (x, x, 1L);
 135
 136       y = mpz_get_d (x);
 137       mpz_set_d (x2, y);
 138
 139       /* stop if any truncation is occurring */
 140       if (mpz_cmp (x, x2) != 0)
 141         break;
 142
 143       check_one ("check_onebits", x, y, 0, 0);
 144       check_one ("check_onebits", x, -y, 1, 0);
 145       mpz_neg (x, x);
 146       check_one ("check_onebits", x, y, -1, 0);
 147       check_one ("check_onebits", x, -y, 0, 0);
 148       mpz_neg (x, x);
 149     }
 150
 151   mpz_clear (x);
 152   mpz_clear (x2);
 153 }
 154
 155
 156 /* With the mpz differing by 1, in a limb position possibly below the double */
 157 void
 158 check_low_z_one (void)
 159 {
 160   mpz_t          x;
 161   double         y;
 162   unsigned long  i;
 163
 164   mpz_init (x);
 165
 166   /* FIXME: It'd be better to base this on the float format. */
 167 #if defined (__vax) || defined (__vax__)
 168 #define LIM 127                 /* vax fp numbers have limited range */
 169 #else
 170 #define LIM 512
 171 #endif
 172
 173   for (i = 1; i < LIM; i++)
 174     {
 175       mpz_set_ui (x, 1L);
 176       mpz_mul_2exp (x, x, i);
 177       y = mpz_get_d (x);
 178
 179       check_one ("check_low_z_one", x, y,   0, 0);
 180       check_one ("check_low_z_one", x, -y,  1, 0);
 181       mpz_neg (x, x);
 182       check_one ("check_low_z_one", x, y,  -1, 0);
 183       check_one ("check_low_z_one", x, -y,  0, 0);
 184       mpz_neg (x, x);
 185
 186       mpz_sub_ui (x, x, 1);
 187
 188       check_one ("check_low_z_one", x, y,  -1, -1);
 189       check_one ("check_low_z_one", x, -y,  1, -1);
 190       mpz_neg (x, x);
 191       check_one ("check_low_z_one", x, y,  -1, -1);
 192       check_one ("check_low_z_one", x, -y,  1, -1);
 193       mpz_neg (x, x);
 194
 195       mpz_add_ui (x, x, 2);
 196
 197       check_one ("check_low_z_one", x, y,   1, 1);
 198       check_one ("check_low_z_one", x, -y,  1, 1);
 199       mpz_neg (x, x);
 200       check_one ("check_low_z_one", x, y,  -1, 1);
 201       check_one ("check_low_z_one", x, -y, -1, 1);
 202       mpz_neg (x, x);
 203     }
 204
 205   mpz_clear (x);
 206 }
 207
 208 /* Comparing 1 and 1+2^-n.  "y" is volatile to make gcc store and fetch it,
 209    which forces it to a 64-bit double, whereas on x86 it would otherwise
 210    remain on the float stack as an 80-bit long double.  */
 211 void
 212 check_one_2exp (void)
 213 {
 214   double           e;
 215   mpz_t            x;
 216   volatile double  y;
 217   int              i;
 218
 219   mpz_init (x);
 220
 221   e = 1.0;
 222   for (i = 0; i < 128; i++)
 223     {
 224       e /= 2.0;
 225       y = 1.0 + e;
 226       if (y == 1.0)
 227         break;
 228
 229       mpz_set_ui (x, 1L);
 230       check_one ("check_one_2exp", x,  y, -1, -1);
 231       check_one ("check_one_2exp", x, -y,  1, -1);
 232
 233       mpz_set_si (x, -1L);
 234       check_one ("check_one_2exp", x,  y, -1, -1);
 235       check_one ("check_one_2exp", x, -y,  1, -1);
 236     }
 237
 238   mpz_clear (x);
 239 }
 240
 241 void
 242 check_infinity (void)
 243 {
 244   mpz_t   x;
 245   double  y = tests_infinity_d ();
 246   if (y == 0.0)
 247     return;
 248
 249   mpz_init (x);
 250
 251   /* 0 cmp inf */
 252   mpz_set_ui (x, 0L);
 253   check_one ("check_infinity", x,  y, -1, -1);
 254   check_one ("check_infinity", x, -y,  1, -1);
 255
 256   /* 123 cmp inf */
 257   mpz_set_ui (x, 123L);
 258   check_one ("check_infinity", x,  y, -1, -1);
 259   check_one ("check_infinity", x, -y,  1, -1);
 260
 261   /* -123 cmp inf */
 262   mpz_set_si (x, -123L);
 263   check_one ("check_infinity", x,  y, -1, -1);
 264   check_one ("check_infinity", x, -y,  1, -1);
 265
 266   /* 2^5000 cmp inf */
 267   mpz_set_ui (x, 1L);
 268   mpz_mul_2exp (x, x, 5000L);
 269   check_one ("check_infinity", x,  y, -1, -1);
 270   check_one ("check_infinity", x, -y,  1, -1);
 271
 272   /* -2^5000 cmp inf */
 273   mpz_neg (x, x);
 274   check_one ("check_infinity", x,  y, -1, -1);
 275   check_one ("check_infinity", x, -y,  1, -1);
 276
 277   mpz_clear (x);
 278 }
 279
 280 int
 281 main (int argc, char *argv[])
 282 {
 283   tests_start ();
 284
 285   check_data ();
 286   check_onebits ();
 287   check_low_z_one ();
 288   check_one_2exp ();
 289   check_infinity ();
 290
 291   tests_end ();
 292   exit (0);
 293 }