/* Test file for features related to exceptions.
Copyright 2001-2018 Free Software Foundation, Inc.
Contributed by the AriC and Caramba projects, INRIA.
This file is part of the GNU MPFR Library.
The GNU MPFR Library is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser 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 MPFR Library 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 Lesser General Public
License for more details.
You should have received a copy of the GNU Lesser General Public License
along with the GNU MPFR Library; see the file COPYING.LESSER. If not, see
http://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. */
#include "mpfr-test.h"
#define PRINT_ERROR(s) do { printf ("%s\n", s); exit (1); } while (0)
/* Test powerof2 */
static void
check_powerof2 (void)
{
mpfr_t x;
mpfr_init (x);
mpfr_set_ui (x, 1, MPFR_RNDN);
MPFR_ASSERTN (mpfr_powerof2_raw (x));
mpfr_set_ui (x, 3, MPFR_RNDN);
MPFR_ASSERTN (!mpfr_powerof2_raw (x));
mpfr_clear (x);
}
/* Test default rounding mode */
static void
check_default_rnd (void)
{
int r;
mpfr_rnd_t t;
for(r = 0 ; r < MPFR_RND_MAX ; r++)
{
mpfr_set_default_rounding_mode ((mpfr_rnd_t) r);
t = (mpfr_get_default_rounding_mode) ();
if ((mpfr_rnd_t) r != t)
{
printf ("%s %s\n", mpfr_print_rnd_mode ((mpfr_rnd_t) r),
mpfr_print_rnd_mode (t));
PRINT_ERROR ("ERROR in setting / getting default rounding mode (1)");
}
}
mpfr_set_default_rounding_mode ((mpfr_rnd_t) MPFR_RND_MAX);
if (mpfr_get_default_rounding_mode() != MPFR_RNDF)
PRINT_ERROR ("ERROR in setting / getting default rounding mode (2)");
mpfr_set_default_rounding_mode((mpfr_rnd_t) -1);
if (mpfr_get_default_rounding_mode() != MPFR_RNDF)
PRINT_ERROR ("ERROR in setting / getting default rounding mode (3)");
}
static void
check_emin_emax (void)
{
mpfr_exp_t old_emin, old_emax;
old_emin = mpfr_get_emin ();
old_emax = mpfr_get_emax ();
/* Check the functions not the macros ! */
if ((mpfr_set_emin)(MPFR_EMIN_MIN) != 0)
PRINT_ERROR ("set_emin failed!");
if ((mpfr_get_emin)() != MPFR_EMIN_MIN)
PRINT_ERROR ("get_emin FAILED!");
if ((mpfr_set_emin)(MPFR_EMIN_MIN-1) == 0)
PRINT_ERROR ("set_emin failed! (2)");
if ((mpfr_set_emax)(MPFR_EMAX_MAX) != 0)
PRINT_ERROR ("set_emax failed!");
if ((mpfr_get_emax)() != MPFR_EMAX_MAX)
PRINT_ERROR ("get_emax FAILED!");
if ((mpfr_set_emax)(MPFR_EMAX_MAX+1) == 0)
PRINT_ERROR ("set_emax failed! (2)");
if ((mpfr_get_emin_min) () != MPFR_EMIN_MIN)
PRINT_ERROR ("get_emin_min");
if ((mpfr_get_emin_max) () != MPFR_EMIN_MAX)
PRINT_ERROR ("get_emin_max");
if ((mpfr_get_emax_min) () != MPFR_EMAX_MIN)
PRINT_ERROR ("get_emax_min");
if ((mpfr_get_emax_max) () != MPFR_EMAX_MAX)
PRINT_ERROR ("get_emax_max");
set_emin (old_emin);
set_emax (old_emax);
}
static void
check_get_prec (void)
{
mpfr_t x;
mpfr_init2 (x, 17);
if (mpfr_get_prec (x) != 17 || (mpfr_get_prec)(x) != 17)
PRINT_ERROR ("mpfr_get_prec");
mpfr_clear (x);
}
static void
mpfr_set_double_range (void)
{
mpfr_set_default_prec (54);
if (mpfr_get_default_prec () != 54)
PRINT_ERROR ("get_default_prec failed (1)");
mpfr_set_default_prec (53);
if ((mpfr_get_default_prec) () != 53)
PRINT_ERROR ("get_default_prec failed (2)");
/* in double precision format, the unbiased exponent is between 0 and
2047, where 0 is used for subnormal numbers, and 2047 for special
numbers (infinities, NaN), and the bias is 1023, thus "normal" numbers
have an exponent between -1022 and 1023, corresponding to numbers
between 2^(-1022) and previous(2^(1024)).
(The smallest subnormal number is 0.(0^51)1*2^(-1022)= 2^(-1074).)
The smallest normal power of two is 1.0*2^(-1022).
The largest normal power of two is 2^1023.
(We have to add one for mpfr since mantissa are between 1/2 and 1.)
*/
set_emin (-1021);
set_emax (1024);
}
static void
check_flags (void)
{
mpfr_t x;
mpfr_exp_t old_emin, old_emax;
old_emin = mpfr_get_emin ();
old_emax = mpfr_get_emax ();
mpfr_init (x);
/* Check the functions not the macros ! */
(mpfr_clear_flags)();
mpfr_set_double_range ();
mpfr_set_ui (x, 1, MPFR_RNDN);
(mpfr_clear_overflow)();
mpfr_mul_2exp (x, x, 1024, MPFR_RNDN);
if (!(mpfr_overflow_p)())
PRINT_ERROR ("ERROR: No overflow detected!\n");
(mpfr_clear_underflow)();
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_div_2exp (x, x, 1025, MPFR_RNDN);
if (!(mpfr_underflow_p)())
PRINT_ERROR ("ERROR: No underflow detected!\n");
(mpfr_clear_nanflag)();
MPFR_SET_NAN(x);
mpfr_add (x, x, x, MPFR_RNDN);
if (!(mpfr_nanflag_p)())
PRINT_ERROR ("ERROR: No NaN flag!\n");
(mpfr_clear_inexflag)();
mpfr_set_ui(x, 2, MPFR_RNDN);
mpfr_cos(x, x, MPFR_RNDN);
if (!(mpfr_inexflag_p)())
PRINT_ERROR ("ERROR: No inexact flag!\n");
(mpfr_clear_erangeflag) ();
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_mul_2exp (x, x, 1024, MPFR_RNDN);
mpfr_get_ui (x, MPFR_RNDN);
if (!(mpfr_erangeflag_p)())
PRINT_ERROR ("ERROR: No erange flag!\n");
mpfr_clear (x);
set_emin (old_emin);
set_emax (old_emax);
}
static void
test_set_underflow (void)
{
mpfr_t x, zero, min;
mpfr_ptr r[MPFR_RND_MAX];
int t[MPFR_RND_MAX] = { 1, -1, 1, -1, 1 }; /* RNDN, RNDZ, RNDU, RNDD, RNDA */
int i;
int s;
mpfr_inits (x, zero, min, (mpfr_ptr) 0);
mpfr_set_ui (zero, 0, MPFR_RNDN);
mpfr_set_ui (min, 0, MPFR_RNDN);
mpfr_nextabove (min);
r[0] = r[2] = r[4] = min; /* RNDN, RNDU, RNDA */
r[1] = r[3] = zero; /* RNDZ, RNDD */
for (s = 1; s > 0; s = -1)
{
for (i = 0; i < MPFR_RND_MAX ; i++)
{
int j;
int inex;
j = s < 0 && i > 1 ? 5 - i : i;
inex = mpfr_underflow (x, (mpfr_rnd_t) i, s);
/* for RNDF, inex has no meaning, just check that x is either
min or zero */
if (i == MPFR_RNDF)
{
if (mpfr_cmp (x, min) && mpfr_cmp (x, zero))
{
printf ("Error in test_set_underflow, sign = %d,"
" rnd_mode = %s\n", s, mpfr_print_rnd_mode ((mpfr_rnd_t) i));
printf ("Got\n");
mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN);
printf ("\ninstead of\n");
mpfr_out_str (stdout, 2, 0, zero, MPFR_RNDN);
printf ("\nor\n");
mpfr_out_str (stdout, 2, 0, min, MPFR_RNDN);
printf ("\n");
exit (1);
}
}
else if (mpfr_cmp (x, r[j]) || inex * t[j] <= 0)
{
printf ("Error in test_set_underflow, sign = %d,"
" rnd_mode = %s\n", s, mpfr_print_rnd_mode ((mpfr_rnd_t) i));
printf ("Got\n");
mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN);
printf (", inex = %d\ninstead of\n", inex);
mpfr_out_str (stdout, 2, 0, r[j], MPFR_RNDN);
printf (", inex = %d\n", t[j]);
exit (1);
}
}
mpfr_neg (zero, zero, MPFR_RNDN);
mpfr_neg (min, min, MPFR_RNDN);
}
mpfr_clears (x, zero, min, (mpfr_ptr) 0);
}
static void
test_set_overflow (void)
{
mpfr_t x, inf, max;
mpfr_ptr r[MPFR_RND_MAX];
int t[MPFR_RND_MAX] = { 1, -1, 1, -1, 1 }; /* RNDN, RNDZ, RNDU, RNDD, RNDA */
int i;
int s;
mpfr_inits2 (32, x, inf, max, (mpfr_ptr) 0);
mpfr_set_inf (inf, 1);
mpfr_set_inf (max, 1);
mpfr_nextbelow (max);
r[0] = r[2] = r[4] = inf; /* RNDN, RNDU, RNDA */
r[1] = r[3] = max; /* RNDZ, RNDD */
for (s = 1; s > 0; s = -1)
{
for (i = 0; i < MPFR_RND_MAX ; i++)
{
int j;
int inex;
j = s < 0 && i > 1 ? 5 - i : i;
inex = mpfr_overflow (x, (mpfr_rnd_t) i, s);
/* for RNDF, inex has no meaning, just check that x is either
max or inf */
if (i == MPFR_RNDF)
{
if (mpfr_cmp (x, max) && mpfr_cmp (x, inf))
{
printf ("Error in test_set_overflow, sign = %d,"
" rnd_mode = %s\n", s, mpfr_print_rnd_mode ((mpfr_rnd_t) i));
printf ("Got\n");
mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN);
printf ("\ninstead of\n");
mpfr_out_str (stdout, 2, 0, max, MPFR_RNDN);
printf ("\nor\n");
mpfr_out_str (stdout, 2, 0, inf, MPFR_RNDN);
printf ("\n");
exit (1);
}
}
else if (mpfr_cmp (x, r[j]) || inex * t[j] <= 0)
{
printf ("Error in test_set_overflow, sign = %d,"
" rnd_mode = %s\n", s, mpfr_print_rnd_mode ((mpfr_rnd_t) i));
printf ("Got\n");
mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN);
printf (", inex = %d\ninstead of\n", inex);
mpfr_out_str (stdout, 2, 0, r[j], MPFR_RNDN);
printf (", inex = %d\n", t[j]);
exit (1);
}
}
mpfr_neg (inf, inf, MPFR_RNDN);
mpfr_neg (max, max, MPFR_RNDN);
}
mpfr_clears (x, inf, max, (mpfr_ptr) 0);
}
static void
check_set (void)
{
mpfr_clear_flags ();
mpfr_set_overflow ();
MPFR_ASSERTN ((mpfr_overflow_p) ());
mpfr_set_underflow ();
MPFR_ASSERTN ((mpfr_underflow_p) ());
mpfr_set_divby0 ();
MPFR_ASSERTN ((mpfr_divby0_p) ());
mpfr_set_nanflag ();
MPFR_ASSERTN ((mpfr_nanflag_p) ());
mpfr_set_inexflag ();
MPFR_ASSERTN ((mpfr_inexflag_p) ());
mpfr_set_erangeflag ();
MPFR_ASSERTN ((mpfr_erangeflag_p) ());
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_ALL);
mpfr_clear_overflow ();
MPFR_ASSERTN (! (mpfr_overflow_p) ());
mpfr_clear_underflow ();
MPFR_ASSERTN (! (mpfr_underflow_p) ());
mpfr_clear_divby0 ();
MPFR_ASSERTN (! (mpfr_divby0_p) ());
mpfr_clear_nanflag ();
MPFR_ASSERTN (! (mpfr_nanflag_p) ());
mpfr_clear_inexflag ();
MPFR_ASSERTN (! (mpfr_inexflag_p) ());
mpfr_clear_erangeflag ();
MPFR_ASSERTN (! (mpfr_erangeflag_p) ());
MPFR_ASSERTN (__gmpfr_flags == 0);
(mpfr_set_overflow) ();
MPFR_ASSERTN (mpfr_overflow_p ());
(mpfr_set_underflow) ();
MPFR_ASSERTN (mpfr_underflow_p ());
(mpfr_set_divby0) ();
MPFR_ASSERTN (mpfr_divby0_p ());
(mpfr_set_nanflag) ();
MPFR_ASSERTN (mpfr_nanflag_p ());
(mpfr_set_inexflag) ();
MPFR_ASSERTN (mpfr_inexflag_p ());
(mpfr_set_erangeflag) ();
MPFR_ASSERTN (mpfr_erangeflag_p ());
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_ALL);
(mpfr_clear_overflow) ();
MPFR_ASSERTN (! mpfr_overflow_p ());
(mpfr_clear_underflow) ();
MPFR_ASSERTN (! mpfr_underflow_p ());
(mpfr_clear_divby0) ();
MPFR_ASSERTN (! mpfr_divby0_p ());
(mpfr_clear_nanflag) ();
MPFR_ASSERTN (! mpfr_nanflag_p ());
(mpfr_clear_inexflag) ();
MPFR_ASSERTN (! mpfr_inexflag_p ());
(mpfr_clear_erangeflag) ();
MPFR_ASSERTN (! mpfr_erangeflag_p ());
MPFR_ASSERTN (__gmpfr_flags == 0);
}
/* Note: this test assumes that mpfr_flags_* can be implemented as both
a function and a macro. Thus in such a case, both implementations are
tested. */
static void
check_groups (void)
{
int i, j;
for (i = 0; i < 200; i++)
{
mpfr_flags_t f1, f2, mask;
f1 = __gmpfr_flags;
MPFR_ASSERTN (mpfr_flags_save () == f1);
MPFR_ASSERTN ((mpfr_flags_save) () == f1);
MPFR_ASSERTN (__gmpfr_flags == f1);
mask = randlimb () & MPFR_FLAGS_ALL;
if (randlimb () & 1)
mpfr_flags_set (mask);
else
(mpfr_flags_set) (mask);
for (j = 1; j <= MPFR_FLAGS_ALL; j <<= 1)
if ((__gmpfr_flags & j) != ((mask & j) != 0 ? j : (f1 & j)))
{
printf ("mpfr_flags_set error: old = 0x%lx, group = 0x%lx, "
"new = 0x%lx, j = 0x%lx\n",
(unsigned long) f1, (unsigned long) mask,
(unsigned long) __gmpfr_flags, (unsigned long) j);
exit (1);
}
f2 = __gmpfr_flags;
mask = randlimb () & MPFR_FLAGS_ALL;
if (randlimb () & 1)
mpfr_flags_clear (mask);
else
(mpfr_flags_clear) (mask);
for (j = 1; j <= MPFR_FLAGS_ALL; j <<= 1)
if ((__gmpfr_flags & j) != ((mask & j) != 0 ? 0 : (f2 & j)))
{
printf ("mpfr_flags_clear error: old = 0x%lx, group = 0x%lx, "
"new = 0x%lx, j = 0x%lx\n",
(unsigned long) f2, (unsigned long) mask,
(unsigned long) __gmpfr_flags, (unsigned long) j);
exit (1);
}
mask = randlimb () & MPFR_FLAGS_ALL;
f2 = (randlimb () & 1) ?
mpfr_flags_test (mask) : (mpfr_flags_test) (mask);
for (j = 1; j <= MPFR_FLAGS_ALL; j <<= 1)
if ((f2 & j) != ((mask & j) != 0 ? (__gmpfr_flags & j) : 0))
{
printf ("mpfr_flags_test error: current = 0x%lx, mask = 0x%lx, "
"res = 0x%lx, j = 0x%lx\n",
(unsigned long) __gmpfr_flags, (unsigned long) mask,
(unsigned long) f2, (unsigned long) j);
exit (1);
}
f2 = __gmpfr_flags;
if (randlimb () & 1)
mpfr_flags_restore (f1, mask);
else
(mpfr_flags_restore) (f1, mask);
for (j = 1; j <= MPFR_FLAGS_ALL; j <<= 1)
if ((__gmpfr_flags & j) != (((mask & j) != 0 ? f1 : f2) & j))
{
printf ("mpfr_flags_restore error: old = 0x%lx, flags = 0x%lx, "
"mask = 0x%lx, new = 0x%lx, j = 0x%lx\n",
(unsigned long) f2, (unsigned long) f1,
(unsigned long) mask, (unsigned long) __gmpfr_flags,
(unsigned long) j);
exit (1);
}
}
}
int
main (int argc, char *argv[])
{
mpfr_t x, y;
mpfr_exp_t emin, emax;
tests_start_mpfr ();
test_set_underflow ();
test_set_overflow ();
check_default_rnd();
mpfr_init (x);
mpfr_init (y);
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
if (emin >= emax)
{
printf ("Error: emin >= emax\n");
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_mul_2exp (x, x, 1024, MPFR_RNDN);
mpfr_set_double_range ();
mpfr_check_range (x, 0, MPFR_RNDN);
if (!mpfr_inf_p (x) || (mpfr_sgn(x) <= 0))
{
printf ("Error: 2^1024 rounded to nearest should give +Inf\n");
exit (1);
}
set_emax (1025);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_mul_2exp (x, x, 1024, MPFR_RNDN);
mpfr_set_double_range ();
mpfr_check_range (x, 0, MPFR_RNDD);
if (!mpfr_number_p (x))
{
printf ("Error: 2^1024 rounded down should give a normal number\n");
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_mul_2exp (x, x, 1023, MPFR_RNDN);
mpfr_add (x, x, x, MPFR_RNDN);
if (!mpfr_inf_p (x) || (mpfr_sgn(x) <= 0))
{
printf ("Error: x+x rounded to nearest for x=2^1023 should give +Inf\n");
printf ("emax = %ld\n", (long) mpfr_get_emax ());
printf ("got "); mpfr_dump (x);
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_mul_2exp (x, x, 1023, MPFR_RNDN);
mpfr_add (x, x, x, MPFR_RNDD);
if (!mpfr_number_p (x))
{
printf ("Error: x+x rounded down for x=2^1023 should give"
" a normal number\n");
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_div_2exp (x, x, 1022, MPFR_RNDN);
mpfr_set_str_binary (y, "1.1e-1022"); /* y = 3/2*x */
mpfr_sub (y, y, x, MPFR_RNDZ);
if (mpfr_cmp_ui (y, 0))
{
printf ("Error: y-x rounded to zero should give 0"
" for y=3/2*2^(-1022), x=2^(-1022)\n");
printf ("Got "); mpfr_dump (y);
exit (1);
}
set_emin (-1026);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_div_2exp (x, x, 1025, MPFR_RNDN);
mpfr_set_double_range ();
mpfr_check_range (x, 0, MPFR_RNDN);
if (!MPFR_IS_ZERO (x) )
{
printf ("Error: x rounded to nearest for x=2^-1024 should give Zero\n");
printf ("emin = %ld\n", (long) mpfr_get_emin ());
printf ("got "); mpfr_dump (x);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
set_emin (emin);
set_emax (emax);
check_emin_emax();
check_flags();
check_get_prec ();
check_powerof2 ();
check_set ();
check_groups ();
tests_end_mpfr ();
return 0;
}