/* From a bug reported by Joseph S. Myers
https://sympa.inria.fr/sympa/arc/mpfr/2012-08/msg00005.html */
static void
bug20120814 (void)
{
mpfr_exp_t emin = -30, e;
mpfr_t x, y;
int r;
char s[64], *p;
mpfr_init2 (x, 2);
mpfr_set_ui_2exp (x, 3, emin - 2, MPFR_RNDN);
mpfr_get_str (s + 1, &e, 10, 19, x, MPFR_RNDD);
s[0] = s[1];
s[1] = '.';
for (p = s; *p != 0; p++) ;
*p = 'e';
sprintf (p + 1, "%d", (int) e - 1);
mpfr_init2 (y, 4);
r = mpfr_strtofr (y, s, NULL, 0, MPFR_RNDN);
if (r <= 0 || ! mpfr_equal_p (x, y))
{
printf ("Error in bug20120814\n");
printf ("mpfr_strtofr failed on string \"%s\"\n", s);
printf ("Expected inex > 0 and y = 0.1100E%d\n", (int) emin);
printf ("Got inex = %-6d and y = ", r);
mpfr_dump (y);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
}
void
mpfr_set_str_binary (mpfr_ptr x, const char *str)
{
int has_sign;
int res;
if (*str == 'N')
{
MPFR_SET_NAN(x);
__gmpfr_flags |= MPFR_FLAGS_NAN;
return;
}
has_sign = *str == '-' || *str == '+';
if (str[has_sign] == 'I')
{
MPFR_SET_INF(x);
if (*str == '-')
MPFR_SET_NEG(x);
else
MPFR_SET_POS(x);
return;
}
res = mpfr_strtofr (x, str, 0, 2, MPFR_RNDZ);
MPFR_ASSERTN (res == 0);
}
static int
string_to_fp (mpfr_t f, const char *s, mpfr_rnd_t rnd)
{
#ifdef WORKAROUND
mpfr_t f2;
mpfr_init2 (f2, 100000);
int r0 = mpfr_strtofr (f2, s, NULL, 0, rnd);
int r = mpfr_set (f, f2, rnd);
r |= mpfr_subnormalize (f, r, rnd);
mpfr_clear (f2);
return r0 | r;
#else
int r = mpfr_strtofr (f, s, NULL, 0, rnd);
r |= mpfr_subnormalize (f, r, rnd);
return r;
#endif
}
static void
check_retval (void)
{
mpfr_t x;
int res;
mpfr_init2 (x, 10);
res = mpfr_strtofr (x, "01011000111", NULL, 2, MPFR_RNDN);
MPFR_ASSERTN (res == 0);
res = mpfr_strtofr (x, "11011000111", NULL, 2, MPFR_RNDN);
MPFR_ASSERTN (res > 0);
res = mpfr_strtofr (x, "110110001101", NULL, 2, MPFR_RNDN);
MPFR_ASSERTN (res < 0);
mpfr_clear (x);
}
int
mpfr_set_str (mpfr_t x, const char *str, int base, mpfr_rnd_t rnd)
{
char *p;
if (MPFR_UNLIKELY (*str == 0))
return -1;
mpfr_strtofr (x, str, &p, base, rnd);
return (*p == 0) ? 0 : -1;
}
static Obj MPD_STRING(Obj self, Obj s, Obj prec)
{
while (!IsStringConv(s))
{
s = ErrorReturnObj("MPD_STRING: object to be converted must be a string, not a %s",
(Int)TNAM_OBJ(s),0,
"You can return a string to continue" );
}
TEST_IS_INTOBJ("MPD_STRING",prec);
int n = INT_INTOBJ(prec);
if (n == 0)
n = GET_LEN_STRING(s)*1000 / 301;
Obj g = NEW_MPD(INT_INTOBJ(prec));
char *p = (char *) CHARS_STRING(s), *newp;
int sign = 1;
mpd_set_ui(MPD_OBJ(g), 0, MPD_RNDNN);
mpfr_ptr f = MPD_OBJ(g)->re;
Obj newg = NEW_MPFR(INT_INTOBJ(prec));
for (;;) {
printf("<%c>",*p);
switch (*p) {
case '-':
case '+':
case 0:
if (!mpfr_nan_p(MPFR_OBJ(newg))) { /* drop the last read float */
mpfr_add (f, f, MPFR_OBJ(newg), GMP_RNDN);
mpfr_set_nan (MPFR_OBJ(newg));
f = MPD_OBJ(g)->re;
sign = 1;
}
if (!*p)
return g;
if (*p == '-')
sign = -sign;
case '*': p++; break;
case 'i':
case 'I': if (f == GET_MPD(g)->re) {
f = MPD_OBJ(g)->im;
if (mpfr_nan_p(MPFR_OBJ(newg)))
mpfr_set_si (MPFR_OBJ(newg), sign, GMP_RNDN); /* accept 'i' as '1*i' */
} else return Fail;
p++; break;
default:
mpfr_strtofr(MPFR_OBJ(newg), p, &newp, 10, GMP_RNDN);
if (newp == p && f != GET_MPD(g)->im)
return Fail; /* no valid characters read */
if (sign == -1)
mpfr_neg(MPFR_OBJ(newg), MPFR_OBJ(newg), GMP_RNDN);
p = newp;
}
}
return g;
}
static void
bug20120829 (void)
{
mpfr_t x1, x2, e;
int inex1, inex2, i, r;
char s[48] = "1e-1";
mpfr_init2 (e, 128);
mpfr_inits2 (4, x1, x2, (mpfr_ptr) 0);
inex1 = mpfr_set_si (e, -1, MPFR_RNDN);
MPFR_ASSERTN (inex1 == 0);
for (i = 1; i <= sizeof(s) - 5; i++)
{
s[3+i] = '0';
s[4+i] = 0;
inex1 = mpfr_mul_ui (e, e, 10, MPFR_RNDN);
MPFR_ASSERTN (inex1 == 0);
RND_LOOP(r)
{
mpfr_rnd_t rnd = (mpfr_rnd_t) r;
inex1 = mpfr_exp10 (x1, e, rnd);
inex1 = SIGN (inex1);
inex2 = mpfr_strtofr (x2, s, NULL, 0, rnd);
inex2 = SIGN (inex2);
/* On 32-bit machines, for i = 7, r8389, r8391 and r8394 do:
strtofr.c:...: MPFR assertion failed: cy == 0
r8396 is OK.
On 64-bit machines, for i = 15,
r8389 does: strtofr.c:678: MPFR assertion failed: err < (64 - 0)
r8391 does: strtofr.c:680: MPFR assertion failed: h < ysize
r8394 and r8396 are OK.
*/
if (! mpfr_equal_p (x1, x2) || inex1 != inex2)
{
printf ("Error in bug20120829 for i = %d, rnd = %s\n",
i, mpfr_print_rnd_mode (rnd));
printf ("Expected inex = %d, x = ", inex1);
mpfr_dump (x1);
printf ("Got inex = %d, x = ", inex2);
mpfr_dump (x2);
exit (1);
}
}
}
mpfr_clears (e, x1, x2, (mpfr_ptr) 0);
}
static void
bug20081028 (void)
{
int i;
int inexact, res;
mpfr_rnd_t rnd;
mpfr_t x, y;
char *s;
mpfr_init2 (x, 32);
mpfr_init2 (y, 32);
for (i = 0 ; i < numberof (Bug20081028Table) ; i++)
{
rnd = Bug20081028Table[i].rnd;
inexact = Bug20081028Table[i].inexact;
mpfr_set_str_binary (x, Bug20081028Table[i].binstr);
res = mpfr_strtofr (y, Bug20081028Table[i].str, &s, 10, rnd);
if (s == NULL || *s != 0)
{
printf ("Error in Bug20081028: strtofr didn't parse entire input\n"
"for (i=%d) Str=\"%s\"", i, Bug20081028Table[i].str);
exit (1);
}
if (! SAME_SIGN (res, inexact))
{
printf ("Error in Bug20081028: expected %s ternary value, "
"got %d\nfor (i=%d) Rnd=%s Str=\"%s\"\n Set binary gives: ",
inexact > 0 ? "positive" : "negative",
res, i, mpfr_print_rnd_mode(rnd), Bug20081028Table[i].str);
mpfr_dump (x);
printf (" strtofr gives: ");
mpfr_dump (y);
exit (1);
}
if (mpfr_cmp (x, y))
{
printf ("Error in Bug20081028: Results differ between strtofr and "
"set_binary\nfor (i=%d) Rnd=%s Str=\"%s\"\n"
" Set binary gives: ",
i, mpfr_print_rnd_mode(rnd), Bug20081028Table[i].str);
mpfr_dump (x);
printf (" strtofr gives: ");
mpfr_dump (y);
exit (1);
}
}
mpfr_clear (y);
mpfr_clear (x);
}
/* check that 1.23e is correctly parsed, cf
http://gmplib.org/list-archives/gmp-bugs/2010-March/001898.html */
static void
test20100310 (void)
{
mpfr_t x, y;
char str[] = "1.23e", *endptr;
mpfr_init2 (x, 53);
mpfr_init2 (y, 53);
mpfr_strtofr (x, str, &endptr, 10, MPFR_RNDN);
mpfr_strtofr (y, "1.23", NULL, 10, MPFR_RNDN);
if (mpfr_cmp (x, y) != 0)
{
printf ("x <> y in test20100310\n");
exit (1);
}
if (endptr != str + 4) /* strtofr should take into account '1.23',
not '1.23e' */
{
printf ("endptr <> str + 4 in test20100310\n");
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
}
static void
check_reftable (void)
{
int i, base;
mpfr_t x, y;
mpfr_prec_t p;
char *s;
mpfr_init2 (x, 200);
mpfr_init2 (y, 200);
for (i = 0 ; i < numberof (RefTable) ; i++)
{
base = RefTable[i].base;
p = RefTable[i].prec;
mpfr_set_prec (x, p);
mpfr_set_prec (y, p);
mpfr_set_str_binary (x, RefTable[i].binstr);
mpfr_strtofr (y, RefTable[i].str, &s, base, MPFR_RNDN);
if (s == NULL || *s != 0)
{
printf ("strtofr didn't parse entire input for i=%d:\n"
" Str=%s", i, RefTable[i].str);
exit (1);
}
if (mpfr_cmp (x, y))
{
printf ("Results differ between strtofr and set_binary for i=%d:\n"
" Set binary gives: ", i);
mpfr_dump (x);
printf (" strtofr gives: ");
mpfr_dump (y);
printf (" setstr gives: ");
mpfr_set_str (x, RefTable[i].str, base, MPFR_RNDN);
mpfr_dump (x);
mpfr_set_prec (x, 2*p);
mpfr_set_str (x, RefTable[i].str, base, MPFR_RNDN);
printf (" setstr ++ gives: ");
mpfr_dump (x);
exit (1);
}
}
mpfr_clear (y);
mpfr_clear (x);
}
static void
check_overflow (void)
{
mpfr_t x;
char *s;
mpfr_init (x);
/* Huge overflow */
mpfr_strtofr (x, "123456789E2147483646", &s, 0, MPFR_RNDN);
if (s[0] != 0 || !MPFR_IS_INF (x) || !MPFR_IS_POS (x) )
{
printf ("Check overflow failed (1) with:\n s=%s\n x=", s);
mpfr_dump (x);
exit (1);
}
mpfr_strtofr (x, "123456789E9223372036854775807", &s, 0, MPFR_RNDN);
if (s[0] != 0 || !MPFR_IS_INF (x) || !MPFR_IS_POS (x) )
{
printf ("Check overflow failed (2) with:\n s='%s'\n x=", s);
mpfr_dump (x);
exit (1);
}
mpfr_strtofr (x, "123456789E170141183460469231731687303715884105728",
&s, 0, MPFR_RNDN);
if (s[0] != 0 || !MPFR_IS_INF (x) || !MPFR_IS_POS (x) )
{
printf ("Check overflow failed (3) with:\n s=%s\n x=", s);
mpfr_dump (x);
exit (1);
}
/* Limit overflow */
mpfr_strtofr (x, "12E2147483646", &s, 0, MPFR_RNDN);
if (s[0] != 0 || !MPFR_IS_INF (x) || !MPFR_IS_POS (x) )
{
printf ("Check overflow failed (4) with:\n s=%s\n x=", s);
mpfr_dump (x);
exit (1);
}
mpfr_strtofr (x, "12E2147483645", &s, 0, MPFR_RNDN);
if (s[0] != 0 || !MPFR_IS_INF (x) || !MPFR_IS_POS (x))
{
printf ("Check overflow failed (5) with:\n s=%s\n x=", s);
mpfr_dump (x);
exit (1);
}
mpfr_strtofr (x, "0123456789ABCDEF@2147483640", &s, 16, MPFR_RNDN);
if (s[0] != 0 || !MPFR_IS_INF (x) || !MPFR_IS_POS (x))
{
printf ("Check overflow failed (6) with:\n s=%s\n x=", s);
mpfr_dump (x);
exit (1);
}
mpfr_strtofr (x, "0123456789ABCDEF@540000000", &s, 16, MPFR_RNDN);
if (s[0] != 0 || !MPFR_IS_INF (x) || !MPFR_IS_POS (x))
{
printf ("Check overflow failed (7) with:\n s=%s\n x=", s);
mpfr_dump (x);
exit (1);
}
/* Check underflow */
mpfr_strtofr (x, "123456789E-2147483646", &s, 0, MPFR_RNDN);
if (s[0] != 0 || !MPFR_IS_ZERO (x) || !MPFR_IS_POS (x) )
{
printf ("Check underflow failed (1) with:\n s=%s\n x=", s);
mpfr_dump (x);
exit (1);
}
mpfr_strtofr (x, "123456789E-9223372036854775807", &s, 0, MPFR_RNDN);
if (s[0] != 0 || !MPFR_IS_ZERO (x) || !MPFR_IS_POS (x) )
{
printf ("Check underflow failed (2) with:\n s='%s'\n x=", s);
mpfr_dump (x);
exit (1);
}
mpfr_strtofr (x, "-123456789E-170141183460469231731687303715884105728",
&s, 0, MPFR_RNDN);
if (s[0] != 0 || !MPFR_IS_ZERO (x) || !MPFR_IS_NEG (x) )
{
printf ("Check underflow failed (3) with:\n s=%s\n x=", s);
mpfr_dump (x);
exit (1);
}
mpfr_strtofr (x, "0123456789ABCDEF@-540000000", &s, 16, MPFR_RNDN);
if (s[0] != 0 || !MPFR_IS_ZERO (x) || !MPFR_IS_POS (x))
{
printf ("Check overflow failed (7) with:\n s=%s\n x=", s);
mpfr_dump (x);
exit (1);
}
mpfr_clear (x);
}
static void
check_parse (void)
{
mpfr_t x;
char *s;
int res;
mpfr_init (x);
/* Invalid data */
mpfr_set_si (x, -1, MPFR_RNDN);
res = mpfr_strtofr (x, " invalid", NULL, 10, MPFR_RNDN);
if (MPFR_NOTZERO (x) || MPFR_IS_NEG (x))
{
printf ("Failed parsing ' invalid' (1)\n X=");
mpfr_dump (x);
exit (1);
}
MPFR_ASSERTN (res == 0);
mpfr_set_si (x, -1, MPFR_RNDN);
res = mpfr_strtofr (x, " invalid", &s, 0, MPFR_RNDN);
if (MPFR_NOTZERO (x) || MPFR_IS_NEG (x) || strcmp (s, " invalid"))
{
printf ("Failed parsing ' invalid' (2)\n S=%s\n X=", s);
mpfr_dump (x);
exit (1);
}
MPFR_ASSERTN (res == 0);
/* Check if it stops correctly */
mpfr_strtofr (x, "15*x", &s, 10, MPFR_RNDN);
if (mpfr_cmp_ui (x, 15) || strcmp (s, "*x"))
{
printf ("Failed parsing '15*x'\n S=%s\n X=", s);
mpfr_dump (x);
exit (1);
}
/* Check for leading spaces */
mpfr_strtofr (x, " 1.5E-10 *x^2", &s, 10, MPFR_RNDN);
if (mpfr_cmp_str1 (x, "1.5E-10") || strcmp (s, " *x^2"))
{
printf ("Failed parsing '1.5E-10*x^2'\n S=%s\n X=", s);
mpfr_dump (x);
exit (1);
}
/* Check for leading sign */
mpfr_strtofr (x, " +17.5E-42E ", &s, 10, MPFR_RNDN);
if (mpfr_cmp_str1 (x, "17.5E-42") || strcmp (s, "E "))
{
printf ("Failed parsing '+17.5E-42E '\n S=%s\n X=", s);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_strtofr (x, "-17.5E+42E\n", &s, 10, MPFR_RNDN);
if (mpfr_cmp_str1 (x, "-17.5E42") || strcmp (s, "E\n"))
{
printf ("Failed parsing '-17.5E+42\\n'\n S=%s\n X=", s);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
/* P form */
mpfr_strtofr (x, "0x42P17", &s, 16, MPFR_RNDN);
if (mpfr_cmp_str (x, "8650752", 10, MPFR_RNDN) || *s != 0)
{
printf ("Failed parsing '0x42P17' (base = 16)\n S='%s'\n X=", s);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_strtofr (x, "-0X42p17", &s, 16, MPFR_RNDN);
if (mpfr_cmp_str (x, "-8650752", 10, MPFR_RNDN) || *s != 0)
{
printf ("Failed parsing '-0x42p17' (base = 16)\n S='%s'\n X=", s);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_strtofr (x, "42p17", &s, 16, MPFR_RNDN);
if (mpfr_cmp_str (x, "8650752", 10, MPFR_RNDN) || *s != 0)
{
printf ("Failed parsing '42p17' (base = 16)\n S='%s'\n X=", s);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_strtofr (x, "-42P17", &s, 16, MPFR_RNDN);
if (mpfr_cmp_str (x, "-8650752", 10, MPFR_RNDN) || *s != 0)
{
printf ("Failed parsing '-42P17' (base = 16)\n S='%s'\n X=", s);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_strtofr (x, "0b1001P17", &s, 2, MPFR_RNDN);
if (mpfr_cmp_str (x, "1179648", 10, MPFR_RNDN) || *s != 0)
{
printf ("Failed parsing '0b1001P17' (base = 2)\n S='%s'\n X=", s);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_strtofr (x, "-0B1001p17", &s, 2, MPFR_RNDN);
if (mpfr_cmp_str (x, "-1179648", 10, MPFR_RNDN) || *s != 0)
{
printf ("Failed parsing '-0B1001p17' (base = 2)\n S='%s'\n X=", s);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_strtofr (x, "1001p17", &s, 2, MPFR_RNDN);
if (mpfr_cmp_str (x, "1179648", 10, MPFR_RNDN) || *s != 0)
{
printf ("Failed parsing '1001p17' (base = 2)\n S='%s'\n X=", s);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_strtofr (x, "-1001P17", &s, 2, MPFR_RNDN);
if (mpfr_cmp_str (x, "-1179648", 10, MPFR_RNDN) || *s != 0)
{
printf ("Failed parsing '-1001P17' (base = 2)\n S='%s'\n X=", s);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
/* Check for auto-detection of the base */
mpfr_strtofr (x, "+0x42P17", &s, 0, MPFR_RNDN);
if (mpfr_cmp_str (x, "42P17", 16, MPFR_RNDN) || *s != 0)
{
printf ("Failed parsing '+0x42P17'\n S=%s\n X=", s);
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_strtofr (x, "-42E17", &s, 0, MPFR_RNDN);
if (mpfr_cmp_str (x, "-42E17", 10, MPFR_RNDN) || *s != 0)
{
printf ("Failed parsing '-42E17'\n S=%s\n X=", s);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_strtofr (x, "-42P17", &s, 0, MPFR_RNDN);
if (mpfr_cmp_str (x, "-42", 10, MPFR_RNDN) || strcmp (s, "P17"))
{
printf ("Failed parsing '-42P17' (base = 0)\n S='%s'\n X=", s);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_strtofr (x, " 0b0101.011@42", &s, 0, MPFR_RNDN);
if (mpfr_cmp_str (x, "0101.011@42", 2, MPFR_RNDN) || *s != 0)
{
printf ("Failed parsing '0101.011@42'\n S=%s\n X=", s);
mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_strtofr (x, " 0b0101.011P42", &s, 0, MPFR_RNDN);
if (mpfr_cmp_str (x, "0101.011@42", 2, MPFR_RNDN) || *s != 0)
{
printf ("Failed parsing '0101.011@42'\n S=%s\n X=", s);
mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_strtofr (x, "+0x42@17", &s, 0, MPFR_RNDN);
if (mpfr_cmp_str (x, "4.2@18", 16, MPFR_RNDN) || *s != 0)
{
printf ("Failed parsing '+0x42P17'\n S=%s\n X=", s);
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
/* Check for space inside the mantissa */
mpfr_strtofr (x, "+0x4 2@17", &s, 0, MPFR_RNDN);
if (mpfr_cmp_ui (x, 4) || strcmp(s," 2@17"))
{
printf ("Failed parsing '+0x4 2@17'\n S=%s\n X=", s);
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_strtofr (x, "+0x42 P17", &s, 0, MPFR_RNDN);
if (mpfr_cmp_ui (x, 0x42) || strcmp(s," P17"))
{
printf ("Failed parsing '+0x42 P17'\n S=%s\n X=", s);
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
/* Space between mantissa and exponent */
mpfr_strtofr (x, " -0b0101P 17", &s, 0, MPFR_RNDN);
if (mpfr_cmp_si (x, -5) || strcmp(s,"P 17"))
{
printf ("Failed parsing '-0b0101P 17'\n S=%s\n X=", s);
mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
/* Check for Invalid exponent. */
mpfr_strtofr (x, " -0b0101PF17", &s, 0, MPFR_RNDN);
if (mpfr_cmp_si (x, -5) || strcmp(s,"PF17"))
{
printf ("Failed parsing '-0b0101PF17'\n S=%s\n X=", s);
mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
/* At least one digit in the mantissa. */
mpfr_strtofr (x, " .E10", &s, 0, MPFR_RNDN);
if (strcmp(s," .E10"))
{
printf ("Failed parsing ' .E10'\n S=%s\n X=", s);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
/* Check 2 '.': 2.3.4 */
mpfr_strtofr (x, "-1.2.3E4", &s, 0, MPFR_RNDN);
if (mpfr_cmp_str1 (x, "-1.2") || strcmp(s,".3E4"))
{
printf ("Failed parsing '-1.2.3E4'\n S=%s\n X=", s);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
/* Check for 0x and 0b */
mpfr_strtofr (x, " 0xG", &s, 0, MPFR_RNDN);
if (mpfr_cmp_ui (x, 0) || strcmp(s,"xG"))
{
printf ("Failed parsing ' 0xG'\n S=%s\n X=", s);
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_strtofr (x, " 0b2", &s, 0, MPFR_RNDN);
if (mpfr_cmp_ui (x, 0) || strcmp(s,"b2"))
{
printf ("Failed parsing ' 0b2'\n S=%s\n X=", s);
mpfr_out_str (stdout, 2, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_strtofr (x, "-0x.23@2Z33", &s, 0, MPFR_RNDN);
if (mpfr_cmp_si (x, -0x23) || strcmp(s,"Z33"))
{
printf ("Failed parsing '-0x.23@2Z33'\n S=%s\n X=", s);
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_strtofr (x, " 0x", &s, 0, MPFR_RNDN);
if (mpfr_cmp_ui (x, 0) || strcmp(s,"x"))
{
printf ("Failed parsing ' 0x'\n S=%s\n X=", s);
mpfr_out_str (stdout, 16, 0, x, MPFR_RNDN); putchar ('\n');
exit (1);
}
mpfr_clear (x);
}
static void
check_special (void)
{
mpfr_t x, y;
int res;
char *s;
mpfr_init (x);
mpfr_init (y);
/* Check dummy case */
res = mpfr_strtofr (x, "1234567.89E1", NULL, 10, MPFR_RNDN);
mpfr_set_str (y, "1234567.89E1", 10, MPFR_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Results differ between strtofr and set_str.\n"
" set_str gives: ");
mpfr_dump (y);
printf (" strtofr gives: ");
mpfr_dump (x);
exit (1);
}
/* Check NAN */
mpfr_set_ui (x, 0, MPFR_RNDN); /* make sure that x is modified */
res = mpfr_strtofr (x, "NaN", &s, 10, MPFR_RNDN);
if (res != 0 || !mpfr_nan_p (x) || *s != 0)
{
printf ("Error for setting NAN (1)\n");
exit (1);
}
mpfr_set_ui (x, 0, MPFR_RNDN); /* make sure that x is modified */
res = mpfr_strtofr (x, "+NaN", &s, 10, MPFR_RNDN);
if (res != 0 || !mpfr_nan_p (x) || *s != 0)
{
printf ("Error for setting +NAN (1)\n");
exit (1);
}
mpfr_set_ui (x, 0, MPFR_RNDN); /* make sure that x is modified */
res = mpfr_strtofr (x, " -NaN", &s, 10, MPFR_RNDN);
if (res != 0 || !mpfr_nan_p (x) || *s != 0)
{
printf ("Error for setting -NAN (1)\n");
exit (1);
}
mpfr_set_ui (x, 0, MPFR_RNDN); /* make sure that x is modified */
res = mpfr_strtofr (x, "@nAn@xx", &s, 16, MPFR_RNDN);
if (res != 0 || !mpfr_nan_p (x) || strcmp(s, "xx") )
{
printf ("Error for setting NAN (2)\n");
exit (1);
}
mpfr_set_ui (x, 0, MPFR_RNDN); /* make sure that x is modified */
res = mpfr_strtofr (x, "NAN(abcdEDF__1256)Hello", &s, 10, MPFR_RNDN);
if (res != 0 || !mpfr_nan_p (x) || strcmp(s, "Hello") )
{
printf ("Error for setting NAN (3)\n");
exit (1);
}
mpfr_set_ui (x, 0, MPFR_RNDN); /* make sure that x is modified */
res = mpfr_strtofr (x, "NAN(abcdEDF)__1256)Hello", &s, 10, MPFR_RNDN);
if (res != 0 || !mpfr_nan_p (x) || strcmp(s, "__1256)Hello") )
{
printf ("Error for setting NAN (4)\n");
exit (1);
}
mpfr_set_ui (x, 0, MPFR_RNDN); /* make sure that x is modified */
res = mpfr_strtofr (x, "NAN(abc%dEDF)__1256)Hello", &s, 10, MPFR_RNDN);
if (res != 0 || !mpfr_nan_p (x) || strcmp(s, "(abc%dEDF)__1256)Hello") )
{
printf ("Error for setting NAN (5)\n");
exit (1);
}
mpfr_set_ui (x, 0, MPFR_RNDN); /* make sure that x is modified */
res = mpfr_strtofr (x, "NAN((abc))", &s, 10, MPFR_RNDN);
if (res != 0 || !mpfr_nan_p (x) || strcmp(s, "((abc))") )
{
printf ("Error for setting NAN (6)\n");
exit (1);
}
mpfr_set_ui (x, 0, MPFR_RNDN); /* make sure that x is modified */
res = mpfr_strtofr (x, "NAN()foo", &s, 10, MPFR_RNDN);
if (res != 0 || !mpfr_nan_p (x) || strcmp(s, "foo") )
{
printf ("Error for setting NAN (7)\n");
exit (1);
}
/* Check INF */
res = mpfr_strtofr (x, "INFINITY", &s, 8, MPFR_RNDN);
if (res != 0 || !mpfr_inf_p (x) || *s != 0)
{
printf ("Error for setting INFINITY (1)\n s=%s\n x=", s);
mpfr_dump (x);
exit (1);
}
res = mpfr_strtofr (x, "INFANITY", &s, 8, MPFR_RNDN);
if (res != 0 || !mpfr_inf_p (x) || strcmp(s, "ANITY"))
{
printf ("Error for setting INFINITY (2)\n s=%s\n x=", s);
mpfr_dump (x);
exit (1);
}
res = mpfr_strtofr (x, "@INF@*2", &s, 11, MPFR_RNDN);
if (res != 0 || !mpfr_inf_p (x) || strcmp(s, "*2"))
{
printf ("Error for setting INFINITY (3)\n s=%s\n x=", s);
mpfr_dump (x);
exit (1);
}
/* Check Zero */
res = mpfr_strtofr (x, " 00000", &s, 11, MPFR_RNDN);
if (res != 0 || !mpfr_zero_p (x) || s[0] != 0)
{
printf ("Error for setting ZERO (1)\n s=%s\n x=", s);
mpfr_dump (x);
exit (1);
}
/* Check base 62 */
res = mpfr_strtofr (x, "A", NULL, 62, MPFR_RNDN);
if (res != 0 || mpfr_cmp_ui (x, 10))
{
printf ("Error for setting 'A' in base 62\n x=");
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
putchar ('\n');
exit (1);
}
res = mpfr_strtofr (x, "a", NULL, 62, MPFR_RNDN);
if (res != 0 || mpfr_cmp_ui (x, 36))
{
printf ("Error for setting 'a' in base 62\n x=");
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
putchar ('\n');
exit (1);
}
res = mpfr_strtofr (x, "Z", NULL, 62, MPFR_RNDN);
if (res != 0 || mpfr_cmp_ui (x, 35))
{
printf ("Error for setting 'Z' in base 62\n x=");
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
putchar ('\n');
exit (1);
}
res = mpfr_strtofr (x, "z", NULL, 62, MPFR_RNDN);
if (res != 0 || mpfr_cmp_ui (x, 61))
{
printf ("Error for setting 'z' in base 62\n x=");
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
putchar ('\n');
exit (1);
}
res = mpfr_strtofr (x, "ZA", NULL, 62, MPFR_RNDN);
if (res != 0 || mpfr_cmp_ui (x, 2180))
{
printf ("Error for setting 'ZA' in base 62\n x=");
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
putchar ('\n');
exit (1);
}
res = mpfr_strtofr (x, "za", NULL, 62, MPFR_RNDN);
if (res != 0 || mpfr_cmp_ui (x, 3818))
{
printf ("Error for setting 'za' in base 62\n x=");
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
putchar ('\n');
exit (1);
}
res = mpfr_strtofr (x, "aZ", NULL, 62, MPFR_RNDN);
if (res != 0 || mpfr_cmp_ui (x, 2267))
{
printf ("Error for setting 'aZ' in base 62\n x=");
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
putchar ('\n');
exit (1);
}
res = mpfr_strtofr (x, "Az", NULL, 62, MPFR_RNDN);
if (res != 0 || mpfr_cmp_ui (x, 681))
{
printf ("Error for setting 'Az' in base 62\n x=");
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
putchar ('\n');
exit (1);
}
/* Check base 60 */
res = mpfr_strtofr (x, "Aa", NULL, 60, MPFR_RNDN);
if (res != 0 || mpfr_cmp_ui (x, 636))
{
printf ("Error for setting 'Aa' in base 60\n x=");
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
putchar ('\n');
exit (1);
}
res = mpfr_strtofr (x, "Zz", &s, 60, MPFR_RNDN);
if (res != 0 || mpfr_cmp_ui (x, 35) || strcmp(s, "z") )
{
printf ("Error for setting 'Zz' in base 60\n x=");
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
putchar ('\n');
exit (1);
}
/* Check base 61 */
res = mpfr_strtofr (x, "z", &s, 61, MPFR_RNDN);
if (res != 0 || mpfr_cmp_ui (x, 0) || strcmp(s, "z") )
{
printf ("Error for setting 'z' in base 61\n x=");
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
putchar ('\n');
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
}
num_t
num_new_from_str(int flags, numtype_t typehint, char *str)
{
numtype_t type = typehint;
double exp;
char *suffix, *s;
int base, type_override, r;
num_t n;
n = num_new(flags);
/*
* If it's a decimal number but it doesn't have a floating point, suffix, etc
* treat it as an integer.
*/
type_override = 1;
if (typehint == NUM_FP) {
s = (str[1] == 'd') ? str + 2 : str;
while (*s != '\0') {
if (!isdigit(*s++)) {
type_override = 0;
break;
}
}
if (type_override)
type = NUM_INT;
}
n->num_type = type;
base = 0;
if (str[1] == 'd') {
base = 10;
str += 2;
}
if (type == NUM_INT) {
if ((r = mpz_init_set_str(Z(n), str, base)) != 0) {
yyxerror("mpz_init_set_str");
mpz_clear(Z(n));
}
} else {
if (str[1] == 'd')
str += 2;
mpfr_init(F(n));
r = mpfr_strtofr(F(n), str, &suffix, 0, round_mode);
/*
* XXX: add support for IEC binary prefixes?
*/
if (*suffix != '\0') {
switch (*suffix) {
case 'k':
exp = 1000;
break;
case 'M':
exp = 1000000;
break;
case 'G':
exp = 1000000000;
break;
case 'T':
exp = 1000000000000;
break;
case 'P':
exp = 1000000000000000;
break;
case 'E':
exp = 1000000000000000000;
break;
case 'm':
exp = 0.001;
break;
case 'u':
exp = 0.000001;
break;
case 'n':
exp = 0.000000001;
break;
case 'p':
exp = 0.000000000001;
break;
case 'f':
exp = 0.000000000000001;
break;
case 'a':
exp = 0.000000000000000001;
break;
default:
yyxerror("Unknown suffix");
exit(1);
}
mpfr_mul_d(F(n), F(n), exp, round_mode);
}
}
return n;
}
static MPC_Object *
GMPy_MPC_From_PyStr(PyObject *s, int base, mpfr_prec_t rprec, mpfr_prec_t iprec,
CTXT_Object *context)
{
MPC_Object *result;
PyObject *ascii_str = NULL;
Py_ssize_t len;
char *cp, *unwind, *tempchar, *lastchar;
int firstp = 0, lastp = 0, real_rc = 0, imag_rc = 0;
CHECK_CONTEXT(context);
if (PyBytes_Check(s)) {
len = PyBytes_Size(s);
cp = (char*)PyBytes_AsString(s);
}
else if (PyUnicode_Check(s)) {
ascii_str = PyUnicode_AsASCIIString(s);
if (!ascii_str) {
VALUE_ERROR("string contains non-ASCII characters");
return NULL;
}
len = PyBytes_Size(ascii_str);
cp = (char*)PyBytes_AsString(ascii_str);
}
else {
TYPE_ERROR("string required");
return NULL;
}
/* Don't allow NULL characters */
if (strlen(cp) != len) {
VALUE_ERROR("string without NULL characters expected");
Py_XDECREF(ascii_str);
return NULL;
}
if (!(result = GMPy_MPC_New(rprec, iprec, context))) {
Py_XDECREF(ascii_str);
return NULL;
}
/* Get a pointer to the last valid character (ignoring trailing
* whitespace.) */
lastchar = cp + len - 1;
while (isspace(*lastchar))
lastchar--;
/* Skip trailing ). */
if (*lastchar == ')') {
lastp = 1;
lastchar--;
}
/* Skip trailing j. */
if (*lastchar == 'j')
lastchar--;
/* Skip leading whitespace. */
while (isspace(*cp))
cp++;
/* Skip a leading (. */
if (*cp == '(') {
firstp = 1;
cp++;
}
if (firstp != lastp) goto invalid_string;
/* Read the real component first. */
unwind = cp;
real_rc = mpfr_strtofr(mpc_realref(result->c), cp, &tempchar, base,
GET_REAL_ROUND(context));
/* Verify that at least one valid character was read. */
if (cp == tempchar) goto invalid_string;
/* If the next character is a j, then the real component is 0 and
* we just read the imaginary componenet.
*/
if (*tempchar == 'j') {
mpfr_set_zero(mpc_realref(result->c), MPFR_RNDN);
cp = unwind;
}
else {
/* Read the imaginary component next. */
cp = tempchar;
}
imag_rc = mpfr_strtofr(mpc_imagref(result->c), cp, &tempchar, base,
GET_IMAG_ROUND(context));
if (cp == tempchar && tempchar > lastchar)
goto valid_string;
if (*tempchar != 'j' && *cp != ' ')
goto invalid_string;
if (tempchar <= lastchar)
goto invalid_string;
valid_string:
Py_XDECREF(ascii_str);
result->rc = MPC_INEX(real_rc, imag_rc);
if (rprec != 1 || iprec != 1) {
GMPY_MPC_CHECK_RANGE(result, context);
}
GMPY_MPC_SUBNORMALIZE(result, context);
GMPY_MPC_EXCEPTIONS(result, context);
return result;
invalid_string:
VALUE_ERROR("invalid string in mpc()");
Py_DECREF((PyObject*)result);
Py_XDECREF(ascii_str);
return NULL;
}
void MpfrFloat::parseValue(const char* value, char** endptr)
{
mpfr_strtofr(mData->mFloat, value, endptr, 10, GMP_RNDN);
}
MpfrFloat MpfrFloat::parseString(const char* str, char** endptr)
{
MpfrFloat retval(MpfrFloat::kNoInitialization);
mpfr_strtofr(retval.mData->mFloat, str, endptr, 10, GMP_RNDN);
return retval;
}
