static void
bug20091013 (void)
{
mpfr_t x, y, z, yref, zref;
mpfr_prec_t p = 1000;
int inex, inexref;
mpfr_rnd_t r = MPFR_RNDN;
mpfr_init2 (x, p);
mpfr_init2 (y, p);
mpfr_init2 (z, p);
mpfr_init2 (yref, p);
mpfr_init2 (zref, p);
mpfr_set_str (x, "3.240ff3fdcb1ee7cd667b96287593ae24e20fb63ed7c2d5bf4bd0f2cc5509283b04e7628e66382605f14ed5967cef15296041539a1bdaa626c777c7fbb6f2068414759b78cee14f37848689b3a170f583656be4e0837f464d8210556a3a822d4ecfdd59f4e0d5fdb76bf7e15b8a57234e2160b98e14c17bbdf27c4643b8@1", 16, MPFR_RNDN);
inexref = mpfr_sin_cos (yref, zref, x, r);
inex = mpfr_sincos_fast (y, z, x, r);
if (mpfr_cmp (y, yref))
{
printf ("mpfr_sin_cos and mpfr_sincos_fast disagree (bug20091013)\n");
printf ("yref="); mpfr_dump (yref);
printf ("y="); mpfr_dump (y);
exit (1);
}
if (mpfr_cmp (z, zref))
{
printf ("mpfr_sin_cos and mpfr_sincos_fast disagree (bug20091013)\n");
printf ("zref="); mpfr_dump (zref);
printf ("z="); mpfr_dump (z);
exit (1);
}
/* sin(x) is rounded down and cos(x) is rounded down, thus we should get
2+4*2 = 10 as return value */
if (inex != inexref)
{
printf ("mpfr_sin_cos and mpfr_sincos_fast disagree (bug20091013)\n");
printf ("inexref=%d inex=%d (10 expected)\n", inexref, inex);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
mpfr_clear (yref);
mpfr_clear (zref);
}
/* Note: with the sin_cos.c code before r6507, the disagreement occurs
only on the return ("inexact") value, which is new in r6444. */
static void
bug20091008 (void)
{
mpfr_t x, y, z, yref, zref;
mpfr_prec_t p = 1000;
int inex, inexref;
mpfr_rnd_t r = MPFR_RNDN;
mpfr_init2 (x, p);
mpfr_init2 (y, p);
mpfr_init2 (z, p);
mpfr_init2 (yref, p);
mpfr_init2 (zref, p);
mpfr_set_str (x, "c.91813724e28ef6a711d33e6505984699daef7fe93636c1ed5d0168bc96989cc6802f7f9e405c902ec62fb90cd39c9d21084c8ad8b5af4c4aa87bf402e2e4a78e6fe1ffeb6dbbbdbbc2983c196c518966ccc1e094ed39ee77984ef2428069d65de37928e75247edbe7007245e682616b5ebbf05f2fdefc74ad192024f10", 16, MPFR_RNDN);
inexref = mpfr_sin_cos (yref, zref, x, r);
inex = mpfr_sincos_fast (y, z, x, r);
if (mpfr_cmp (y, yref))
{
printf ("mpfr_sin_cos and mpfr_sincos_fast disagree (bug20091008)\n");
printf ("yref="); mpfr_dump (yref);
printf ("y="); mpfr_dump (y);
exit (1);
}
if (mpfr_cmp (z, zref))
{
printf ("mpfr_sin_cos and mpfr_sincos_fast disagree (bug20091008)\n");
printf ("zref="); mpfr_dump (zref);
printf ("z="); mpfr_dump (z);
exit (1);
}
/* sin(x) is rounded up, cos(x) is rounded up too, thus we should get 5
for the return value */
if (inex != inexref)
{
printf ("mpfr_sin_cos and mpfr_sincos_fast disagree (bug20091008)\n");
printf ("inexref=%d inex=%d (5 expected)\n", inexref, inex);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
mpfr_clear (yref);
mpfr_clear (zref);
}
static void
check_diff (void)
{
int inex;
mpfr_t x;
mpz_t z;
mpfr_exp_t emin;
mpz_init (z);
mpfr_init2 (x, 2);
mpfr_set_ui (x, 2047, MPFR_RNDU);
mpz_set_fr (z, x, MPFR_RNDN);
if (mpz_cmp_ui (z, 2048) != 0)
{
printf ("get_z RU 2048 failed\n");
exit (1);
}
mpfr_set_prec (x, 6);
mpfr_set_str (x, "17.5", 10, MPFR_RNDN);
inex = mpfr_get_z (z, x, MPFR_RNDN);
if (inex <= 0 || mpz_cmp_ui (z, 18) != 0)
{
printf ("get_z RN 17.5 failed\n");
exit (1);
}
/* save default emin */
emin = mpfr_get_emin ();;
mpfr_set_emin (17);
mpfr_set_ui (x, 0, MPFR_RNDN);
inex = mpfr_get_z (z, x, MPFR_RNDN);
if (inex != 0 || mpz_cmp_ui (z, 0) != 0)
{
printf ("get_z 0 failed\n");
exit (1);
}
/* restore default emin */
mpfr_set_emin (emin);
mpfr_clear (x);
mpz_clear (z);
}
static void
bug20091007 (void)
{
mpfr_t x, y, z, yref, zref;
mpfr_prec_t p = 1000;
int inex, inexref;
mpfr_rnd_t r = MPFR_RNDZ;
mpfr_init2 (x, p);
mpfr_init2 (y, p);
mpfr_init2 (z, p);
mpfr_init2 (yref, p);
mpfr_init2 (zref, p);
mpfr_set_str (x, "1.9ecdc22ba77a5ab2560f7e84289e2a328906f47377ea3fd4c82d1bb2f13ee05c032cffc1933eadab7b0a5498e03e3bd0508968e59c25829d97a0b54f20cd4662c8dfffa54e714de41fc8ee3e0e0b244d110a194db05b70022b7d77f88955d415b09f17dd404576098dc51a583a3e49c35839551646e880c7eb790a01a4@1", 16, MPFR_RNDN);
inexref = mpfr_sin_cos (yref, zref, x, r);
inex = mpfr_sincos_fast (y, z, x, r);
if (mpfr_cmp (y, yref))
{
printf ("mpfr_sin_cos and mpfr_sincos_fast disagree (bug20091007)\n");
printf ("yref="); mpfr_dump (yref);
printf ("y="); mpfr_dump (y);
exit (1);
}
if (mpfr_cmp (z, zref))
{
printf ("mpfr_sin_cos and mpfr_sincos_fast disagree (bug20091007)\n");
printf ("zref="); mpfr_dump (zref);
printf ("z="); mpfr_dump (z);
exit (1);
}
if (inex != inexref)
{
printf ("mpfr_sin_cos and mpfr_sincos_fast disagree (bug20091007)\n");
printf ("inexref=%d inex=%d\n", inexref, inex);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
mpfr_clear (yref);
mpfr_clear (zref);
}
/* bug reported by Joseph S. Myers on 2013-10-27
https://sympa.inria.fr/sympa/arc/mpfr/2013-10/msg00015.html */
static void
bug20131027 (void)
{
mpfr_t sum, t[4];
mpfr_ptr p[4];
char *s[4] = {
"0x1p1000",
"-0x0.fffffffffffff80000000000000001p1000",
"-0x1p947",
"0x1p880"
};
int i, r;
mpfr_init2 (sum, 53);
for (i = 0; i < 4; i++)
{
mpfr_init2 (t[i], i == 0 ? 53 : 1000);
mpfr_set_str (t[i], s[i], 0, MPFR_RNDN);
p[i] = t[i];
}
RND_LOOP(r)
{
int expected_sign = (mpfr_rnd_t) r == MPFR_RNDD ? -1 : 1;
int inex;
inex = mpfr_sum (sum, p, 4, (mpfr_rnd_t) r);
if (MPFR_NOTZERO (sum) || MPFR_SIGN (sum) != expected_sign || inex != 0)
{
printf ("mpfr_sum incorrect in bug20131027 for %s:\n"
"expected %c0 with inex = 0, got ",
mpfr_print_rnd_mode ((mpfr_rnd_t) r),
expected_sign > 0 ? '+' : '-');
mpfr_dump (sum);
printf ("with inex = %d\n", inex);
exit (1);
}
}
for (i = 0; i < 4; i++)
mpfr_clear (t[i]);
mpfr_clear (sum);
}
static void
large_test (char *X, int prec, int N)
{
int i;
mpfr_t x, s, c;
mpfr_init2 (x, prec);
mpfr_init2 (s, prec);
mpfr_init2 (c, prec);
mpfr_set_str (x, X, 10, MPFR_RNDN);
for (i = 0; i < N; i++)
mpfr_sin_cos (s, c, x, MPFR_RNDN);
mpfr_clear (x);
mpfr_clear (s);
mpfr_clear (c);
}
REAL _ln(REAL a, REAL, QByteArray &error)
{
if (a <= ZERO)
{
error = QByteArray("ERROR: ln(a <= 0!!!)!");
print(error.constData());
return ZERO;
}
mpfr_t tmp1; mpfr_init2(tmp1, NUMBITS);
mpfr_t result; mpfr_init2(result, NUMBITS);
// mpfr_init_set_f(tmp1, a.get_mpf_t(), MPFR_RNDN);
mpfr_set_str(tmp1, getString(a).data(), 10, MPFR_RNDN);
mpfr_log(result, tmp1, MPFR_RNDN);
mpfr_get_f(a.get_mpf_t(), result, MPFR_RNDN);
mpfr_clear(tmp1);
mpfr_clear(result);
return a;
}
static void
check3 (const char *d, mpfr_rnd_t rnd, const char *res)
{
mpfr_t x;
char *str;
mpfr_exp_t e;
mpfr_init2 (x, 53);
mpfr_set_str (x, d, 10, rnd);
str = mpfr_get_str (NULL, &e, 10, 5, x, rnd);
if (strcmp (str, res))
{
printf ("Error in mpfr_get_str for x=%s\n", d);
printf ("got %s instead of %s\n", str, res);
exit (1);
}
mpfr_clear (x);
mpfr_free_str (str);
}
/* Check with locale "da_DK". On most platforms, decimal point is ','
and thousands separator is '.'; the test is not performed if this
is not the case or if the locale doesn't exist. */
static int
locale_da_DK (void)
{
mpfr_prec_t p = 128;
mpfr_t x;
if (setlocale (LC_ALL, "da_DK") == 0 ||
localeconv()->decimal_point[0] != ',' ||
localeconv()->thousands_sep[0] != '.')
return 0;
mpfr_init2 (x, p);
/* positive numbers */
mpfr_set_str (x, "18993474.61279296875", 10, MPFR_RNDN);
/* simplest case right justified with thousands separator */
check_sprintf (" 1,899347461279296875e+07", "%'30Re", x);
check_sprintf (" 1,89935e+07", "%'30Rg", x);
check_sprintf (" 18.993.474,61279296875", "%'30.19Rg", x);
check_sprintf (" 18.993.474,612793", "%'30Rf", x);
/* sign or space, pad, thousands separator with leading zeros */
check_sprintf (" 000001,899347461279296875E+07", "%' 030RE", x);
check_sprintf (" 0000000000000000001,89935E+07", "%' 030RG", x);
check_sprintf (" 000000018.993.474,61279296875", "%' 030.19RG", x);
check_sprintf (" 00000000000018.993.474,612793", "%' 030RF", x);
mpfr_set_ui (x, 50, MPFR_RNDN);
mpfr_exp10 (x, x, MPFR_RNDN);
check_sprintf ("100000000000000000000000000000000000000000000000000", "%.0Rf",
x);
check_sprintf
("100.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000,",
"%'#.0Rf", x);
check_sprintf
("100.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000.000,0000",
"%'.4Rf", x);
mpfr_clear (x);
return 0;
}
REAL _tan(REAL a, REAL, QByteArray &)
{
mpfr_t tmp1; mpfr_init2(tmp1, NUMBITS);
mpfr_t result; mpfr_init2(result, NUMBITS);
try
{
// mpfr_init_set_f(tmp1, a.get_mpf_t(), MPFR_RNDN);
mpfr_set_str(tmp1, getString(a).data(), 10, MPFR_RNDN);
mpfr_tan(result, tmp1, MPFR_RNDN);
mpfr_get_f(a.get_mpf_t(), result, MPFR_RNDN);
}
catch(...)
{
mpfr_clear(tmp1);
mpfr_clear(result);
return ZERO;
}
mpfr_clear(tmp1);
mpfr_clear(result);
return a;
}
void gcalc_set_builtin_decimal_variable(gcalc* calc, const char* name, const char* value)
{
// there is no check here to test if a variable already exists. This is not necessary, because the builtin variables
// are, well, builtin, and thus do not overlap existing variables.
gcalc_variable* result = (gcalc_variable*) malloc(sizeof(gcalc_variable));
if( result != NULL )
{
gcalc_variable_constructor(calc, result, name, GCALC_TRUE);
result->value.type = GCALC_TYPE_DECIMAL;
mpfr_init2(result->value.big_decimal, MPFR_DEFAULT_PRECISION);
// i have fixed the base to 10 here, because I see litte usage for decimals in other bases - yet;
// plus doing so here really isolates the issue, should I decide to change my mind at a later point in time.
if( 0 != mpfr_set_str (result->value.big_decimal, value, 10, MPFR_DEFAULT_ROUNDING) )
{
// remove from queue :/
calc->variables = result->next;
gcalc_object_release(&(result->value.object_header));
}
}
}
void
check2a (double x, int px, double y, int py, int pz, mp_rnd_t rnd_mode,
char *res)
{
mpfr_t xx, yy, zz;
mpfr_init2(xx,px); mpfr_init2(yy,py); mpfr_init2(zz,pz);
mpfr_set_d(xx, x, rnd_mode);
mpfr_set_d(yy, y, rnd_mode);
mpfr_add(zz, xx, yy, rnd_mode);
mpfr_set_prec(xx, pz);
mpfr_set_str(xx, res, 16, GMP_RNDN);
if (mpfr_cmp(xx, zz)) {
printf("x=%1.20e,%d y=%1.20e,%d pz=%d,rnd=%s\n",
x,px,y,py,pz,mpfr_print_rnd_mode(rnd_mode));
printf("got "); mpfr_print_binary(zz); putchar('\n');
printf("instead of "); mpfr_print_binary(xx); putchar('\n');
exit(1);
}
mpfr_clear(xx); mpfr_clear(yy); mpfr_clear(zz);
}
static void
check53b (const char *xs, const char *sin_xs, mpfr_rnd_t rnd_mode)
{
mpfr_t xx, s;
mpfr_init2 (xx, 53);
mpfr_init2 (s, 53);
mpfr_set_str (xx, xs, 2, MPFR_RNDN); /* should be exact */
test_sin (s, xx, rnd_mode);
if (mpfr_cmp_str (s, sin_xs, 2, MPFR_RNDN))
{
printf ("mpfr_sin failed in rounding mode %s for\n x = %s\n",
mpfr_print_rnd_mode (rnd_mode), xs);
printf (" got ");
mpfr_out_str (stdout, 2, 0, s, MPFR_RNDN);
printf ("\nexpected %s\n", sin_xs);
exit (1);
}
mpfr_clear (xx);
mpfr_clear (s);
}
/* Bug reported by Laurent Fousse for the 2.4 branch.
No problem in the trunk.
https://sympa.inria.fr/sympa/arc/mpfr/2009-11/msg00044.html */
static void
bug20091122 (void)
{
mpfr_t x, y, z, yref, zref;
mpfr_prec_t p = 3;
mpfr_rnd_t r = MPFR_RNDN;
mpfr_init2 (x, 5);
mpfr_init2 (y, p);
mpfr_init2 (z, p);
mpfr_init2 (yref, p);
mpfr_init2 (zref, p);
mpfr_set_str (x, "0.11111E49", 2, MPFR_RNDN);
mpfr_sin_cos (yref, zref, x, r);
mpfr_sin (y, x, r);
mpfr_cos (z, x, r);
if (! mpfr_equal_p (y, yref))
{
printf ("mpfr_sin_cos and mpfr_sin disagree (bug20091122)\n");
printf ("yref = "); mpfr_dump (yref);
printf ("y = "); mpfr_dump (y);
exit (1);
}
if (! mpfr_equal_p (z, zref))
{
printf ("mpfr_sin_cos and mpfr_cos disagree (bug20091122)\n");
printf ("zref = "); mpfr_dump (zref);
printf ("z = "); mpfr_dump (z);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
mpfr_clear (yref);
mpfr_clear (zref);
}
static void
check4 (const char *Ns, const char *Ds, mpfr_rnd_t rnd_mode, int p,
const char *Qs)
{
mpfr_t q, n, d;
mpfr_inits2 (p, q, n, d, (mpfr_ptr) 0);
mpfr_set_str1 (n, Ns);
mpfr_set_str1 (d, Ds);
test_div(q, n, d, rnd_mode);
if (mpfr_cmp_str (q, Qs, ((p==53) ? 10 : 2), MPFR_RNDN) )
{
printf ("mpfr_div failed for n=%s, d=%s, p=%d, rnd_mode=%s\n",
Ns, Ds, p, mpfr_print_rnd_mode (rnd_mode));
printf ("got ");mpfr_print_binary(q);
mpfr_set_str (q, Qs, ((p==53) ? 10 : 2), MPFR_RNDN);
printf("\nexpected "); mpfr_print_binary(q);
putchar('\n');
exit (1);
}
mpfr_clears (q, n, d, (mpfr_ptr) 0);
}
static void
check_regression (void)
{
mpfr_t x, y;
mpfr_prec_t p;
int i;
p = strlen (xs) - 2 - 3;
mpfr_inits2 (p, x, y, (mpfr_ptr) 0);
mpfr_set_str (x, xs, 2, MPFR_RNDN);
i = mpfr_sin (y, x, MPFR_RNDN);
if (i >= 0
|| mpfr_cmp_str (y, "0.111001110011110011110001010110011101110E-1",
2, MPFR_RNDN))
{
printf ("Regression test failed (1) i=%d\ny=", i);
mpfr_dump (y);
exit (1);
}
mpfr_clears (x, y, (mpfr_ptr) 0);
}
static void
check_reduced_exprange (void)
{
mpfr_t x;
char *s;
mpfr_exp_t emax, e;
emax = mpfr_get_emax ();
mpfr_init2 (x, 8);
mpfr_set_str (x, "0.11111111E0", 2, MPFR_RNDN);
set_emax (0);
s = mpfr_get_str (NULL, &e, 16, 0, x, MPFR_RNDN);
set_emax (emax);
if (strcmp (s, "ff0"))
{
printf ("Error for mpfr_get_str on 0.11111111E0 in base 16:\n"
"Got \"%s\" instead of \"ff0\".\n", s);
exit (1);
}
mpfr_free_str (s);
mpfr_clear (x);
}
static void
check2b (const char *xs, int px,
const char *ys, int py,
const char *rs, int pz,
mp_rnd_t rnd_mode)
{
mpfr_t xx, yy, zz;
mpfr_init2(xx,px); mpfr_init2(yy,py); mpfr_init2(zz,pz);
mpfr_set_str_binary (xx, xs);
mpfr_set_str_binary (yy, ys);
test_add (zz, xx, yy, rnd_mode);
if (mpfr_cmp_str (zz, rs, 2, GMP_RNDN))
{
printf ("(2) x=%s,%d y=%s,%d pz=%d,rnd=%s\n",
xs, px, ys, py, pz, mpfr_print_rnd_mode (rnd_mode));
printf ("got "); mpfr_print_binary(zz); puts ("");
mpfr_set_str(zz, rs, 2, GMP_RNDN);
printf ("instead of "); mpfr_print_binary(zz); puts ("");
exit (1);
}
mpfr_clear(xx); mpfr_clear(yy); mpfr_clear(zz);
}
static void
reuse_bug (void)
{
mpc_t z1;
/* reuse bug found by Paul Zimmermann 20081021 */
mpc_init2 (z1, 2);
/* RE (z1^2) overflows, IM(z^2) = -0 */
mpfr_set_str (mpc_realref (z1), "0.11", 2, MPFR_RNDN);
mpfr_mul_2si (mpc_realref (z1), mpc_realref (z1), mpfr_get_emax (), MPFR_RNDN);
mpfr_set_ui (mpc_imagref (z1), 0, MPFR_RNDN);
mpc_conj (z1, z1, MPC_RNDNN);
mpc_sqr (z1, z1, MPC_RNDNN);
if (!mpfr_inf_p (mpc_realref (z1)) || mpfr_signbit (mpc_realref (z1))
||!mpfr_zero_p (mpc_imagref (z1)) || !mpfr_signbit (mpc_imagref (z1)))
{
printf ("Error: Regression, bug 20081021 reproduced\n");
MPC_OUT (z1);
exit (1);
}
mpc_clear (z1);
}
/* From the MPFR (2.3.2, 2008) doc :
-- Function:
int mpfr_set_str (mpfr_t ROP, const char *S, int BASE, mpfr_rnd_t RND)
Set ROP to the value of the whole string S in base BASE, rounded
in the direction RND. See the documentation of `mpfr_strtofr' for
a detailed description of the valid string formats. This function
returns 0 if the entire string up to the final null character is a
valid number in base BASE; otherwise it returns -1, and ROP may
have changed.
*/
SEXP str2mpfr1_list(SEXP x, SEXP prec, SEXP base, SEXP rnd_mode)
{
/* NB: Both x and prec are "recycled" to the longer one if needed */
int ibase = asInteger(base), *iprec,
nx = LENGTH(x), np = LENGTH(prec),
n = (nx == 0 || np == 0) ? 0 : imax2(nx, np),
nprot = 1;
SEXP val = PROTECT(allocVector(VECSXP, n));
mpfr_rnd_t rnd = R_rnd2MP(rnd_mode);
mpfr_t r_i;
mpfr_init(r_i);
if(!isString(x)) { PROTECT(x = coerceVector(x, STRSXP)); nprot++; }
if(!isInteger(prec)) { PROTECT(prec = coerceVector(prec, INTSXP)); nprot++; }
iprec = INTEGER(prec);
for(int i = 0; i < n; i++) {
int prec_i = iprec[i % np];
R_mpfr_check_prec(prec_i);
mpfr_set_prec(r_i, (mpfr_prec_t) prec_i);
int ierr = mpfr_set_str(r_i, CHAR(STRING_ELT(x, i % nx)), ibase, rnd);
if(ierr) {
if (!strcmp("NA", CHAR(STRING_ELT(x, i % nx))))
mpfr_set_nan(r_i); // "NA" <=> "NaN" (which *are* treated well, by mpfr_set_str)
else
error("str2mpfr1_list(x, *): x[%d] cannot be made into MPFR",
i+1);
}
/* FIXME: become more efficient by doing R_..._2R_init() only once*/
SET_VECTOR_ELT(val, i, MPFR_as_R(r_i));
}
mpfr_clear (r_i);
mpfr_free_cache();
UNPROTECT(nprot);
return val;
}
/* check sign of inexact flag */
static void
check_inexact (void)
{
mpfr_t x, y;
int inexact;
mpfr_init2 (x, 53);
mpfr_init2 (y, 53);
mpfr_set_str_binary (x,
"1.0000000000001001000110100100101000001101101011100101e2");
inexact = mpfr_exp (y, x, GMP_RNDN);
if (inexact <= 0)
{
printf ("Wrong inexact flag\n");
exit (1);
}
/* Bug due to wrong approximation of (x)/log2 */
mpfr_set_prec (x, 163);
mpfr_set_str (x, "-4.28ac8fceeadcda06bb56359017b1c81b85b392e7", 16,
GMP_RNDN);
mpfr_exp (x, x, GMP_RNDN);
if (mpfr_cmp_str (x, "3.fffffffffffffffffffffffffffffffffffffffe8@-2",
16, GMP_RNDN))
{
printf ("Error for x= -4.28ac8fceeadcda06bb56359017b1c81b85b392e7");
printf ("expected 3.fffffffffffffffffffffffffffffffffffffffe8@-2");
printf ("Got ");
mpfr_out_str (stdout, 16, 0, x, GMP_RNDN); putchar ('\n');
}
mpfr_clear (x);
mpfr_clear (y);
}
static int
my_setstr (mpfr_ptr t, const char *s)
{
if (strcmp (s, "min") == 0)
{
mpfr_setmin (t, mpfr_get_emin ());
MPFR_SET_POS (t);
return 0;
}
if (strcmp (s, "min+") == 0)
{
mpfr_setmin (t, mpfr_get_emin ());
MPFR_SET_POS (t);
mpfr_nextabove (t);
return 0;
}
if (strcmp (s, "max") == 0)
{
mpfr_setmax (t, mpfr_get_emax ());
MPFR_SET_POS (t);
return 0;
}
return mpfr_set_str (t, s, 10, MPFR_RNDN);
}
int main (int argc, char** argv)
{
mpfr_t a;
mpfr_t b;
mpfr_t c;
char* lpsz;
mpfr_exp_t exp = 0;
int num = 100 * MPFR_VERSION_MAJOR + 10 * MPFR_VERSION_MINOR + MPFR_VERSION_PATCHLEVEL;
if (!(num >= 312 && strlen(mpfr_get_version()) > 0))
{
return 1;
}
mpfr_inits2(32, a, b, c, NULL);
mpfr_set_str(a, "3.1415926535897932384626433832795028841971693993751058209749445923078164062862", 10, MPFR_RNDN);
mpfr_set_si(b, 12345678, MPFR_RNDN);
mpfr_mul(c, a, b, MPFR_RNDN);
lpsz = mpfr_get_str(NULL, &exp, 10, 13, c, MPFR_RNDN);
if (strcmp(lpsz, "3878509131250") != 0)
{
return 1;
}
return 0;
}
void mp_Iinv (mp_interval_t *rop, mp_interval_t op) {
// CHECK IF OP = [0,0]
if (mpfr_cmp_si (op.a, 0) == 0 && mpfr_cmp_si (op.b, 0) == 0) {
mpfr_set_str (rop->a, "nan", 10, MPFR_RNDD);
mpfr_set_str (rop->b, "nan", 10, MPFR_RNDU);
return;
}
// CHECKS WHETHER ZERO IS CONTAINED IN OP
if (mp_isZeroContained (op)) {
// IF ZERO IS LEFT BOUNDARY
if (mpfr_cmp_si (op.a, 0) == 0) {
mpfr_si_div (rop->a, 1, op.b, MPFR_RNDD);
mpfr_set_str (rop->b, "+inf", 10, MPFR_RNDU);
return;
}
// IF ZERO IS RIGHT BOUNDARY
if (mpfr_cmp_si (op.b, 0) == 0) {
mpfr_si_div (rop->b, 1, op.a, MPFR_RNDU);
mpfr_set_str (rop->a, "-inf", 10, MPFR_RNDD);
return;
}
// ZERO IS EXTRICTLY CONTAINED IN op
mpfr_set_str (rop->a, "-inf", 10, MPFR_RNDD);
mpfr_set_str (rop->b, "+inf", 10, MPFR_RNDU);
return;
}
// ZERO IS NOT IN op
mpfr_t ropA; mpfr_init (ropA);
mpfr_si_div (ropA, 1, op.b, MPFR_RNDD);
mpfr_si_div (rop->b, 1, op.a, MPFR_RNDU);
mpfr_set (rop->a, ropA, MPFR_RNDD);
mpfr_clear (ropA);
}
int
main (int argc, char *argv[])
{
mpfr_t x, y;
long n;
mpfr_prec_t prec = 53;
tests_start_mpfr ();
mpfr_init (x);
mpfr_init (y);
if (argc != 1)
{
if (argc != 4)
{
printf ("Usage: tyn n x prec\n");
exit (1);
}
n = atoi (argv[1]);
prec = atoi (argv[3]);
mpfr_set_prec (x, prec);
mpfr_set_prec (y, prec);
mpfr_set_str (x, argv[2], 10, MPFR_RNDN);
mpfr_yn (y, n, x, MPFR_RNDN);
printf ("Y(%ld,", n);
mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);
printf (")=");
mpfr_out_str (stdout, 10, 0, y, MPFR_RNDN);
printf ("\n");
goto end;
}
/* special values */
mpfr_set_nan (x);
mpfr_yn (y, 17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_nan_p (y));
mpfr_set_inf (x, 1); /* +Inf */
mpfr_yn (y, 17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_POS (y));
mpfr_set_inf (x, -1); /* -Inf */
mpfr_yn (y, 17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_nan_p (y));
mpfr_set_ui (x, 0, MPFR_RNDN); /* +0 */
mpfr_yn (y, 0, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_NEG (y)); /* y0(+0)=-Inf */
mpfr_yn (y, 17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_NEG (y)); /* y17(+0)=-Inf */
mpfr_yn (y, -17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_POS (y)); /* y(-17,+0)=+Inf */
mpfr_yn (y, -42, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_NEG (y)); /* y(-42,+0)=-Inf */
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_neg (x, x, MPFR_RNDN); /* -0 */
mpfr_yn (y, 0, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_NEG (y)); /* y0(-0)=-Inf */
mpfr_yn (y, 17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_NEG (y)); /* y17(-0)=-Inf */
mpfr_yn (y, -17, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_POS (y)); /* y(-17,-0)=+Inf */
mpfr_yn (y, -42, x, MPFR_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && MPFR_IS_NEG (y)); /* y(-42,-0)=-Inf */
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_yn (y, 0, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.00010110100110000000001000100110111100110101100011011111");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_yn for n=0, x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_yn (y, 1, x, MPFR_RNDN);
mpfr_set_str_binary (x, "-0.110001111111110110010000001111101011001101011100101");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_yn for n=1, x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_yn (y, -1, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.110001111111110110010000001111101011001101011100101");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_yn for n=-1, x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_yn (y, 2, x, MPFR_RNDN);
mpfr_set_str_binary (x, "-1.101001101001001100100010101001000101101000010010001");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_yn for n=2, x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_yn (y, -2, x, MPFR_RNDN);
mpfr_set_str_binary (x, "-1.101001101001001100100010101001000101101000010010001");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_yn for n=-2, x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_yn (y, 17, x, MPFR_RNDN);
mpfr_set_str_binary (x, "-0.11000100111000100010101101011000110011001101100001011E60");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_yn for n=17, x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_yn (y, -17, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.11000100111000100010101101011000110011001101100001011E60");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_yn for n=-17, x=1, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
mpfr_set_ui (x, 17, MPFR_RNDN);
mpfr_yn (y, 1, x, MPFR_RNDN);
mpfr_set_str_binary (x, "0.00101010110011011111001100000001101011011001111111");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_yn for n=1, x=17, rnd=MPFR_RNDN\n");
printf ("Expected "); mpfr_dump (x);
printf ("Got "); mpfr_dump (y);
exit (1);
}
end:
mpfr_clear (x);
mpfr_clear (y);
tests_end_mpfr ();
return 0;
}
int
main (int argc, char *argv[])
{
mpfr_t x, y, r;
long q[1];
if (argc == 3) /* usage: tremquo x y (rnd=MPFR_RNDN implicit) */
{
mpfr_init2 (x, GMP_NUMB_BITS);
mpfr_init2 (y, GMP_NUMB_BITS);
mpfr_init2 (r, GMP_NUMB_BITS);
mpfr_set_str (x, argv[1], 10, MPFR_RNDN);
mpfr_set_str (y, argv[2], 10, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
printf ("r=");
mpfr_out_str (stdout, 10, 0, r, MPFR_RNDN);
printf (" q=%ld\n", q[0]);
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (r);
return 0;
}
tests_start_mpfr ();
bug20090227 ();
mpfr_init (x);
mpfr_init (y);
mpfr_init (r);
/* special values */
mpfr_set_nan (x);
mpfr_set_ui (y, 1, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN(mpfr_nan_p (r));
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_set_nan (y);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN(mpfr_nan_p (r));
mpfr_set_inf (x, 1); /* +Inf */
mpfr_set_ui (y, 1, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_nan_p (r));
mpfr_set_inf (x, 1); /* +Inf */
mpfr_set_ui (y, 0, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_nan_p (r));
mpfr_set_inf (x, 1); /* +Inf */
mpfr_set_inf (y, 1);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_nan_p (r));
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_set_inf (y, 1);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_ui (r, 0) == 0 && MPFR_IS_POS (r));
MPFR_ASSERTN (q[0] == (long) 0);
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_neg (x, x, MPFR_RNDN); /* -0 */
mpfr_set_inf (y, 1);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_ui (r, 0) == 0 && MPFR_IS_NEG (r));
MPFR_ASSERTN (q[0] == (long) 0);
mpfr_set_ui (x, 17, MPFR_RNDN);
mpfr_set_inf (y, 1);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp (r, x) == 0);
MPFR_ASSERTN (q[0] == (long) 0);
mpfr_set_ui (x, 17, MPFR_RNDN);
mpfr_set_ui (y, 0, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_nan_p (r));
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_set_ui (y, 17, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_ui (r, 0) == 0 && MPFR_IS_POS (r));
MPFR_ASSERTN (q[0] == (long) 0);
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_neg (x, x, MPFR_RNDN);
mpfr_set_ui (y, 17, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_ui (r, 0) == 0 && MPFR_IS_NEG (r));
MPFR_ASSERTN (q[0] == (long) 0);
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
/* check four possible sign combinations */
mpfr_set_ui (x, 42, MPFR_RNDN);
mpfr_set_ui (y, 17, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_ui (r, 8) == 0);
MPFR_ASSERTN (q[0] == (long) 2);
mpfr_set_si (x, -42, MPFR_RNDN);
mpfr_set_ui (y, 17, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_si (r, -8) == 0);
MPFR_ASSERTN (q[0] == (long) -2);
mpfr_set_si (x, -42, MPFR_RNDN);
mpfr_set_si (y, -17, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_si (r, -8) == 0);
MPFR_ASSERTN (q[0] == (long) 2);
mpfr_set_ui (x, 42, MPFR_RNDN);
mpfr_set_si (y, -17, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_ui (r, 8) == 0);
MPFR_ASSERTN (q[0] == (long) -2);
mpfr_set_prec (x, 100);
mpfr_set_prec (y, 50);
mpfr_set_ui (x, 42, MPFR_RNDN);
mpfr_nextabove (x); /* 42 + 2^(-94) */
mpfr_set_ui (y, 21, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_ui_2exp (r, 1, -94) == 0);
MPFR_ASSERTN (q[0] == (long) 2);
mpfr_set_prec (x, 50);
mpfr_set_prec (y, 100);
mpfr_set_ui (x, 42, MPFR_RNDN);
mpfr_nextabove (x); /* 42 + 2^(-44) */
mpfr_set_ui (y, 21, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_ui_2exp (r, 1, -44) == 0);
MPFR_ASSERTN (q[0] == (long) 2);
mpfr_set_prec (x, 100);
mpfr_set_prec (y, 50);
mpfr_set_ui (x, 42, MPFR_RNDN);
mpfr_set_ui (y, 21, MPFR_RNDN);
mpfr_nextabove (y); /* 21 + 2^(-45) */
mpfr_remquo (r, q, x, y, MPFR_RNDN);
/* r should be 42 - 2*(21 + 2^(-45)) = -2^(-44) */
MPFR_ASSERTN (mpfr_cmp_si_2exp (r, -1, -44) == 0);
MPFR_ASSERTN (q[0] == (long) 2);
mpfr_set_prec (x, 50);
mpfr_set_prec (y, 100);
mpfr_set_ui (x, 42, MPFR_RNDN);
mpfr_set_ui (y, 21, MPFR_RNDN);
mpfr_nextabove (y); /* 21 + 2^(-95) */
mpfr_remquo (r, q, x, y, MPFR_RNDN);
/* r should be 42 - 2*(21 + 2^(-95)) = -2^(-94) */
MPFR_ASSERTN (mpfr_cmp_si_2exp (r, -1, -94) == 0);
MPFR_ASSERTN (q[0] == (long) 2);
/* exercise large quotient */
mpfr_set_ui_2exp (x, 1, 65, MPFR_RNDN);
mpfr_set_ui (y, 1, MPFR_RNDN);
/* quotient is 2^65 */
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_si (r, 0) == 0);
MPFR_ASSERTN (q[0] % 1073741824L == 0L);
/* another large quotient */
mpfr_set_prec (x, 65);
mpfr_set_prec (y, 65);
mpfr_const_pi (x, MPFR_RNDN);
mpfr_mul_2exp (x, x, 63, MPFR_RNDN);
mpfr_const_log2 (y, MPFR_RNDN);
mpfr_set_prec (r, 10);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
/* q should be 41803643793084085130, r should be 605/2048 */
MPFR_ASSERTN (mpfr_cmp_ui_2exp (r, 605, -11) == 0);
MPFR_ASSERTN ((q[0] > 0) && ((q[0] % 1073741824L) == 733836170L));
/* check cases where quotient is 1.5 +/- eps */
mpfr_set_prec (x, 65);
mpfr_set_prec (y, 65);
mpfr_set_prec (r, 63);
mpfr_set_ui (x, 3, MPFR_RNDN);
mpfr_set_ui (y, 2, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
/* x/y = 1.5, quotient should be 2 (even rule), remainder should be -1 */
MPFR_ASSERTN (mpfr_cmp_si (r, -1) == 0);
MPFR_ASSERTN (q[0] == 2L);
mpfr_set_ui (x, 3, MPFR_RNDN);
mpfr_nextabove (x); /* 3 + 2^(-63) */
mpfr_set_ui (y, 2, MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
/* x/y = 1.5 + 2^(-64), quo should be 2, r should be -1 + 2^(-63) */
MPFR_ASSERTN (mpfr_add_ui (r, r, 1, MPFR_RNDN) == 0);
MPFR_ASSERTN (mpfr_cmp_ui_2exp (r, 1, -63) == 0);
MPFR_ASSERTN (q[0] == 2L);
mpfr_set_ui (x, 3, MPFR_RNDN);
mpfr_set_ui (y, 2, MPFR_RNDN);
mpfr_nextabove (y); /* 2 + 2^(-63) */
mpfr_remquo (r, q, x, y, MPFR_RNDN);
/* x/y = 1.5 - eps, quo should be 1, r should be 1 - 2^(-63) */
MPFR_ASSERTN (mpfr_sub_ui (r, r, 1, MPFR_RNDN) == 0);
MPFR_ASSERTN (mpfr_cmp_si_2exp (r, -1, -63) == 0);
MPFR_ASSERTN (q[0] == 1L);
/* bug founds by Kaveh Ghazi, 3 May 2007 */
mpfr_set_ui (x, 2, MPFR_RNDN);
mpfr_set_ui (y, 3, MPFR_RNDN);
mpfr_remainder (r, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_si (r, -1) == 0);
mpfr_set_si (x, -1, MPFR_RNDN);
mpfr_set_ui (y, 1, MPFR_RNDN);
mpfr_remainder (r, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_si (r, 0) == 0 && MPFR_SIGN (r) < 0);
/* check argument reuse */
mpfr_set_si (x, -1, MPFR_RNDN);
mpfr_set_ui (y, 1, MPFR_RNDN);
mpfr_remainder (x, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_cmp_si (x, 0) == 0 && MPFR_SIGN (x) < 0);
mpfr_set_ui_2exp (x, 1, mpfr_get_emax () - 1, MPFR_RNDN);
mpfr_set_ui_2exp (y, 1, mpfr_get_emin (), MPFR_RNDN);
mpfr_remquo (r, q, x, y, MPFR_RNDN);
MPFR_ASSERTN (mpfr_zero_p (r) && MPFR_SIGN (r) > 0);
MPFR_ASSERTN (q[0] == 0);
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (r);
tests_end_mpfr ();
return 0;
}
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);
}
int
main (int argc, char *argv[])
{
mpfr_t x, y, z, s;
tests_start_mpfr ();
mpfr_init (x);
mpfr_init (s);
mpfr_init (y);
mpfr_init (z);
/* check special cases */
mpfr_set_prec (x, 2);
mpfr_set_prec (y, 2);
mpfr_set_prec (z, 2);
mpfr_set_prec (s, 2);
mpfr_set_str (x, "-0.75", 10, GMP_RNDN);
mpfr_set_str (y, "0.5", 10, GMP_RNDN);
mpfr_set_str (z, "0.375", 10, GMP_RNDN);
mpfr_fma (s, x, y, z, GMP_RNDU); /* result is 0 */
if (mpfr_cmp_ui(s, 0))
{
printf("Error: -0.75 * 0.5 + 0.375 should be equal to 0 for prec=2\n");
exit(1);
}
mpfr_set_prec (x, 27);
mpfr_set_prec (y, 27);
mpfr_set_prec (z, 27);
mpfr_set_prec (s, 27);
mpfr_set_str_binary (x, "1.11111111111111111111111111e-1");
mpfr_set (y, x, GMP_RNDN);
mpfr_set_str_binary (z, "-1.00011110100011001011001001e-1");
if (mpfr_fma (s, x, y, z, GMP_RNDN) >= 0)
{
printf ("Wrong inexact flag for x=y=1-2^(-27)\n");
exit (1);
}
mpfr_set_nan (x);
mpfr_random (y);
mpfr_random (z);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_nan_p (s))
{
printf ("evaluation of function in x=NAN does not return NAN");
exit (1);
}
mpfr_set_nan (y);
mpfr_random (x);
mpfr_random (z);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_nan_p(s))
{
printf ("evaluation of function in y=NAN does not return NAN");
exit (1);
}
mpfr_set_nan (z);
mpfr_random (y);
mpfr_random (x);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_nan_p (s))
{
printf ("evaluation of function in z=NAN does not return NAN");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_set_inf (y, 1);
mpfr_set_inf (z, 1);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_inf_p (s) || mpfr_sgn (s) < 0)
{
printf ("Error for (+inf) * (+inf) + (+inf)\n");
exit (1);
}
mpfr_set_inf (x, -1);
mpfr_set_inf (y, -1);
mpfr_set_inf (z, 1);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_inf_p (s) || mpfr_sgn (s) < 0)
{
printf ("Error for (-inf) * (-inf) + (+inf)\n");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_set_inf (y, -1);
mpfr_set_inf (z, -1);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_inf_p (s) || mpfr_sgn (s) > 0)
{
printf ("Error for (+inf) * (-inf) + (-inf)\n");
exit (1);
}
mpfr_set_inf (x, -1);
mpfr_set_inf (y, 1);
mpfr_set_inf (z, -1);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_inf_p (s) || mpfr_sgn (s) > 0)
{
printf ("Error for (-inf) * (+inf) + (-inf)\n");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_set_ui (y, 0, GMP_RNDN);
mpfr_random (z);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_nan_p (s))
{
printf ("evaluation of function in x=INF y=0 does not return NAN");
exit (1);
}
mpfr_set_inf (y, 1);
mpfr_set_ui (x, 0, GMP_RNDN);
mpfr_random (z);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_nan_p (s))
{
printf ("evaluation of function in x=0 y=INF does not return NAN");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_random (y); /* always positive */
mpfr_set_inf (z, -1);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_nan_p (s))
{
printf ("evaluation of function in x=INF y>0 z=-INF does not return NAN");
exit (1);
}
mpfr_set_inf (y, 1);
mpfr_random (x);
mpfr_set_inf (z, -1);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_nan_p (s))
{
printf ("evaluation of function in x>0 y=INF z=-INF does not return NAN");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_random (y);
mpfr_random (z);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_inf_p (s) || mpfr_sgn (s) < 0)
{
printf ("evaluation of function in x=INF does not return INF");
exit (1);
}
mpfr_set_inf (y, 1);
mpfr_random (x);
mpfr_random (z);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_inf_p (s) || mpfr_sgn (s) < 0)
{
printf ("evaluation of function in y=INF does not return INF");
exit (1);
}
mpfr_set_inf (z, 1);
mpfr_random (x);
mpfr_random (y);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (!mpfr_inf_p (s) || mpfr_sgn (s) < 0)
{
printf ("evaluation of function in z=INF does not return INF");
exit (1);
}
mpfr_set_ui (x, 0, GMP_RNDN);
mpfr_random (y);
mpfr_random (z);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (mpfr_cmp (s, z))
{
printf ("evaluation of function in x=0 does not return z\n");
exit (1);
}
mpfr_set_ui (y, 0, GMP_RNDN);
mpfr_random (x);
mpfr_random (z);
mpfr_fma (s, x, y, z, GMP_RNDN);
if (mpfr_cmp (s, z))
{
printf ("evaluation of function in y=0 does not return z\n");
exit (1);
}
{
mp_prec_t prec;
mpfr_t t, slong;
mp_rnd_t rnd;
int inexact, compare;
unsigned int n;
mp_prec_t p0=2, p1=200;
unsigned int N=200;
mpfr_init (t);
mpfr_init (slong);
/* generic test */
for (prec = p0; prec <= p1; prec++)
{
mpfr_set_prec (x, prec);
mpfr_set_prec (y, prec);
mpfr_set_prec (z, prec);
mpfr_set_prec (s, prec);
mpfr_set_prec (t, prec);
for (n=0; n<N; n++)
{
mpfr_random (x);
mpfr_random (y);
mpfr_random (z);
if (randlimb () % 2)
mpfr_neg (x, x, GMP_RNDN);
if (randlimb () % 2)
mpfr_neg (y, y, GMP_RNDN);
if (randlimb () % 2)
mpfr_neg (z, z, GMP_RNDN);
rnd = (mp_rnd_t) RND_RAND ();
mpfr_set_prec (slong, 2 * prec);
if (mpfr_mul (slong, x, y, rnd))
{
printf ("x*y should be exact\n");
exit (1);
}
compare = mpfr_add (t, slong, z, rnd);
inexact = mpfr_fma (s, x, y, z, rnd);
if (mpfr_cmp (s, t))
{
printf ("results differ for x=");
mpfr_out_str (stdout, 2, prec, x, GMP_RNDN);
printf (" y=");
mpfr_out_str (stdout, 2, prec, y, GMP_RNDN);
printf (" z=");
mpfr_out_str (stdout, 2, prec, z, GMP_RNDN);
printf (" prec=%u rnd_mode=%s\n", (unsigned int) prec,
mpfr_print_rnd_mode (rnd));
printf ("got ");
mpfr_out_str (stdout, 2, prec, s, GMP_RNDN);
puts ("");
printf ("expected ");
mpfr_out_str (stdout, 2, prec, t, GMP_RNDN);
puts ("");
printf ("approx ");
mpfr_print_binary (slong);
puts ("");
exit (1);
}
if (((inexact == 0) && (compare != 0)) ||
((inexact < 0) && (compare >= 0)) ||
((inexact > 0) && (compare <= 0)))
{
printf ("Wrong inexact flag for rnd=%s: expected %d, got %d\n",
mpfr_print_rnd_mode (rnd), compare, inexact);
printf (" x="); mpfr_out_str (stdout, 2, 0, x, GMP_RNDN);
printf (" y="); mpfr_out_str (stdout, 2, 0, y, GMP_RNDN);
printf (" z="); mpfr_out_str (stdout, 2, 0, z, GMP_RNDN);
printf (" s="); mpfr_out_str (stdout, 2, 0, s, GMP_RNDN);
printf ("\n");
exit (1);
}
}
}
mpfr_clear (t);
mpfr_clear (slong);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
mpfr_clear (s);
test_exact ();
test_overflow1 ();
test_overflow2 ();
test_underflow1 ();
test_underflow2 ();
tests_end_mpfr ();
return 0;
}
static void
special (void)
{
mpfr_t x, y;
int inex;
mpfr_init (x);
mpfr_init (y);
mpfr_set_nan (x);
mpfr_gamma (y, x, GMP_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error for gamma(NaN)\n");
exit (1);
}
mpfr_set_inf (x, -1);
mpfr_gamma (y, x, GMP_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error for gamma(-Inf)\n");
exit (1);
}
mpfr_set_inf (x, 1);
mpfr_gamma (y, x, GMP_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error for gamma(+Inf)\n");
exit (1);
}
mpfr_set_ui (x, 0, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error for gamma(+0)\n");
exit (1);
}
mpfr_set_ui (x, 0, GMP_RNDN);
mpfr_neg (x, x, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) > 0)
{
printf ("Error for gamma(-0)\n");
exit (1);
}
mpfr_set_ui (x, 1, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
if (mpfr_cmp_ui (y, 1))
{
printf ("Error for gamma(1)\n");
exit (1);
}
mpfr_set_si (x, -1, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
if (!mpfr_nan_p (y))
{
printf ("Error for gamma(-1)\n");
exit (1);
}
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
#define CHECK_X1 "1.0762904832837976166"
#define CHECK_Y1 "0.96134843256452096050"
mpfr_set_str (x, CHECK_X1, 10, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_str (x, CHECK_Y1, 10, GMP_RNDN);
if (mpfr_cmp (y, x))
{
printf ("mpfr_lngamma("CHECK_X1") is wrong:\n"
"expected ");
mpfr_print_binary (x); putchar ('\n');
printf ("got ");
mpfr_print_binary (y); putchar ('\n');
exit (1);
}
#define CHECK_X2 "9.23709516716202383435e-01"
#define CHECK_Y2 "1.0502315560291053398"
mpfr_set_str (x, CHECK_X2, 10, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_str (x, CHECK_Y2, 10, GMP_RNDN);
if (mpfr_cmp (y, x))
{
printf ("mpfr_lngamma("CHECK_X2") is wrong:\n"
"expected ");
mpfr_print_binary (x); putchar ('\n');
printf ("got ");
mpfr_print_binary (y); putchar ('\n');
exit (1);
}
mpfr_set_prec (x, 8);
mpfr_set_prec (y, 175);
mpfr_set_ui (x, 33, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDU);
mpfr_set_prec (x, 175);
mpfr_set_str_binary (x, "0.110010101011010101101000010101010111000110011101001000101011000001100010111001101001011E118");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_gamma (1)\n");
exit (1);
}
mpfr_set_prec (x, 21);
mpfr_set_prec (y, 8);
mpfr_set_ui (y, 120, GMP_RNDN);
mpfr_gamma (x, y, GMP_RNDZ);
mpfr_set_prec (y, 21);
mpfr_set_str_binary (y, "0.101111101110100110110E654");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_gamma (120)\n");
printf ("Expected "); mpfr_print_binary (y); puts ("");
printf ("Got "); mpfr_print_binary (x); puts ("");
exit (1);
}
mpfr_set_prec (x, 3);
mpfr_set_prec (y, 206);
mpfr_set_str_binary (x, "0.110e10");
inex = mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_prec (x, 206);
mpfr_set_str_binary (x, "0.110111100001000001101010010001000111000100000100111000010011100011011111001100011110101000111101101100110001001100110100001001111110000101010000100100011100010011101110000001000010001100010000101001111E6250");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_gamma (768)\n");
exit (1);
}
if (inex <= 0)
{
printf ("Wrong flag for mpfr_gamma (768)\n");
exit (1);
}
/* worst case to exercise retry */
mpfr_set_prec (x, 1000);
mpfr_set_prec (y, 869);
mpfr_const_pi (x, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_prec (x, 4);
mpfr_set_prec (y, 4);
mpfr_set_str_binary (x, "-0.1100E-66");
mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_str_binary (x, "-0.1011E67");
if (mpfr_cmp (x, y))
{
printf ("Error for gamma(-0.1100E-66)\n");
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
}
static void
special_overflow (void)
{
mpfr_t x, y;
mp_exp_t emin, emax;
int inex;
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
set_emin (-125);
set_emax (128);
mpfr_init2 (x, 24);
mpfr_init2 (y, 24);
mpfr_set_str_binary (x, "0.101100100000000000110100E7");
mpfr_gamma (y, x, GMP_RNDN);
if (!mpfr_inf_p (y))
{
printf ("Overflow error.\n");
mpfr_dump (y);
exit (1);
}
/* problem mentioned by Kenneth Wilder, 18 Aug 2005 */
mpfr_set_prec (x, 29);
mpfr_set_prec (y, 29);
mpfr_set_str (x, "-200000000.5", 10, GMP_RNDN); /* exact */
mpfr_gamma (y, x, GMP_RNDN);
if (!(mpfr_zero_p (y) && MPFR_SIGN (y) < 0))
{
printf ("Error for gamma(-200000000.5)\n");
printf ("expected -0");
printf ("got ");
mpfr_dump (y);
exit (1);
}
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str (x, "-200000000.1", 10, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
if (!(mpfr_zero_p (y) && MPFR_SIGN (y) < 0))
{
printf ("Error for gamma(-200000000.1), prec=53\n");
printf ("expected -0");
printf ("got ");
mpfr_dump (y);
exit (1);
}
/* another problem mentioned by Kenneth Wilder, 29 Aug 2005 */
mpfr_set_prec (x, 333);
mpfr_set_prec (y, 14);
mpfr_set_str (x, "-2.0000000000000000000000005", 10, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_prec (x, 14);
mpfr_set_str_binary (x, "-11010011110001E66");
if (mpfr_cmp (x, y))
{
printf ("Error for gamma(-2.0000000000000000000000005)\n");
printf ("expected "); mpfr_dump (x);
printf ("got "); mpfr_dump (y);
exit (1);
}
/* another tests from Kenneth Wilder, 31 Aug 2005 */
set_emax (200);
set_emin (-200);
mpfr_set_prec (x, 38);
mpfr_set_prec (y, 54);
mpfr_set_str_binary (x, "0.11101111011100111101001001010110101001E-166");
mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_prec (x, 54);
mpfr_set_str_binary (x, "0.100010001101100001110110001010111111010000100101011E167");
if (mpfr_cmp (x, y))
{
printf ("Error for gamma (test 1)\n");
printf ("expected "); mpfr_dump (x);
printf ("got "); mpfr_dump (y);
exit (1);
}
set_emax (1000);
set_emin (-2000);
mpfr_set_prec (x, 38);
mpfr_set_prec (y, 71);
mpfr_set_str_binary (x, "10101011011100001111111000010111110010E-1034");
/* 184083777010*2^(-1034) */
mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_prec (x, 71);
mpfr_set_str_binary (x, "10111111001000011110010001000000000000110011110000000011101011111111100E926");
/* 1762885132679550982140*2^926 */
if (mpfr_cmp (x, y))
{
printf ("Error for gamma (test 2)\n");
printf ("expected "); mpfr_dump (x);
printf ("got "); mpfr_dump (y);
exit (1);
}
mpfr_set_prec (x, 38);
mpfr_set_prec (y, 88);
mpfr_set_str_binary (x, "10111100111001010000100001100100100101E-104");
/* 202824096037*2^(-104) */
mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_prec (x, 88);
mpfr_set_str_binary (x, "1010110101111000111010111100010110101010100110111000001011000111000011101100001101110010E-21");
/* 209715199999500283894743922*2^(-21) */
if (mpfr_cmp (x, y))
{
printf ("Error for gamma (test 3)\n");
printf ("expected "); mpfr_dump (x);
printf ("got "); mpfr_dump (y);
exit (1);
}
mpfr_set_prec (x, 171);
mpfr_set_prec (y, 38);
mpfr_set_str (x, "-2993155353253689176481146537402947624254601559176535", 10,
GMP_RNDN);
mpfr_div_2exp (x, x, 170, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_prec (x, 38);
mpfr_set_str (x, "201948391737", 10, GMP_RNDN);
mpfr_mul_2exp (x, x, 92, GMP_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Error for gamma (test 5)\n");
printf ("expected "); mpfr_dump (x);
printf ("got "); mpfr_dump (y);
exit (1);
}
set_emin (-500000);
mpfr_set_prec (x, 337);
mpfr_set_prec (y, 38);
mpfr_set_str (x, "-30000.000000000000000000000000000000000000000000001", 10,
GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_prec (x, 38);
mpfr_set_str (x, "-3.623795987425E-121243", 10, GMP_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Error for gamma (test 7)\n");
printf ("expected "); mpfr_dump (x);
printf ("got "); mpfr_dump (y);
exit (1);
}
/* was producing infinite loop */
set_emin (emin);
mpfr_set_prec (x, 71);
mpfr_set_prec (y, 71);
mpfr_set_str (x, "-200000000.1", 10, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
if (!(mpfr_zero_p (y) && MPFR_SIGN (y) < 0))
{
printf ("Error for gamma (test 8)\n");
printf ("expected "); mpfr_dump (x);
printf ("got "); mpfr_dump (y);
exit (1);
}
set_emax (1073741823);
mpfr_set_prec (x, 29);
mpfr_set_prec (y, 29);
mpfr_set_str (x, "423786866", 10, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0)
{
printf ("Error for gamma(423786866)\n");
exit (1);
}
/* check exact result */
mpfr_set_prec (x, 2);
mpfr_set_ui (x, 3, GMP_RNDN);
inex = mpfr_gamma (x, x, GMP_RNDN);
if (inex != 0 || mpfr_cmp_ui (x, 2) != 0)
{
printf ("Error for gamma(3)\n");
exit (1);
}
mpfr_set_emax (1024);
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str_binary (x, "101010110100110011111010000110001000111100000110101E-43");
mpfr_gamma (x, x, GMP_RNDU);
mpfr_set_str_binary (y, "110000011110001000111110110101011110000100001111111E971");
if (mpfr_cmp (x, y) != 0)
{
printf ("Error for gamma(4)\n");
printf ("expected "); mpfr_dump (y);
printf ("got "); mpfr_dump (x);
exit (1);
}
mpfr_clear (y);
mpfr_clear (x);
set_emin (emin);
set_emax (emax);
}
