int
main (int argc, char *argv[])
{
mpfr_t x;
FILE *f;
int i;
tests_start_mpfr ();
mpfr_init (x);
mpfr_set_prec (x, 15);
f = src_fopen ("inp_str.data", "r");
if (f == NULL)
{
printf ("Error, can't open inp_str.data\n");
exit (1);
}
i = mpfr_inp_str (x, f, 10, GMP_RNDN);
if (i == 0 || mpfr_cmp_ui (x, 31415))
{
printf ("Error in reading 1st line from file inp_str.data (%d)\n", i);
mpfr_dump (x);
exit (1);
}
getc (f);
i = mpfr_inp_str (x, f, 10, GMP_RNDN);
if ((i == 0) || mpfr_cmp_ui (x, 31416))
{
printf ("Error in reading 2nd line from file inp_str.data (%d)\n", i);
mpfr_dump (x);
exit (1);
}
getc (f);
i = mpfr_inp_str (x, f, 10, GMP_RNDN);
if (i != 0)
{
printf ("Error in reading 3rd line from file inp_str.data (%d)\n", i);
mpfr_dump (x);
exit (1);
}
fclose (f);
mpfr_clear (x);
tests_end_mpfr ();
return 0;
}
static void
check_regression (void)
{
mpfr_t x, y, z;
int i;
FILE *fp;
char s[BUFSIZE];
mpfr_inits2 (6177, x, y, z, (mpfr_ptr) 0);
/* we read long strings from a file since ISO C90 does not support strings of
length > 509 */
fp = src_fopen ("tmul.dat", "r");
if (fp == NULL)
{
fprintf (stderr, "Error, cannot open tmul.dat in srcdir\n");
exit (1);
}
get_string (s, fp);
mpfr_set_str (y, s, 16, MPFR_RNDN);
get_string (s, fp);
mpfr_set_str (z, s, 16, MPFR_RNDN);
i = mpfr_mul (x, y, z, MPFR_RNDN);
get_string (s, fp);
if (mpfr_cmp_str (x, s, 16, MPFR_RNDN) != 0 || i != -1)
{
printf ("Regression test 1 failed (i=%d, expected -1)\nx=", i);
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
fclose (fp);
mpfr_set_prec (x, 606);
mpfr_set_prec (y, 606);
mpfr_set_prec (z, 606);
mpfr_set_str (y, "-f.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff92daefc3f8052ca9f58736564d9e93e62d324@-1", 16, MPFR_RNDN);
mpfr_set_str (z, "-f.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff92daefc3f8052ca9f58736564d9e93e62d324@-1", 16, MPFR_RNDN);
i = mpfr_mul (x, y, z, MPFR_RNDU);
mpfr_set_str (y, "f.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff25b5df87f00a5953eb0e6cac9b3d27cc5a64c@-1", 16, MPFR_RNDN);
if (mpfr_cmp (x, y) || i <= 0)
{
printf ("Regression test (2) failed! (i=%d - Expected 1)\n", i);
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_set_prec (x, 184);
mpfr_set_prec (y, 92);
mpfr_set_prec (z, 1023);
mpfr_set_str (y, "6.9b8c8498882770d8038c3b0@-1", 16, MPFR_RNDN);
mpfr_set_str (z, "7.44e24b986e7fb296f1e936ce749fec3504cbf0d5ba769466b1c9f1578115efd5d29b4c79271191a920a99280c714d3a657ad6e3afbab77ffce9d697e9bb9110e26d676069afcea8b69f1d1541f2365042d80a97c21dcccd8ace4f1bb58b49922003e738e6f37bb82ef653cb2e87f763974e6ae50ae54e7724c38b80653e3289@255", 16, MPFR_RNDN);
i = mpfr_mul (x, y, z, MPFR_RNDU);
mpfr_set_prec (y, 184);
mpfr_set_str (y, "3.0080038f2ac5054e3e71ccbb95f76aaab2221715025a28@255",
16, MPFR_RNDN);
if (mpfr_cmp (x, y) || i <= 0)
{
printf ("Regression test (4) failed! (i=%d - expected 1)\n", i);
printf ("Ref: 3.0080038f2ac5054e3e71ccbb95f76aaab2221715025a28@255\n"
"Got: ");
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN);
printf ("\n");
exit (1);
}
mpfr_set_prec (x, 908);
mpfr_set_prec (y, 908);
mpfr_set_prec (z, 908);
mpfr_set_str (y, "-f.fffffffffffffffffffffffffffffffffffffffffffffffffffffff"
"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
"ffffffffffffffffffffffffffffffffffffffffffffffffffffff99be91f83ec6f0ed28a3d42"
"e6e9a327230345ea6@-1", 16, MPFR_RNDN);
mpfr_set_str (z, "-f.fffffffffffffffffffffffffffffffffffffffffffffffffffffff"
"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
"ffffffffffffffffffffffffffffffffffffffffffffffffffffff99be91f83ec6f0ed28a3d42"
"e6e9a327230345ea6@-1", 16, MPFR_RNDN);
i = mpfr_mul (x, y, z, MPFR_RNDU);
mpfr_set_str (y, "f.ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
"fffffffffffffffffffffffffffffffffffffffffffffffffffff337d23f07d8de1da5147a85c"
"dd3464e46068bd4d@-1", 16, MPFR_RNDN);
if (mpfr_cmp (x, y) || i <= 0)
{
printf ("Regression test (5) failed! (i=%d - expected 1)\n", i);
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN);
printf ("\n");
exit (1);
}
mpfr_set_prec (x, 50);
mpfr_set_prec (y, 40);
mpfr_set_prec (z, 53);
mpfr_set_str (y, "4.1ffffffff8", 16, MPFR_RNDN);
mpfr_set_str (z, "4.2000000ffe0000@-4", 16, MPFR_RNDN);
i = mpfr_mul (x, y, z, MPFR_RNDN);
if (mpfr_cmp_str (x, "1.104000041d6c0@-3", 16, MPFR_RNDN) != 0
|| i <= 0)
{
printf ("Regression test (6) failed! (i=%d - expected 1)\nx=", i);
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN);
printf ("\nMore prec=");
mpfr_set_prec (x, 93);
mpfr_mul (x, y, z, MPFR_RNDN);
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN);
printf ("\n");
exit (1);
}
mpfr_set_prec (x, 439);
mpfr_set_prec (y, 393);
mpfr_set_str (y, "-1.921fb54442d18469898cc51701b839a252049c1114cf98e804177d"
"4c76273644a29410f31c6809bbdf2a33679a748636600",
16, MPFR_RNDN);
i = mpfr_mul (x, y, y, MPFR_RNDU);
if (mpfr_cmp_str (x, "2.77a79937c8bbcb495b89b36602306b1c2159a8ff834288a19a08"
"84094f1cda3dc426da61174c4544a173de83c2500f8bfea2e0569e3698",
16, MPFR_RNDN) != 0
|| i <= 0)
{
printf ("Regression test (7) failed! (i=%d - expected 1)\nx=", i);
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN);
printf ("\n");
exit (1);
}
mpfr_set_prec (x, 1023);
mpfr_set_prec (y, 1023);
mpfr_set_prec (z, 511);
mpfr_set_ui (x, 17, MPFR_RNDN);
mpfr_set_ui (y, 42, MPFR_RNDN);
i = mpfr_mul (z, x, y, MPFR_RNDN);
if (mpfr_cmp_ui (z, 17*42) != 0 || i != 0)
{
printf ("Regression test (8) failed! (i=%d - expected 0)\nz=", i);
mpfr_out_str (stdout, 16, 0, z, MPFR_RNDN);
printf ("\n");
exit (1);
}
mpfr_clears (x, y, z, (mpfr_ptr) 0);
}
/* Check data in file f for function foo, with name 'name'.
Each line consists of the file f one:
xprec yprec rnd x y
where:
xprec is the input precision
yprec is the output precision
rnd is the rounding mode (n, z, u, d, a, Z, *)
x is the input (hexadecimal format)
y is the expected output (hexadecimal format) for foo(x) with rounding rnd
If rnd is Z, y is the expected output in round-toward-zero, and the
four directed rounding modes are tested, then the round-to-nearest
mode is tested in precision yprec-1. This is useful for worst cases,
where yprec is the minimum value such that one has a worst case in a
directed rounding mode.
If rnd is *, y must be an exact case. All the rounding modes are tested
and the ternary value is checked (it must be 0).
*/
void
data_check (const char *f, int (*foo) (FLIST), const char *name)
{
FILE *fp;
int xprec, yprec; /* not mpfr_prec_t because of the fscanf */
mpfr_t x, y, z;
mpfr_rnd_t rnd;
char r;
int c;
fp = fopen (f, "r");
if (fp == NULL)
fp = src_fopen (f, "r");
if (fp == NULL)
{
char *v = (char *) MPFR_VERSION_STRING;
/* In the '-dev' versions, assume that the data file exists and
return an error if the file cannot be opened to make sure
that such failures are detected. */
while (*v != '\0')
v++;
if (v[-4] == '-' && v[-3] == 'd' && v[-2] == 'e' && v[-1] == 'v')
{
printf ("Error: unable to open file '%s'\n", f);
exit (1);
}
else
return;
}
mpfr_init (x);
mpfr_init (y);
mpfr_init (z);
while (!feof (fp))
{
/* skip whitespace, for consistency */
if (fscanf (fp, " ") == EOF)
{
if (ferror (fp))
{
perror ("data_check");
exit (1);
}
else
break; /* end of file */
}
if ((c = getc (fp)) == EOF)
{
if (ferror (fp))
{
perror ("data_check");
exit (1);
}
else
break; /* end of file */
}
if (c == '#') /* comment: read entire line */
{
do
{
c = getc (fp);
}
while (!feof (fp) && c != '\n');
}
else
{
ungetc (c, fp);
c = fscanf (fp, "%d %d %c", &xprec, &yprec, &r);
MPFR_ASSERTN (xprec >= MPFR_PREC_MIN && xprec <= MPFR_PREC_MAX);
MPFR_ASSERTN (yprec >= MPFR_PREC_MIN && yprec <= MPFR_PREC_MAX);
if (c == EOF)
{
perror ("data_check");
exit (1);
}
else if (c != 3)
{
printf ("Error: corrupted line in file '%s'\n", f);
exit (1);
}
switch (r)
{
case 'n':
rnd = MPFR_RNDN;
break;
case 'z': case 'Z':
rnd = MPFR_RNDZ;
break;
case 'u':
rnd = MPFR_RNDU;
break;
case 'd':
rnd = MPFR_RNDD;
break;
case '*':
rnd = MPFR_RND_MAX; /* non-existing rounding mode */
break;
default:
printf ("Error: unexpected rounding mode"
" in file '%s': %c\n", f, (int) r);
exit (1);
}
mpfr_set_prec (x, xprec);
mpfr_set_prec (y, yprec);
if (mpfr_inp_str (x, fp, 0, MPFR_RNDN) == 0)
{
printf ("Error: corrupted argument in file '%s'\n", f);
exit (1);
}
if (mpfr_inp_str (y, fp, 0, MPFR_RNDN) == 0)
{
printf ("Error: corrupted result in file '%s'\n", f);
exit (1);
}
if (getc (fp) != '\n')
{
printf ("Error: result not followed by \\n in file '%s'\n", f);
exit (1);
}
/* Skip whitespace, in particular at the end of the file. */
if (fscanf (fp, " ") == EOF && ferror (fp))
{
perror ("data_check");
exit (1);
}
if (r == '*')
{
int rndint;
RND_LOOP (rndint)
test5rm (foo, x, y, z, (mpfr_rnd_t) rndint, 2, name);
}
else
test5rm (foo, x, y, z, rnd, r != 'Z', name);
}
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
fclose (fp);
}
int
main (int argc, char *argv[])
{
mpfr_t x;
mpfr_t y;
FILE *f;
int i;
tests_start_mpfr ();
mpfr_init (x);
mpfr_init (y);
mpfr_set_prec (x, 15);
f = src_fopen ("inp_str.data", "r");
if (f == NULL)
{
printf ("Error, can't open inp_str.data\n");
exit (1);
}
i = mpfr_inp_str (x, f, 10, MPFR_RNDN);
if (i == 0 || mpfr_cmp_ui (x, 31415))
{
printf ("Error in reading 1st line from file inp_str.data (%d)\n", i);
mpfr_dump (x);
exit (1);
}
getc (f);
i = mpfr_inp_str (x, f, 10, MPFR_RNDN);
if ((i == 0) || mpfr_cmp_ui (x, 31416))
{
printf ("Error in reading 2nd line from file inp_str.data (%d)\n", i);
mpfr_dump (x);
exit (1);
}
getc (f);
i = mpfr_inp_str (x, f, 10, MPFR_RNDN);
if (i != 0)
{
printf ("Error in reading 3rd line from file inp_str.data (%d)\n", i);
mpfr_dump (x);
exit (1);
}
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str (y, "1.0010010100001110100101001110011010111011100001110010e226",
2, MPFR_RNDN);
for (i = 2; i < 63; i++)
{
getc (f);
if (mpfr_inp_str (x, f, i, MPFR_RNDN) == 0 || !mpfr_equal_p (x, y))
{
printf ("Error in reading %dth line from file inp_str.data\n", i+2);
mpfr_dump (x);
exit (1);
}
mpfr_set_ui (x, 0, MPFR_RNDN);
}
fclose (f);
mpfr_clear (x);
mpfr_clear (y);
tests_end_mpfr ();
return 0;
}
int
main (int argc, char *argv[])
{
char *filenameCompressed = FILE_NAME_RW;
char *data = FILE_NAME_R;
int status;
FILE *fh;
mpfr_t x[9];
mpfr_t y;
unsigned char badData[6][2] =
{ { 7, 0 }, { 16, 0 }, { 23, 118 }, { 23, 95 }, { 23, 127 }, { 23, 47 } };
int badDataSize[6] = { 1, 1, 2, 2, 2, 2 };
int i;
if (argc != 1)
{
printf ("Usage: %s\n", argv[0]);
exit (1);
}
tests_start_mpfr ();
mpfr_init2 (x[0], 130);
mpfr_init2 (x[8], 130);
mpfr_inits2 (2048, x[1], x[2], x[3], x[4], x[5], x[6], x[7], (mpfr_ptr) 0);
mpfr_set_str1 (x[0], "45.2564215000000018562786863185465335845947265625");
mpfr_set_str1 (x[1], "45.2564215000000018562786863185465335845947265625");
mpfr_set_str1 (x[2], "45.2564215000000018562786863185465335845947265625");
mpfr_set_exp (x[2], -48000);
mpfr_set_inf (x[3], -1);
mpfr_set_zero (x[4], 0);
mpfr_set_nan (x[5]);
mpfr_set_ui (x[6], 104348, MPFR_RNDN);
mpfr_set_ui (x[7], 33215, MPFR_RNDN);
mpfr_div (x[8], x[6], x[7], MPFR_RNDN);
mpfr_div (x[6], x[6], x[7], MPFR_RNDN);
/* we first write to file FILE_NAME_RW the numbers x[i] */
fh = fopen (filenameCompressed, "w");
if (fh == NULL)
{
printf ("Failed to open for writing %s, exiting...\n",
filenameCompressed);
exit (1);
}
for (i = 0; i < 9; i++)
{
status = mpfr_fpif_export (fh, x[i]);
if (status != 0)
{
fclose (fh);
printf ("Failed to export number %d, exiting...\n", i);
exit (1);
}
}
fclose (fh);
/* we then read back FILE_NAME_RW and check we get the same numbers x[i] */
fh = fopen (filenameCompressed, "r");
if (fh == NULL)
{
printf ("Failed to open for reading %s, exiting...\n",
filenameCompressed);
exit (1);
}
for (i = 0; i < 9; i++)
{
mpfr_init2 (y, 2);
mpfr_fpif_import (y, fh);
if (mpfr_cmp(x[i], y) != 0)
{
printf ("mpfr_cmp failed on written number %d, exiting...\n", i);
printf ("expected "); mpfr_dump (x[i]);
printf ("got "); mpfr_dump (y);
exit (1);
}
mpfr_clear (y);
}
fclose (fh);
/* we do the same for the fixed file FILE_NAME_R, this ensures
we get same results with different word size or endianness */
fh = src_fopen (data, "r");
if (fh == NULL)
{
printf ("Failed to open for reading %s in srcdir, exiting...\n", data);
exit (1);
}
for (i = 0; i < 9; i++)
{
mpfr_init2 (y, 2);
mpfr_fpif_import (y, fh);
if (mpfr_cmp (x[i], y) != 0)
{
printf ("mpfr_cmp failed on data number %d, exiting...\n", i);
printf ("expected "); mpfr_dump (x[i]);
printf ("got "); mpfr_dump (y);
exit (1);
}
mpfr_clear (y);
}
fclose (fh);
for (i = 0; i < 9; i++)
mpfr_clear (x[i]);
remove (filenameCompressed);
mpfr_init2 (y, 2);
status = mpfr_fpif_export (NULL, y);
if (status == 0)
{
printf ("mpfr_fpif_export did not fail with a NULL file\n");
exit(1);
}
status = mpfr_fpif_import (y, NULL);
if (status == 0)
{
printf ("mpfr_fpif_import did not fail with a NULL file\n");
exit(1);
}
fh = fopen (filenameCompressed, "w+");
if (fh == NULL)
{
printf ("Failed to open for reading/writing %s, exiting...\n",
filenameCompressed);
fclose (fh);
remove (filenameCompressed);
exit (1);
}
status = mpfr_fpif_import (y, fh);
if (status == 0)
{
printf ("mpfr_fpif_import did not fail on a empty file\n");
fclose (fh);
remove (filenameCompressed);
exit(1);
}
for (i = 0; i < 6; i++)
{
rewind (fh);
status = fwrite (&badData[i][0], badDataSize[i], 1, fh);
if (status != 1)
{
printf ("Write error on the test file\n");
fclose (fh);
remove (filenameCompressed);
exit(1);
}
rewind (fh);
status = mpfr_fpif_import (y, fh);
if (status == 0)
{
printf ("mpfr_fpif_import did not fail on a bad imported data\n");
switch (i)
{
case 0:
printf (" not enough precision data\n");
break;
case 1:
printf (" no exponent data\n");
break;
case 2:
printf (" too big exponent\n");
break;
case 3:
printf (" not enough exponent data\n");
break;
case 4:
printf (" exponent data wrong\n");
break;
case 5:
printf (" no limb data\n");
break;
default:
printf ("Test fatal error, unknown case\n");
break;
}
fclose (fh);
remove (filenameCompressed);
exit(1);
}
}
fclose (fh);
mpfr_clear (y);
fh = fopen (filenameCompressed, "r");
if (fh == NULL)
{
printf ("Failed to open for reading %s, exiting...\n",
filenameCompressed);
exit (1);
}
mpfr_init2 (y, 2);
status = mpfr_fpif_export (fh, y);
if (status == 0)
{
printf ("mpfr_fpif_export did not fail on a read only stream\n");
exit(1);
}
fclose (fh);
remove (filenameCompressed);
mpfr_clear (y);
tests_end_mpfr ();
return 0;
}
