void
check_data (void)
{
static const struct {
int base;
const char *f;
long want;
} data[] = {
{ 10, "0", 0L },
{ 10, "1", 1L },
{ 10, "-1", -1L },
{ 10, "2", 2L },
{ 10, "-2", -2L },
{ 10, "12345", 12345L },
{ 10, "-12345", -12345L },
/* fraction bits ignored */
{ 10, "0.5", 0L },
{ 10, "-0.5", 0L },
{ 10, "1.1", 1L },
{ 10, "-1.1", -1L },
{ 10, "1.9", 1L },
{ 10, "-1.9", -1L },
{ 16, "1.000000000000000000000000000000000000000000000000001", 1L },
{ 16, "-1.000000000000000000000000000000000000000000000000001", -1L },
/* low bits extracted (this is undocumented) */
{ 16, "1000000000000000000000000000000000000000000000000001", 1L },
{ 16, "-1000000000000000000000000000000000000000000000000001", -1L },
};
int i;
mpf_t f;
long got;
mpf_init2 (f, 2000L);
for (i = 0; i < numberof (data); i++)
{
mpf_set_str_or_abort (f, data[i].f, data[i].base);
got = mpf_get_si (f);
if (got != data[i].want)
{
printf ("mpf_get_si wrong at data[%d]\n", i);
printf (" f \"%s\"\n", data[i].f);
printf (" dec "); mpf_out_str (stdout, 10, 0, f); printf ("\n");
printf (" hex "); mpf_out_str (stdout, 16, 0, f); printf ("\n");
printf (" size %ld\n", (long) SIZ(f));
printf (" exp %ld\n", (long) EXP(f));
printf (" got %ld (0x%lX)\n", got, got);
printf (" want %ld (0x%lX)\n", data[i].want, data[i].want);
abort();
}
}
mpf_clear (f);
}
void
check_f (void)
{
static const struct {
const char *fmt;
const char *input;
const char *want;
int ret;
long ftell; /* or -1 for length of input string */
} data[] = {
{ "%Ff", "0", "0", 1, -1 },
{ "%Fe", "0", "0", 1, -1 },
{ "%FE", "0", "0", 1, -1 },
{ "%Fg", "0", "0", 1, -1 },
{ "%FG", "0", "0", 1, -1 },
{ "%Ff", "123", "123", 1, -1 },
{ "%Ff", "+123", "123", 1, -1 },
{ "%Ff", "-123", "-123", 1, -1 },
{ "%Ff", "123.", "123", 1, -1 },
{ "%Ff", "+123.", "123", 1, -1 },
{ "%Ff", "-123.", "-123", 1, -1 },
{ "%Ff", "123.0", "123", 1, -1 },
{ "%Ff", "+123.0", "123", 1, -1 },
{ "%Ff", "-123.0", "-123", 1, -1 },
{ "%Ff", "0123", "123", 1, -1 },
{ "%Ff", "-0123", "-123", 1, -1 },
{ "%Ff", "123.456e3", "123456", 1, -1 },
{ "%Ff", "-123.456e3", "-123456", 1, -1 },
{ "%Ff", "123.456e+3", "123456", 1, -1 },
{ "%Ff", "-123.456e+3", "-123456", 1, -1 },
{ "%Ff", "123000e-3", "123", 1, -1 },
{ "%Ff", "-123000e-3", "-123", 1, -1 },
{ "%Ff", "123000.e-3", "123", 1, -1 },
{ "%Ff", "-123000.e-3", "-123", 1, -1 },
{ "%Ff", "123.456E3", "123456", 1, -1 },
{ "%Ff", "-123.456E3", "-123456", 1, -1 },
{ "%Ff", "123.456E+3", "123456", 1, -1 },
{ "%Ff", "-123.456E+3", "-123456", 1, -1 },
{ "%Ff", "123000E-3", "123", 1, -1 },
{ "%Ff", "-123000E-3", "-123", 1, -1 },
{ "%Ff", "123000.E-3", "123", 1, -1 },
{ "%Ff", "-123000.E-3", "-123", 1, -1 },
{ "%Ff", ".456e3", "456", 1, -1 },
{ "%Ff", "-.456e3", "-456", 1, -1 },
{ "%Ff", ".456e+3", "456", 1, -1 },
{ "%Ff", "-.456e+3", "-456", 1, -1 },
{ "%Ff", " 0", "0", 1, -1 },
{ "%Ff", " 0", "0", 1, -1 },
{ "%Ff", " 0", "0", 1, -1 },
{ "%Ff", "\t0", "0", 1, -1 },
{ "%Ff", "\t\t0", "0", 1, -1 },
{ "hello%Fg", "hello0", "0", 1, -1 },
{ "hello%Fg", "hello 0", "0", 1, -1 },
{ "hello%Fg", "hello \t0", "0", 1, -1 },
{ "hello%Fgworld", "hello 0world", "0", 1, -1 },
{ "hello%Fg", "hello3.0", "3.0", 1, -1 },
{ "hello%*Fg", "hello0", "-999", 0, -1 },
{ "hello%*Fg", "hello 0", "-999", 0, -1 },
{ "hello%*Fg", "hello \t0", "-999", 0, -1 },
{ "hello%*Fgworld", "hello 0world", "-999", 0, -1 },
{ "hello%*Fgworld", "hello3.0world", "-999", 0, -1 },
{ "%Ff", "", "-999", -1, -1 },
{ "%Ff", " ", "-999", -1, -1 },
{ "%Ff", "\t", "-999", -1, -1 },
{ "%Ff", " \t", "-999", -1, -1 },
{ " %Ff", "", "-999", -1, -1 },
{ "xyz%Ff", "", "-999", -1, -1 },
{ "%*Ff", "", "-999", -1, -1 },
{ " %*Ff", "", "-999", -1, -1 },
{ "xyz%*Ff", "", "-999", -1, -1 },
{ "%Ff", "xyz", "0", 0 },
/* various non-empty but invalid */
{ "%Ff", "-", "-999", 0, 1 },
{ "%Ff", "+", "-999", 0, 1 },
{ "xyz%Ff", "xyz-", "-999", 0, 4 },
{ "xyz%Ff", "xyz+", "-999", 0, 4 },
{ "%Ff", "-.", "-999", 0, 2 },
{ "%Ff", "+.", "-999", 0, 2 },
{ "%Ff", ".e", "-999", 0, 1 },
{ "%Ff", "-.e", "-999", 0, 2 },
{ "%Ff", "+.e", "-999", 0, 2 },
{ "%Ff", ".E", "-999", 0, 1 },
{ "%Ff", "-.E", "-999", 0, 2 },
{ "%Ff", "+.E", "-999", 0, 2 },
{ "%Ff", ".e123", "-999", 0, 1 },
{ "%Ff", "-.e123", "-999", 0, 2 },
{ "%Ff", "+.e123", "-999", 0, 2 },
{ "%Ff", "123e", "-999", 0, 4 },
{ "%Ff", "-123e", "-999", 0, 5 },
{ "%Ff", "123e-", "-999", 0, 5 },
{ "%Ff", "-123e-", "-999", 0, 6 },
{ "%Ff", "123e+", "-999", 0, 5 },
{ "%Ff", "-123e+", "-999", 0, 6 },
{ "%Ff", "123e-Z", "-999", 0, 5 },
/* hex floats */
{ "%Ff", "0x123p0", "291", 1, -1 },
{ "%Ff", "0x123P0", "291", 1, -1 },
{ "%Ff", "0X123p0", "291", 1, -1 },
{ "%Ff", "0X123P0", "291", 1, -1 },
{ "%Ff", "-0x123p0", "-291", 1, -1 },
{ "%Ff", "+0x123p0", "291", 1, -1 },
{ "%Ff", "0x123.p0", "291", 1, -1 },
{ "%Ff", "0x12.3p4", "291", 1, -1 },
{ "%Ff", "-0x12.3p4", "-291", 1, -1 },
{ "%Ff", "+0x12.3p4", "291", 1, -1 },
{ "%Ff", "0x1230p-4", "291", 1, -1 },
{ "%Ff", "-0x1230p-4", "-291", 1, -1 },
{ "%Ff", "+0x1230p-4", "291", 1, -1 },
{ "%Ff", "+0x.1230p12", "291", 1, -1 },
{ "%Ff", "+0x123000p-12", "291", 1, -1 },
{ "%Ff", "0x123 p12", "291", 1, 5 },
{ "%Ff", "0x9 9", "9", 1, 3 },
{ "%Ff", "0x01", "1", 1, 4 },
{ "%Ff", "0x23", "35", 1, 4 },
{ "%Ff", "0x45", "69", 1, 4 },
{ "%Ff", "0x67", "103", 1, 4 },
{ "%Ff", "0x89", "137", 1, 4 },
{ "%Ff", "0xAB", "171", 1, 4 },
{ "%Ff", "0xCD", "205", 1, 4 },
{ "%Ff", "0xEF", "239", 1, 4 },
{ "%Ff", "0xab", "171", 1, 4 },
{ "%Ff", "0xcd", "205", 1, 4 },
{ "%Ff", "0xef", "239", 1, 4 },
{ "%Ff", "0x100p0A", "256", 1, 7 },
{ "%Ff", "0x1p9", "512", 1, -1 },
/* invalid hex floats */
{ "%Ff", "0x", "-999", 0, 2 },
{ "%Ff", "-0x", "-999", 0, 3 },
{ "%Ff", "+0x", "-999", 0, 3 },
{ "%Ff", "0x-", "-999", 0, 2 },
{ "%Ff", "0x+", "-999", 0, 2 },
{ "%Ff", "0x.", "-999", 0, 3 },
{ "%Ff", "-0x.", "-999", 0, 4 },
{ "%Ff", "+0x.", "-999", 0, 4 },
{ "%Ff", "0x.p", "-999", 0, 3 },
{ "%Ff", "-0x.p", "-999", 0, 4 },
{ "%Ff", "+0x.p", "-999", 0, 4 },
{ "%Ff", "0x.P", "-999", 0, 3 },
{ "%Ff", "-0x.P", "-999", 0, 4 },
{ "%Ff", "+0x.P", "-999", 0, 4 },
{ "%Ff", ".p123", "-999", 0, 1 },
{ "%Ff", "-.p123", "-999", 0, 2 },
{ "%Ff", "+.p123", "-999", 0, 2 },
{ "%Ff", "0x1p", "-999", 0, 4 },
{ "%Ff", "0x1p-", "-999", 0, 5 },
{ "%Ff", "0x1p+", "-999", 0, 5 },
{ "%Ff", "0x123p 12", "291", 0, 6 },
{ "%Ff", "0x 123p12", "291", 0, 2 },
};
int i, j, ignore, got_ret, want_ret, got_upto, want_upto;
mpf_t got, want;
double got_d;
long want_ftell;
int error = 0;
fun_t fun;
const char *name;
char fmt[128];
mpf_init (got);
mpf_init (want);
for (i = 0; i < numberof (data); i++)
{
mpf_set_str_or_abort (want, data[i].want, 10);
ASSERT_ALWAYS (strlen (data[i].fmt) + 2 < sizeof (fmt));
strcpy (fmt, data[i].fmt);
strcat (fmt, "%n");
ignore = (strchr (fmt, '*') != NULL);
for (j = 0; j <= 3; j++)
{
want_ret = data[i].ret;
want_ftell = data[i].ftell;
if (want_ftell == -1)
want_ftell = strlen (data[i].input);
want_upto = want_ftell;
if (want_ret == -1 || (want_ret == 0 && ! ignore))
want_upto = -555;
switch (j) {
case 0:
name = "gmp_sscanf";
fun = fun_gmp_sscanf;
break;
case 1:
name = "gmp_fscanf";
fun = fun_gmp_fscanf;
break;
case 2:
if (! libc_scanf_convert (fmt))
continue;
name = "standard sscanf";
fun = fun_sscanf;
break;
case 3:
if (! libc_scanf_convert (fmt))
continue;
name = "standard fscanf";
fun = fun_fscanf;
break;
default:
ASSERT_ALWAYS (0);
break;
}
got_upto = -555;
got_ftell = -1;
switch (j) {
case 0:
case 1:
mpf_set_si (got, -999L);
if (ignore)
got_ret = (*fun) (data[i].input, fmt, &got_upto, NULL);
else
got_ret = (*fun) (data[i].input, fmt, got, &got_upto);
break;
case 2:
case 3:
got_d = -999L;
if (ignore)
got_ret = (*fun) (data[i].input, fmt, &got_upto, NULL);
else
got_ret = (*fun) (data[i].input, fmt, &got_d, &got_upto);
mpf_set_d (got, got_d);
break;
default:
ASSERT_ALWAYS (0);
break;
}
MPF_CHECK_FORMAT (got);
if (got_ret != want_ret)
{
printf ("%s wrong return value\n", name);
error = 1;
}
if (want_ret == 1 && mpf_cmp (want, got) != 0)
{
printf ("%s wrong result\n", name);
error = 1;
}
if (got_upto != want_upto)
{
printf ("%s wrong upto\n", name);
error = 1;
}
if (got_ftell != -1 && want_ftell != -1 && got_ftell != want_ftell)
{
printf ("%s wrong ftell\n", name);
error = 1;
}
if (error)
{
printf (" fmt \"%s\"\n", data[i].fmt);
printf (" input \"%s\"\n", data[i].input);
printf (" ret want=%d\n", want_ret);
printf (" got =%d\n", got_ret);
mpf_trace (" value want", want);
mpf_trace (" got ", got);
printf (" upto want=%d\n", want_upto);
printf (" got =%d\n", got_upto);
if (got_ftell != -1)
{
printf (" ftell want =%ld\n", want_ftell);
printf (" got =%ld\n", got_ftell);
}
abort ();
}
}
}
mpf_clear (got);
mpf_clear (want);
}
int
main (int argc, char **argv)
{
#if GMP_NAIL_BITS == 0
static const struct {
int f_base;
const char *f;
int z_base;
const char *want_num;
const char *want_den;
} data[] = {
{ -2, "0", 16, "0", "1" },
{ -2, "1", 16, "1", "1" },
{ -2, "1@1", 16, "2", "1" },
{ -2, "1@2", 16, "4", "1" },
{ -2, "1@3", 16, "8", "1" },
{ -2, "1@30", 16, "40000000", "1" },
{ -2, "1@31", 16, "80000000", "1" },
{ -2, "1@32", 16, "100000000", "1" },
{ -2, "1@33", 16, "200000000", "1" },
{ -2, "1@34", 16, "400000000", "1" },
{ -2, "1@62", 16, "4000000000000000", "1" },
{ -2, "1@63", 16, "8000000000000000", "1" },
{ -2, "1@64", 16, "10000000000000000", "1" },
{ -2, "1@65", 16, "20000000000000000", "1" },
{ -2, "1@66", 16, "40000000000000000", "1" },
{ -2, "1@126", 16, "40000000000000000000000000000000", "1" },
{ -2, "1@127", 16, "80000000000000000000000000000000", "1" },
{ -2, "1@128", 16, "100000000000000000000000000000000", "1" },
{ -2, "1@129", 16, "200000000000000000000000000000000", "1" },
{ -2, "1@130", 16, "400000000000000000000000000000000", "1" },
{ -2, "1@-1", 16, "1", "2" },
{ -2, "1@-2", 16, "1", "4" },
{ -2, "1@-3", 16, "1", "8" },
{ -2, "1@-30", 16, "1", "40000000" },
{ -2, "1@-31", 16, "1", "80000000" },
{ -2, "1@-32", 16, "1", "100000000" },
{ -2, "1@-33", 16, "1", "200000000" },
{ -2, "1@-34", 16, "1", "400000000" },
{ -2, "1@-62", 16, "1", "4000000000000000" },
{ -2, "1@-63", 16, "1", "8000000000000000" },
{ -2, "1@-64", 16, "1", "10000000000000000" },
{ -2, "1@-65", 16, "1", "20000000000000000" },
{ -2, "1@-66", 16, "1", "40000000000000000" },
{ -2, "1@-126", 16, "1", "40000000000000000000000000000000" },
{ -2, "1@-127", 16, "1", "80000000000000000000000000000000" },
{ -2, "1@-128", 16, "1", "100000000000000000000000000000000" },
{ -2, "1@-129", 16, "1", "200000000000000000000000000000000" },
{ -2, "1@-130", 16, "1", "400000000000000000000000000000000" },
{ -2, "1@-30", 16, "1", "40000000" },
{ -2, "1@-31", 16, "1", "80000000" },
{ -2, "1@-32", 16, "1", "100000000" },
{ -2, "1@-33", 16, "1", "200000000" },
{ -2, "1@-34", 16, "1", "400000000" },
{ -2, "11@-62", 16, "3", "4000000000000000" },
{ -2, "11@-63", 16, "3", "8000000000000000" },
{ -2, "11@-64", 16, "3", "10000000000000000" },
{ -2, "11@-65", 16, "3", "20000000000000000" },
{ -2, "11@-66", 16, "3", "40000000000000000" },
{ 16, "80000000.00000001", 16, "8000000000000001", "100000000" },
{ 16, "80000000.00000008", 16, "1000000000000001", "20000000" },
{ 16, "80000000.8", 16, "100000001", "2" },
};
mpf_t f;
mpq_t got;
mpz_t want_num, want_den;
int i, neg;
tests_start ();
mpf_init2 (f, 1024L);
mpq_init (got);
mpz_init (want_num);
mpz_init (want_den);
for (i = 0; i < numberof (data); i++)
{
for (neg = 0; neg <= 1; neg++)
{
mpf_set_str_or_abort (f, data[i].f, data[i].f_base);
mpz_set_str_or_abort (want_num, data[i].want_num, data[i].z_base);
mpz_set_str_or_abort (want_den, data[i].want_den, data[i].z_base);
if (neg)
{
mpf_neg (f, f);
mpz_neg (want_num, want_num);
}
mpq_set_f (got, f);
MPQ_CHECK_FORMAT (got);
if (mpz_cmp (mpq_numref(got), want_num) != 0
|| mpz_cmp (mpq_denref(got), want_den) != 0)
{
printf ("wrong at data[%d]\n", i);
printf (" f_base %d, z_base %d\n",
data[i].f_base, data[i].z_base);
printf (" f \"%s\" hex ", data[i].f);
mpf_out_str (stdout, 16, 0, f);
printf ("\n");
printf (" want num 0x");
mpz_out_str (stdout, 16, want_num);
printf ("\n");
printf (" want den 0x");
mpz_out_str (stdout, 16, want_den);
printf ("\n");
printf (" got num 0x");
mpz_out_str (stdout, 16, mpq_numref(got));
printf ("\n");
printf (" got den 0x");
mpz_out_str (stdout, 16, mpq_denref(got));
printf ("\n");
abort ();
}
}
}
mpf_clear (f);
mpq_clear (got);
mpz_clear (want_num);
mpz_clear (want_den);
tests_end ();
#endif
exit (0);
}
void
check_data (void)
{
static const struct {
int a_base;
const char *a;
const char *b;
int want;
} data[] = {
{ 10, "0", "1", -1 },
{ 10, "0", "0", 0 },
{ 10, "0", "-1", 1 },
{ 10, "1", "1", 0 },
{ 10, "1", "0", 1 },
{ 10, "1", "-1", 1 },
{ 10, "-1", "1", -1 },
{ 10, "-1", "0", -1 },
{ 10, "-1", "-1", 0 },
{ 16, "0", "-0x80000000", 1 },
{ 16, "80000000", "-0x80000000", 1 },
{ 16, "80000001", "-0x80000000", 1 },
{ 16, "-80000000", "-0x80000000", 0 },
{ 16, "-80000001", "-0x80000000", -1 },
{ 16, "-FF0080000001", "-0x80000000", -1 },
{ 16, "0", "-0x8000000000000000", 1 },
{ 16, "8000000000000000", "-0x8000000000000000", 1 },
{ 16, "8000000000000001", "-0x8000000000000000", 1 },
{ 16, "-8000000000000000", "-0x8000000000000000", 0 },
{ 16, "-8000000000000001", "-0x8000000000000000", -1 },
{ 16, "-FF008000000000000001", "-0x8000000000000000", -1 },
};
mpf_t a;
mpz_t bz;
long b;
int got;
int i;
mpf_init (a);
mpz_init (bz);
for (i = 0; i < numberof (data); i++)
{
mpf_set_str_or_abort (a, data[i].a, data[i].a_base);
mpz_set_str_or_abort (bz, data[i].b, 0);
if (mpz_fits_slong_p (bz))
{
b = mpz_get_si (bz);
got = mpf_cmp_si (a, b);
if (SGN (got) != data[i].want)
{
printf ("mpf_cmp_si wrong on data[%d]\n", i);
printf (" a="); mpf_out_str (stdout, 10, 0, a);
printf (" (%s)\n", data[i].a);
printf (" b=%ld (%s)\n", b, data[i].b);
printf (" got=%d\n", got);
printf (" want=%d\n", data[i].want);
abort();
}
}
}
mpf_clear (a);
mpz_clear (bz);
}
int
main (int argc, char **argv)
{
mpf_t x, y;
int reps = 20000;
int i;
mp_size_t bprec = 100;
mpf_t d, rerr, max_rerr, limit_rerr;
char *str;
mp_exp_t bexp;
long size, exp;
int base;
char buf[SIZE * GMP_LIMB_BITS + 5];
tests_start ();
if (argc > 1)
{
reps = strtol (argv[1], 0, 0);
if (argc > 2)
bprec = strtol (argv[2], 0, 0);
}
mpf_set_default_prec (bprec);
mpf_init_set_ui (limit_rerr, 1);
mpf_div_2exp (limit_rerr, limit_rerr, bprec);
#if VERBOSE
mpf_dump (limit_rerr);
#endif
mpf_init (rerr);
mpf_init_set_ui (max_rerr, 0);
mpf_init (x);
mpf_init (y);
mpf_init (d);
/* First test some specific values. */
mpf_set_str (y, "1.23456e1000", 0);
mpf_set_str (x, "1.23456e1000", 10);
if (mpf_cmp (x, y) != 0)
abort ();
mpf_set_str (x, "1.23456e+1000", 0);
if (mpf_cmp (x, y) != 0)
abort ();
mpf_set_str (x, "1.23456e+1000", 10);
if (mpf_cmp (x, y) != 0)
abort ();
/* Now test random values. */
for (i = 0; i < reps; i++)
{
if (i == 0)
{
/* exercise the special case in get_str for for x==0 */
mpf_set_ui (x, 0L);
base = 10;
}
else
{
size = urandom () % (2 * SIZE) - SIZE;
exp = urandom () % EXPO;
mpf_random2 (x, size, exp);
base = urandom () % 61 + 2;
}
str = mpf_get_str (0, &bexp, base, 0, x);
if (str[0] == '-')
sprintf (buf, "-0.%s@%ld", str + 1, bexp);
else
sprintf (buf, "0.%s@%ld", str, bexp);
mpf_set_str_or_abort (y, buf, -base);
(*__gmp_free_func) (str, strlen (str) + 1);
mpf_reldiff (rerr, x, y);
if (mpf_cmp (rerr, max_rerr) > 0)
{
mpf_set (max_rerr, rerr);
#if VERBOSE
mpf_dump (max_rerr);
#endif
if (mpf_cmp (rerr, limit_rerr) > 0)
{
printf ("ERROR after %d tests\n", i);
printf ("base = %d\n", base);
printf (" x = ");
mpf_dump (x);
printf (" y = ");
mpf_dump (y);
abort ();
}
}
}
mpf_clear (limit_rerr);
mpf_clear (rerr);
mpf_clear (max_rerr);
mpf_clear (x);
mpf_clear (y);
mpf_clear (d);
tests_end ();
exit (0);
}
int
main (void)
{
mpf_t f, f0p5;
int got;
const char *expr;
int error = 0;
tests_start ();
mpf_init2 (f, 200L);
mpf_init2 (f0p5, 200L);
/* 0.5 */
mpf_set_ui (f0p5, 1L);
mpf_div_2exp (f0p5, f0p5, 1L);
mpf_set_ui (f, 0L);
expr = "0";
EXPECT (mpf_fits_ulong_p, 1);
EXPECT (mpf_fits_uint_p, 1);
EXPECT (mpf_fits_ushort_p, 1);
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_ui (f, 1L);
expr = "1";
EXPECT (mpf_fits_ulong_p, 1);
EXPECT (mpf_fits_uint_p, 1);
EXPECT (mpf_fits_ushort_p, 1);
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_si (f, -1L);
expr = "-1";
EXPECT (mpf_fits_ulong_p, 0);
EXPECT (mpf_fits_uint_p, 0);
EXPECT (mpf_fits_ushort_p, 0);
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_ui (f, (unsigned long) USHRT_MAX);
expr = "USHRT_MAX";
EXPECT (mpf_fits_ulong_p, 1);
EXPECT (mpf_fits_uint_p, 1);
EXPECT (mpf_fits_ushort_p, 1);
mpf_set_ui (f, (unsigned long) USHRT_MAX);
mpf_add (f, f, f0p5);
expr = "USHRT_MAX + 0.5";
EXPECT (mpf_fits_ulong_p, 1);
EXPECT (mpf_fits_uint_p, 1);
EXPECT (mpf_fits_ushort_p, 1);
mpf_set_ui (f, (unsigned long) USHRT_MAX);
mpf_add_ui (f, f, 1L);
expr = "USHRT_MAX + 1";
EXPECT (mpf_fits_ushort_p, 0);
mpf_set_ui (f, (unsigned long) UINT_MAX);
expr = "UINT_MAX";
EXPECT (mpf_fits_ulong_p, 1);
EXPECT (mpf_fits_uint_p, 1);
mpf_set_ui (f, (unsigned long) UINT_MAX);
mpf_add (f, f, f0p5);
expr = "UINT_MAX + 0.5";
EXPECT (mpf_fits_ulong_p, 1);
EXPECT (mpf_fits_uint_p, 1);
mpf_set_ui (f, (unsigned long) UINT_MAX);
mpf_add_ui (f, f, 1L);
expr = "UINT_MAX + 1";
EXPECT (mpf_fits_uint_p, 0);
mpf_set_ui (f, ULONG_MAX);
expr = "ULONG_MAX";
EXPECT (mpf_fits_ulong_p, 1);
mpf_set_ui (f, ULONG_MAX);
mpf_add (f, f, f0p5);
expr = "ULONG_MAX + 0.5";
EXPECT (mpf_fits_ulong_p, 1);
mpf_set_ui (f, ULONG_MAX);
mpf_add_ui (f, f, 1L);
expr = "ULONG_MAX + 1";
EXPECT (mpf_fits_ulong_p, 0);
mpf_set_si (f, (long) SHRT_MAX);
expr = "SHRT_MAX";
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_si (f, (long) SHRT_MAX);
expr = "SHRT_MAX + 0.5";
mpf_add (f, f, f0p5);
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_si (f, (long) SHRT_MAX);
mpf_add_ui (f, f, 1L);
expr = "SHRT_MAX + 1";
EXPECT (mpf_fits_sshort_p, 0);
mpf_set_si (f, (long) INT_MAX);
expr = "INT_MAX";
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
mpf_set_si (f, (long) INT_MAX);
mpf_add (f, f, f0p5);
expr = "INT_MAX + 0.5";
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
mpf_set_si (f, (long) INT_MAX);
mpf_add_ui (f, f, 1L);
expr = "INT_MAX + 1";
EXPECT (mpf_fits_sint_p, 0);
mpf_set_si (f, LONG_MAX);
expr = "LONG_MAX";
EXPECT (mpf_fits_slong_p, 1);
mpf_set_si (f, LONG_MAX);
mpf_add (f, f, f0p5);
expr = "LONG_MAX + 0.5";
EXPECT (mpf_fits_slong_p, 1);
mpf_set_si (f, LONG_MAX);
mpf_add_ui (f, f, 1L);
expr = "LONG_MAX + 1";
EXPECT (mpf_fits_slong_p, 0);
mpf_set_si (f, (long) SHRT_MIN);
expr = "SHRT_MIN";
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_si (f, (long) SHRT_MIN);
mpf_sub (f, f, f0p5);
expr = "SHRT_MIN - 0.5";
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_si (f, (long) SHRT_MIN);
mpf_sub_ui (f, f, 1L);
expr = "SHRT_MIN + 1";
EXPECT (mpf_fits_sshort_p, 0);
mpf_set_si (f, (long) INT_MIN);
expr = "INT_MIN";
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
mpf_set_si (f, (long) INT_MIN);
mpf_sub (f, f, f0p5);
expr = "INT_MIN - 0.5";
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
mpf_set_si (f, (long) INT_MIN);
mpf_sub_ui (f, f, 1L);
expr = "INT_MIN + 1";
EXPECT (mpf_fits_sint_p, 0);
mpf_set_si (f, LONG_MIN);
expr = "LONG_MIN";
EXPECT (mpf_fits_slong_p, 1);
mpf_set_si (f, LONG_MIN);
mpf_sub (f, f, f0p5);
expr = "LONG_MIN - 0.5";
EXPECT (mpf_fits_slong_p, 1);
mpf_set_si (f, LONG_MIN);
mpf_sub_ui (f, f, 1L);
expr = "LONG_MIN + 1";
EXPECT (mpf_fits_slong_p, 0);
mpf_set_str_or_abort (f, "0.5", 10);
expr = "0.5";
EXPECT (mpf_fits_ulong_p, 1);
EXPECT (mpf_fits_uint_p, 1);
EXPECT (mpf_fits_ushort_p, 1);
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_str_or_abort (f, "-0.5", 10);
expr = "-0.5";
EXPECT (mpf_fits_ulong_p, 0);
EXPECT (mpf_fits_uint_p, 0);
EXPECT (mpf_fits_ushort_p, 0);
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_str_or_abort (f, "1.000000000000000000000000000000000001", 16);
expr = "1.000000000000000000000000000000000001 base 16";
EXPECT (mpf_fits_ulong_p, 1);
EXPECT (mpf_fits_uint_p, 1);
EXPECT (mpf_fits_ushort_p, 1);
EXPECT (mpf_fits_slong_p, 1);
EXPECT (mpf_fits_sint_p, 1);
EXPECT (mpf_fits_sshort_p, 1);
mpf_set_str_or_abort (f, "1@1000", 16);
expr = "1@1000 base 16";
EXPECT (mpf_fits_ulong_p, 0);
EXPECT (mpf_fits_uint_p, 0);
EXPECT (mpf_fits_ushort_p, 0);
EXPECT (mpf_fits_slong_p, 0);
EXPECT (mpf_fits_sint_p, 0);
EXPECT (mpf_fits_sshort_p, 0);
mpf_set_ui (f, 1L);
mpf_mul_2exp (f, f, BITS_PER_ULONG + 1);
mpf_sub_ui (f, f, 1L);
expr = "2^(BITS_PER_ULONG+1) - 1";
EXPECT (mpf_fits_ulong_p, 0);
EXPECT (mpf_fits_uint_p, 0);
EXPECT (mpf_fits_ushort_p, 0);
EXPECT (mpf_fits_slong_p, 0);
EXPECT (mpf_fits_sint_p, 0);
EXPECT (mpf_fits_sshort_p, 0);
mpf_set_ui (f, 1L);
mpf_mul_2exp (f, f, BITS_PER_ULONG + 1);
mpf_sub_ui (f, f, 1L);
mpf_neg (f, f);
expr = "- (2^(BITS_PER_ULONG+1) - 1)";
EXPECT (mpf_fits_ulong_p, 0);
EXPECT (mpf_fits_uint_p, 0);
EXPECT (mpf_fits_ushort_p, 0);
EXPECT (mpf_fits_slong_p, 0);
EXPECT (mpf_fits_sint_p, 0);
EXPECT (mpf_fits_sshort_p, 0);
mpf_set_ui (f, 1L);
mpf_mul_2exp (f, f, BITS_PER_ULONG + 5);
mpf_sub_ui (f, f, 1L);
expr = "2^(BITS_PER_ULONG+5) - 1";
EXPECT (mpf_fits_ulong_p, 0);
EXPECT (mpf_fits_uint_p, 0);
EXPECT (mpf_fits_ushort_p, 0);
EXPECT (mpf_fits_slong_p, 0);
EXPECT (mpf_fits_sint_p, 0);
EXPECT (mpf_fits_sshort_p, 0);
if (error)
abort ();
mpf_clear (f);
mpf_clear (f0p5);
tests_end ();
exit (0);
}
void
check_f (void)
{
static const struct {
const char *fmt;
const char *f;
const char *want;
} data[] = {
{ "%Ff", "0", "0.000000" },
{ "%Ff", "123", "123.000000" },
{ "%Ff", "-123", "-123.000000" },
{ "%+Ff", "0", "+0.000000" },
{ "%+Ff", "123", "+123.000000" },
{ "%+Ff", "-123", "-123.000000" },
{ "%.0Ff", "0", "0" },
{ "%.0Ff", "123", "123" },
{ "%.0Ff", "-123", "-123" },
{ "%8.0Ff", "0", " 0" },
{ "%8.0Ff", "123", " 123" },
{ "%8.0Ff", "-123", " -123" },
{ "%08.0Ff", "0", "00000000" },
{ "%08.0Ff", "123", "00000123" },
{ "%08.0Ff", "-123", "-0000123" },
{ "%10.2Ff", "0", " 0.00" },
{ "%10.2Ff", "0.25", " 0.25" },
{ "%10.2Ff", "123.25", " 123.25" },
{ "%10.2Ff", "-123.25", " -123.25" },
{ "%-10.2Ff", "0", "0.00 " },
{ "%-10.2Ff", "0.25", "0.25 " },
{ "%-10.2Ff", "123.25", "123.25 " },
{ "%-10.2Ff", "-123.25", "-123.25 " },
{ "%.2Ff", "0.00000000000001", "0.00" },
{ "%.2Ff", "0.002", "0.00" },
{ "%.2Ff", "0.008", "0.01" },
{ "%.0Ff", "123.00000000000001", "123" },
{ "%.0Ff", "123.2", "123" },
{ "%.0Ff", "123.8", "124" },
{ "%.0Ff", "999999.9", "1000000" },
{ "%.0Ff", "3999999.9", "4000000" },
{ "%Fe", "0", "0.000000e+00" },
{ "%Fe", "1", "1.000000e+00" },
{ "%Fe", "123", "1.230000e+02" },
{ "%FE", "0", "0.000000E+00" },
{ "%FE", "1", "1.000000E+00" },
{ "%FE", "123", "1.230000E+02" },
{ "%Fe", "0", "0.000000e+00" },
{ "%Fe", "1", "1.000000e+00" },
{ "%.0Fe", "10000000000", "1e+10" },
{ "%.0Fe", "-10000000000", "-1e+10" },
{ "%.2Fe", "10000000000", "1.00e+10" },
{ "%.2Fe", "-10000000000", "-1.00e+10" },
{ "%8.0Fe", "10000000000", " 1e+10" },
{ "%8.0Fe", "-10000000000", " -1e+10" },
{ "%-8.0Fe", "10000000000", "1e+10 " },
{ "%-8.0Fe", "-10000000000", "-1e+10 " },
{ "%12.2Fe", "10000000000", " 1.00e+10" },
{ "%12.2Fe", "-10000000000", " -1.00e+10" },
{ "%012.2Fe", "10000000000", "00001.00e+10" },
{ "%012.2Fe", "-10000000000", "-0001.00e+10" },
{ "%Fg", "0", "0" },
{ "%Fg", "1", "1" },
{ "%Fg", "-1", "-1" },
{ "%.0Fg", "0", "0" },
{ "%.0Fg", "1", "1" },
{ "%.0Fg", "-1", "-1" },
{ "%.1Fg", "100", "1e+02" },
{ "%.2Fg", "100", "1e+02" },
{ "%.3Fg", "100", "100" },
{ "%.4Fg", "100", "100" },
{ "%Fg", "0.001", "0.001" },
{ "%Fg", "0.0001", "0.0001" },
{ "%Fg", "0.00001", "1e-05" },
{ "%Fg", "0.000001", "1e-06" },
{ "%.4Fg", "1.00000000000001", "1" },
{ "%.4Fg", "100000000000001", "1e+14" },
{ "%.4Fg", "12345678", "1.235e+07" },
{ "%Fa", "0","0x0p+0" },
{ "%FA", "0","0X0P+0" },
{ "%Fa", "1","0x1p+0" },
{ "%Fa", "65535","0xf.fffp+12" },
{ "%Fa", "65536","0x1p+16" },
{ "%F.10a", "65536","0x1.0000000000p+16" },
{ "%F.1a", "65535","0x1.0p+16" },
{ "%F.0a", "65535","0x1p+16" },
{ "%.2Ff", "0.99609375", "1.00" },
{ "%.Ff", "0.99609375", "0.99609375" },
{ "%.Fe", "0.99609375", "9.9609375e-01" },
{ "%.Fg", "0.99609375", "0.99609375" },
{ "%.20Fg", "1000000", "1000000" },
{ "%.Fg", "1000000", "1000000" },
{ "%#.0Ff", "1", "1." },
{ "%#.0Fe", "1", "1.e+00" },
{ "%#.0Fg", "1", "1." },
{ "%#.1Ff", "1", "1.0" },
{ "%#.1Fe", "1", "1.0e+00" },
{ "%#.1Fg", "1", "1." },
{ "%#.4Ff", "1234", "1234.0000" },
{ "%#.4Fe", "1234", "1.2340e+03" },
{ "%#.4Fg", "1234", "1234." },
{ "%#.8Ff", "1234", "1234.00000000" },
{ "%#.8Fe", "1234", "1.23400000e+03" },
{ "%#.8Fg", "1234", "1234.0000" },
};
int i;
mpf_t f;
double d;
mpf_init2 (f, 256L);
for (i = 0; i < numberof (data); i++)
{
if (data[i].f[0] == '0' && data[i].f[1] == 'x')
mpf_set_str_or_abort (f, data[i].f, 16);
else
mpf_set_str_or_abort (f, data[i].f, 10);
/* if mpf->double doesn't truncate, then expect same result */
d = mpf_get_d (f);
if (mpf_cmp_d (f, d) == 0)
check_plain (data[i].want, data[i].fmt, d);
check_one (data[i].want, data[i].fmt, f);
}
mpf_clear (f);
}
