/* Test mpz_cmp_d and mpz_cmpabs_d. Copyright 2001-2003, 2005, 2013 Free Software Foundation, Inc. This file is part of the GNU MP Library test suite. The GNU MP Library test suite is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. The GNU MP Library test suite is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with the GNU MP Library test suite. If not, see https://www.gnu.org/licenses/. */ #include #include "testutils.h" /* FIXME: Not sure if the tests here are exhaustive. Ought to try to get each possible exit from mpz_cmp_d (and mpz_cmpabs_d) exercised. */ #define SGN(n) ((n) > 0 ? 1 : (n) < 0 ? -1 : 0) void check_one (const char *name, mpz_srcptr x, double y, int cmp, int cmpabs) { int got; got = mpz_cmp_d (x, y); if (SGN(got) != cmp) { unsigned i; printf ("mpz_cmp_d wrong (from %s)\n", name); printf (" got %d\n", got); printf (" want %d\n", cmp); fail: printf (" x="); mpz_out_str (stdout, 10, x); printf ("\n y %g\n", y); printf (" x=0x"); mpz_out_str (stdout, -16, x); printf ("\n y %g\n", y); printf (" y"); for (i = 0; i < sizeof(y); i++) printf (" %02X", (unsigned) ((unsigned char *) &y)[i]); printf ("\n"); abort (); } got = mpz_cmpabs_d (x, y); if (SGN(got) != cmpabs) { printf ("mpz_cmpabs_d wrong\n"); printf (" got %d\n", got); printf (" want %d\n", cmpabs); goto fail; } } void check_data (void) { static const struct { const char *x; double y; int cmp, cmpabs; } data[] = { { "0", 0.0, 0, 0 }, { "1", 0.0, 1, 1 }, { "-1", 0.0, -1, 1 }, { "1", 0.5, 1, 1 }, { "-1", -0.5, -1, 1 }, { "0", 1.0, -1, -1 }, { "0", -1.0, 1, -1 }, { "0x1000000000000000000000000000000000000000000000000", 1.0, 1, 1 }, { "-0x1000000000000000000000000000000000000000000000000", 1.0, -1, 1 }, { "0", 1e100, -1, -1 }, { "0", -1e100, 1, -1 }, { "2", 1.5, 1, 1 }, { "2", -1.5, 1, 1 }, { "-2", 1.5, -1, 1 }, { "-2", -1.5, -1, 1 }, }; mpz_t x; unsigned i; mpz_init (x); for (i = 0; i < numberof (data); i++) { mpz_set_str_or_abort (x, data[i].x, 0); check_one ("check_data", x, data[i].y, data[i].cmp, data[i].cmpabs); } mpz_clear (x); } /* Equality of integers with up to 53 bits */ void check_onebits (void) { mpz_t x, x2; double y; int i; mpz_init_set_ui (x, 0L); mpz_init (x2); for (i = 0; i < 512; i++) { mpz_mul_2exp (x, x, 1); mpz_add_ui (x, x, 1L); y = mpz_get_d (x); mpz_set_d (x2, y); /* stop if any truncation is occurring */ if (mpz_cmp (x, x2) != 0) break; check_one ("check_onebits", x, y, 0, 0); check_one ("check_onebits", x, -y, 1, 0); mpz_neg (x, x); check_one ("check_onebits", x, y, -1, 0); check_one ("check_onebits", x, -y, 0, 0); mpz_neg (x, x); } mpz_clear (x); mpz_clear (x2); } /* With the mpz differing by 1, in a limb position possibly below the double */ void check_low_z_one (void) { mpz_t x; double y; unsigned long i; mpz_init (x); /* FIXME: It'd be better to base this on the float format. */ #if defined (__vax) || defined (__vax__) #define LIM 127 /* vax fp numbers have limited range */ #else #define LIM 512 #endif for (i = 1; i < LIM; i++) { mpz_set_ui (x, 1L); mpz_mul_2exp (x, x, i); y = mpz_get_d (x); check_one ("check_low_z_one", x, y, 0, 0); check_one ("check_low_z_one", x, -y, 1, 0); mpz_neg (x, x); check_one ("check_low_z_one", x, y, -1, 0); check_one ("check_low_z_one", x, -y, 0, 0); mpz_neg (x, x); mpz_sub_ui (x, x, 1); check_one ("check_low_z_one", x, y, -1, -1); check_one ("check_low_z_one", x, -y, 1, -1); mpz_neg (x, x); check_one ("check_low_z_one", x, y, -1, -1); check_one ("check_low_z_one", x, -y, 1, -1); mpz_neg (x, x); mpz_add_ui (x, x, 2); check_one ("check_low_z_one", x, y, 1, 1); check_one ("check_low_z_one", x, -y, 1, 1); mpz_neg (x, x); check_one ("check_low_z_one", x, y, -1, 1); check_one ("check_low_z_one", x, -y, -1, 1); mpz_neg (x, x); } mpz_clear (x); } /* Comparing 1 and 1+2^-n. "y" is volatile to make gcc store and fetch it, which forces it to a 64-bit double, whereas on x86 it would otherwise remain on the float stack as an 80-bit long double. */ void check_one_2exp (void) { double e; mpz_t x; volatile double y; int i; mpz_init (x); e = 1.0; for (i = 0; i < 128; i++) { e /= 2.0; y = 1.0 + e; if (y == 1.0) break; mpz_set_ui (x, 1L); check_one ("check_one_2exp", x, y, -1, -1); check_one ("check_one_2exp", x, -y, 1, -1); mpz_set_si (x, -1L); check_one ("check_one_2exp", x, y, -1, -1); check_one ("check_one_2exp", x, -y, 1, -1); } mpz_clear (x); } void check_infinity (void) { mpz_t x; double y = HUGE_VAL; if (y != 2*y) return; mpz_init (x); /* 0 cmp inf */ mpz_set_ui (x, 0L); check_one ("check_infinity", x, y, -1, -1); check_one ("check_infinity", x, -y, 1, -1); /* 123 cmp inf */ mpz_set_ui (x, 123L); check_one ("check_infinity", x, y, -1, -1); check_one ("check_infinity", x, -y, 1, -1); /* -123 cmp inf */ mpz_set_si (x, -123L); check_one ("check_infinity", x, y, -1, -1); check_one ("check_infinity", x, -y, 1, -1); /* 2^5000 cmp inf */ mpz_set_ui (x, 1L); mpz_mul_2exp (x, x, 5000L); check_one ("check_infinity", x, y, -1, -1); check_one ("check_infinity", x, -y, 1, -1); /* -2^5000 cmp inf */ mpz_neg (x, x); check_one ("check_infinity", x, y, -1, -1); check_one ("check_infinity", x, -y, 1, -1); mpz_clear (x); } void testmain (int argc, char *argv[]) { check_data (); check_onebits (); check_low_z_one (); check_one_2exp (); check_infinity (); }