static bool
do_mpc_ckconv (real_value *result_real, real_value *result_imag,
mpc_srcptr m, bool inexact, const real_format *format)
{
/* Proceed iff we get a normal number, i.e. not NaN or Inf and no
overflow/underflow occurred. If -frounding-math, proceed iff the
result of calling FUNC was exact. */
if (!mpfr_number_p (mpc_realref (m))
|| !mpfr_number_p (mpc_imagref (m))
|| mpfr_overflow_p ()
|| mpfr_underflow_p ()
|| (flag_rounding_math && inexact))
return false;
REAL_VALUE_TYPE tmp_real, tmp_imag;
real_from_mpfr (&tmp_real, mpc_realref (m), format, GMP_RNDN);
real_from_mpfr (&tmp_imag, mpc_imagref (m), format, GMP_RNDN);
/* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values.
If the REAL_VALUE_TYPE is zero but the mpft_t is not, then we
underflowed in the conversion. */
if (!real_isfinite (&tmp_real)
|| !real_isfinite (&tmp_imag)
|| (tmp_real.cl == rvc_zero) != (mpfr_zero_p (mpc_realref (m)) != 0)
|| (tmp_imag.cl == rvc_zero) != (mpfr_zero_p (mpc_imagref (m)) != 0))
return false;
real_convert (result_real, format, &tmp_real);
real_convert (result_imag, format, &tmp_imag);
return (real_identical (result_real, &tmp_real)
&& real_identical (result_imag, &tmp_imag));
}
static int
test_add (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
{
int res;
#ifdef CHECK_EXTERNAL
int ok = rnd_mode == MPFR_RNDN && mpfr_number_p (b) && mpfr_number_p (c);
if (ok)
{
mpfr_print_raw (b);
printf (" ");
mpfr_print_raw (c);
}
#endif
if (usesp || MPFR_ARE_SINGULAR(b,c) || MPFR_SIGN(b) != MPFR_SIGN(c))
res = mpfr_add (a, b, c, rnd_mode);
else
{
if (MPFR_GET_EXP(b) < MPFR_GET_EXP(c))
res = mpfr_add1(a, c, b, rnd_mode);
else
res = mpfr_add1(a, b, c, rnd_mode);
}
#ifdef CHECK_EXTERNAL
if (ok)
{
printf (" ");
mpfr_print_raw (a);
printf ("\n");
}
#endif
return res;
}
static PyObject *
GMPy_Real_Is_Finite(PyObject *x, CTXT_Object *context)
{
MPFR_Object *tempx;
int res;
if (MPFR_Check(x)) {
res = mpfr_number_p(MPFR(x));
}
else {
CHECK_CONTEXT(context);
if (!(tempx = GMPy_MPFR_From_Real(x, 1, context))) {
return NULL;
}
res = mpfr_number_p(tempx->f);
Py_DECREF((PyObject*)tempx);
}
if (res) {
Py_RETURN_TRUE;
}
else {
Py_RETURN_FALSE;
}
}
static void
check_nan (void)
{
mpfr_t d, q;
mpfr_init2 (d, 100L);
mpfr_init2 (q, 100L);
/* 1/+inf == 0 */
MPFR_CLEAR_FLAGS (d);
MPFR_SET_INF (d);
MPFR_SET_POS (d);
MPFR_ASSERTN (mpfr_ui_div (q, 1L, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_number_p (q));
MPFR_ASSERTN (mpfr_sgn (q) == 0);
/* 1/-inf == -0 */
MPFR_CLEAR_FLAGS (d);
MPFR_SET_INF (d);
MPFR_SET_NEG (d);
MPFR_ASSERTN (mpfr_ui_div (q, 1L, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_number_p (q));
MPFR_ASSERTN (mpfr_sgn (q) == 0);
/* 1/nan == nan */
MPFR_SET_NAN (d);
MPFR_ASSERTN (mpfr_ui_div (q, 1L, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_nan_p (q));
/* 0/0 == nan */
mpfr_set_ui (d, 0L, GMP_RNDN);
MPFR_ASSERTN (mpfr_ui_div (q, 0L, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_nan_p (q));
/* 1/+0 = +inf */
mpfr_set_ui (d, 0L, GMP_RNDN);
MPFR_ASSERTN (mpfr_ui_div (q, 1L, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) > 0);
/* 1/-0 = -inf */
mpfr_set_ui (d, 0L, GMP_RNDN);
mpfr_neg (d, d, GMP_RNDN);
MPFR_ASSERTN (mpfr_ui_div (q, 1L, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) < 0);
/* 0/1 = +0 */
mpfr_set_ui (d, 1L, GMP_RNDN);
MPFR_ASSERTN (mpfr_ui_div (q, 0L, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_cmp_ui (q, 0) == 0 && MPFR_IS_POS (q));
/* 0/-1 = -0 */
mpfr_set_si (d, -1, GMP_RNDN);
MPFR_ASSERTN (mpfr_ui_div (q, 0L, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_cmp_ui (q, 0) == 0 && MPFR_IS_NEG (q));
mpfr_clear (d);
mpfr_clear (q);
}
static MPC_Object *
GMPy_MPC_From_MPC(MPC_Object *obj, mpfr_prec_t rprec, mpfr_prec_t iprec,
CTXT_Object *context)
{
MPC_Object *result = NULL;
assert(MPC_Check(obj));
/* Optimize the critical case when prec==1 or obj is NaN or Inf. */
if ((rprec == 1 && iprec == 1) ||
(!mpfr_number_p(mpc_realref(obj->c)) && !mpfr_number_p(mpc_imagref(obj->c)))) {
Py_INCREF((PyObject*)obj);
return obj;
}
CHECK_CONTEXT(context);
if (rprec == 0)
rprec = GET_REAL_PREC(context);
else if (rprec == 1)
rprec = mpfr_get_prec(mpc_realref(obj->c));
if (iprec == 0)
iprec = GET_IMAG_PREC(context);
else if (iprec == 1)
iprec = mpfr_get_prec(mpc_imagref(obj->c));
/* Try to identify when an additional reference to existing instance can
* be returned. It is possible when (1) the precision matches, (2) the
* exponent is valid and not in the range that might require subnormal-
* ization, and (3) subnormalize is not enabled.
*/
if ((rprec == mpfr_get_prec(mpc_realref(obj->c))) &&
(iprec == mpfr_get_prec(mpc_imagref(obj->c))) &&
(!context->ctx.subnormalize) &&
(mpc_realref(obj->c)->_mpfr_exp >= (context->ctx.emin + mpfr_get_prec(mpc_realref(obj->c)) - 1)) &&
(mpc_realref(obj->c)->_mpfr_exp <= context->ctx.emax) &&
(mpc_imagref(obj->c)->_mpfr_exp >= (context->ctx.emin + mpfr_get_prec(mpc_imagref(obj->c)) - 1)) &&
(mpc_imagref(obj->c)->_mpfr_exp <= context->ctx.emax)
) {
Py_INCREF((PyObject*)obj);
return obj;
}
if ((result = GMPy_MPC_New(rprec, iprec, context))) {
result->rc = mpc_set(result->c, obj->c, GET_MPC_ROUND(context));
_GMPy_MPC_Cleanup(&result, context);
}
return result;
}
static void
check_singular (void)
{
mpfr_t x, got;
mpfr_init2 (x, 100L);
mpfr_init2 (got, 100L);
/* sqrt(NaN) == NaN */
MPFR_SET_NAN (x);
MPFR_ASSERTN (test_sqrt (got, x, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_nan_p (got));
/* sqrt(-1) == NaN */
mpfr_set_si (x, -1L, MPFR_RNDZ);
MPFR_ASSERTN (test_sqrt (got, x, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_nan_p (got));
/* sqrt(+inf) == +inf */
MPFR_SET_INF (x);
MPFR_SET_POS (x);
MPFR_ASSERTN (test_sqrt (got, x, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (got));
/* sqrt(-inf) == NaN */
MPFR_SET_INF (x);
MPFR_SET_NEG (x);
MPFR_ASSERTN (test_sqrt (got, x, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_nan_p (got));
/* sqrt(+0) == +0 */
mpfr_set_si (x, 0L, MPFR_RNDZ);
MPFR_ASSERTN (test_sqrt (got, x, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_number_p (got));
MPFR_ASSERTN (mpfr_cmp_ui (got, 0L) == 0);
MPFR_ASSERTN (MPFR_IS_POS (got));
/* sqrt(-0) == -0 */
mpfr_set_si (x, 0L, MPFR_RNDZ);
MPFR_SET_NEG (x);
MPFR_ASSERTN (test_sqrt (got, x, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_number_p (got));
MPFR_ASSERTN (mpfr_cmp_ui (got, 0L) == 0);
MPFR_ASSERTN (MPFR_IS_NEG (got));
mpfr_clear (x);
mpfr_clear (got);
}
static int
test_div (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
{
int res;
int ok = rnd_mode == MPFR_RNDN && mpfr_number_p (b) && mpfr_number_p (c);
if (ok)
{
mpfr_print_raw (b);
printf (" ");
mpfr_print_raw (c);
}
res = mpfr_all_div (a, b, c, rnd_mode);
if (ok)
{
printf (" ");
mpfr_print_raw (a);
printf ("\n");
}
return res;
}
static int
test_pow (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mp_rnd_t rnd_mode)
{
int res;
int ok = rnd_mode == GMP_RNDN && mpfr_number_p (b) && mpfr_number_p (c)
&& mpfr_get_prec (a) >= 53;
if (ok)
{
mpfr_print_raw (b);
printf (" ");
mpfr_print_raw (c);
}
res = mpfr_pow (a, b, c, rnd_mode);
if (ok)
{
printf (" ");
mpfr_print_raw (a);
printf ("\n");
}
return res;
}
void print_number(FILE *OUT, int digits, complex_number z)
/***************************************************************\
* USAGE: prints z to OUT *
\***************************************************************/
{
int base = 10;
// verify that z is a valid number
if (mpfr_number_p(z->re) && mpfr_number_p(z->im))
{ // print to OUT
mpf_out_str(OUT, base, digits, z->re);
if (mpfr_sgn(z->im) >= 0)
fprintf(OUT, "+");
mpf_out_str(OUT, base, digits, z->im);
fprintf(OUT, "*I");
}
else
fprintf(OUT, "NaN+NaN*I");
return;
}
static char *
get_pretty_str (const int base, const size_t n, mpfr_srcptr x, mpfr_rnd_t rnd)
{
mp_exp_t expo;
char *ugly;
char *pretty;
if (mpfr_zero_p (x))
return pretty_zero (x);
ugly = mpfr_get_str (NULL, &expo, base, n, x, rnd);
MPC_ASSERT (ugly != NULL);
pretty = prettify (ugly, expo, base, !mpfr_number_p (x));
mpfr_free_str (ugly);
return pretty;
}
static int
test_expm1 (mpfr_ptr a, mpfr_srcptr b, mpfr_rnd_t rnd_mode)
{
int res;
int ok = rnd_mode == MPFR_RNDN && mpfr_number_p (b) && mpfr_get_prec (a)>=53;
if (ok)
{
mpfr_print_raw (b);
}
res = mpfr_expm1 (a, b, rnd_mode);
if (ok)
{
printf (" ");
mpfr_print_raw (a);
printf ("\n");
}
return res;
}
SeedValue
seed_mpfr_number_p (SeedContext ctx,
SeedObject function,
SeedObject this_object,
gsize argument_count,
const SeedValue args[],
SeedException *exception)
{
mpfr_ptr rop;
gboolean ret;
CHECK_ARG_COUNT("mpfr.number_p", 0);
rop = seed_object_get_private(this_object);
ret = mpfr_number_p(rop);
return seed_value_from_boolean(ctx, ret, exception);
}
/* Put in z the value of x^y, rounded according to 'rnd'.
Return the inexact flag in [0, 10]. */
int
mpc_pow (mpc_ptr z, mpc_srcptr x, mpc_srcptr y, mpc_rnd_t rnd)
{
int ret = -2, loop, x_real, y_real, z_real = 0, z_imag = 0;
mpc_t t, u;
mp_prec_t p, q, pr, pi, maxprec;
long Q;
x_real = mpfr_zero_p (MPC_IM(x));
y_real = mpfr_zero_p (MPC_IM(y));
if (y_real && mpfr_zero_p (MPC_RE(y))) /* case y zero */
{
if (x_real && mpfr_zero_p (MPC_RE(x))) /* 0^0 = NaN +i*NaN */
{
mpfr_set_nan (MPC_RE(z));
mpfr_set_nan (MPC_IM(z));
return 0;
}
else /* x^0 = 1 +/- i*0 even for x=NaN see algorithms.tex for the
sign of zero */
{
mpfr_t n;
int inex, cx1;
int sign_zi;
/* cx1 < 0 if |x| < 1
cx1 = 0 if |x| = 1
cx1 > 0 if |x| > 1
*/
mpfr_init (n);
inex = mpc_norm (n, x, GMP_RNDN);
cx1 = mpfr_cmp_ui (n, 1);
if (cx1 == 0 && inex != 0)
cx1 = -inex;
sign_zi = (cx1 < 0 && mpfr_signbit (MPC_IM (y)) == 0)
|| (cx1 == 0
&& mpfr_signbit (MPC_IM (x)) != mpfr_signbit (MPC_RE (y)))
|| (cx1 > 0 && mpfr_signbit (MPC_IM (y)));
/* warning: mpc_set_ui_ui does not set Im(z) to -0 if Im(rnd)=RNDD */
ret = mpc_set_ui_ui (z, 1, 0, rnd);
if (MPC_RND_IM (rnd) == GMP_RNDD || sign_zi)
mpc_conj (z, z, MPC_RNDNN);
mpfr_clear (n);
return ret;
}
}
if (mpfr_nan_p (MPC_RE(x)) || mpfr_nan_p (MPC_IM(x)) ||
mpfr_nan_p (MPC_RE(y)) || mpfr_nan_p (MPC_IM(y)) ||
mpfr_inf_p (MPC_RE(x)) || mpfr_inf_p (MPC_IM(x)) ||
mpfr_inf_p (MPC_RE(y)) || mpfr_inf_p (MPC_IM(y)))
{
/* special values: exp(y*log(x)) */
mpc_init2 (u, 2);
mpc_log (u, x, MPC_RNDNN);
mpc_mul (u, u, y, MPC_RNDNN);
ret = mpc_exp (z, u, rnd);
mpc_clear (u);
goto end;
}
if (x_real) /* case x real */
{
if (mpfr_zero_p (MPC_RE(x))) /* x is zero */
{
/* special values: exp(y*log(x)) */
mpc_init2 (u, 2);
mpc_log (u, x, MPC_RNDNN);
mpc_mul (u, u, y, MPC_RNDNN);
ret = mpc_exp (z, u, rnd);
mpc_clear (u);
goto end;
}
/* Special case 1^y = 1 */
if (mpfr_cmp_ui (MPC_RE(x), 1) == 0)
{
int s1, s2;
s1 = mpfr_signbit (MPC_RE (y));
s2 = mpfr_signbit (MPC_IM (x));
ret = mpc_set_ui (z, +1, rnd);
/* the sign of the zero imaginary part is known in some cases (see
algorithm.tex). In such cases we have
(x +s*0i)^(y+/-0i) = x^y + s*sign(y)*0i
where s = +/-1. We extend here this rule to fix the sign of the
zero part.
Note that the sign must also be set explicitly when rnd=RNDD
because mpfr_set_ui(z_i, 0, rnd) always sets z_i to +0.
*/
if (MPC_RND_IM (rnd) == GMP_RNDD || s1 != s2)
mpc_conj (z, z, MPC_RNDNN);
goto end;
}
/* x^y is real when:
(a) x is real and y is integer
(b) x is real non-negative and y is real */
if (y_real && (mpfr_integer_p (MPC_RE(y)) ||
mpfr_cmp_ui (MPC_RE(x), 0) >= 0))
{
int s1, s2;
s1 = mpfr_signbit (MPC_RE (y));
s2 = mpfr_signbit (MPC_IM (x));
ret = mpfr_pow (MPC_RE(z), MPC_RE(x), MPC_RE(y), MPC_RND_RE(rnd));
ret = MPC_INEX(ret, mpfr_set_ui (MPC_IM(z), 0, MPC_RND_IM(rnd)));
/* the sign of the zero imaginary part is known in some cases
(see algorithm.tex). In such cases we have (x +s*0i)^(y+/-0i)
= x^y + s*sign(y)*0i where s = +/-1.
We extend here this rule to fix the sign of the zero part.
Note that the sign must also be set explicitly when rnd=RNDD
because mpfr_set_ui(z_i, 0, rnd) always sets z_i to +0.
*/
if (MPC_RND_IM(rnd) == GMP_RNDD || s1 != s2)
mpfr_neg (MPC_IM(z), MPC_IM(z), MPC_RND_IM(rnd));
goto end;
}
/* (-1)^(n+I*t) is real for n integer and t real */
if (mpfr_cmp_si (MPC_RE(x), -1) == 0 && mpfr_integer_p (MPC_RE(y)))
z_real = 1;
/* for x real, x^y is imaginary when:
(a) x is negative and y is half-an-integer
(b) x = -1 and Re(y) is half-an-integer
*/
if (mpfr_cmp_ui (MPC_RE(x), 0) < 0 && is_odd (MPC_RE(y), 1) &&
(y_real || mpfr_cmp_si (MPC_RE(x), -1) == 0))
z_imag = 1;
}
else /* x non real */
/* I^(t*I) and (-I)^(t*I) are real for t real,
I^(n+t*I) and (-I)^(n+t*I) are real for n even and t real, and
I^(n+t*I) and (-I)^(n+t*I) are imaginary for n odd and t real
(s*I)^n is real for n even and imaginary for n odd */
if ((mpc_cmp_si_si (x, 0, 1) == 0 || mpc_cmp_si_si (x, 0, -1) == 0 ||
(mpfr_cmp_ui (MPC_RE(x), 0) == 0 && y_real)) &&
mpfr_integer_p (MPC_RE(y)))
{ /* x is I or -I, and Re(y) is an integer */
if (is_odd (MPC_RE(y), 0))
z_imag = 1; /* Re(y) odd: z is imaginary */
else
z_real = 1; /* Re(y) even: z is real */
}
else /* (t+/-t*I)^(2n) is imaginary for n odd and real for n even */
if (mpfr_cmpabs (MPC_RE(x), MPC_IM(x)) == 0 && y_real &&
mpfr_integer_p (MPC_RE(y)) && is_odd (MPC_RE(y), 0) == 0)
{
if (is_odd (MPC_RE(y), -1)) /* y/2 is odd */
z_imag = 1;
else
z_real = 1;
}
/* first bound |Re(y log(x))|, |Im(y log(x)| < 2^q */
mpc_init2 (t, 64);
mpc_log (t, x, MPC_RNDNN);
mpc_mul (t, t, y, MPC_RNDNN);
/* the default maximum exponent for MPFR is emax=2^30-1, thus if
t > log(2^emax) = emax*log(2), then exp(t) will overflow */
if (mpfr_cmp_ui_2exp (MPC_RE(t), 372130558, 1) > 0)
goto overflow;
/* the default minimum exponent for MPFR is emin=-2^30+1, thus the
smallest representable value is 2^(emin-1), and if
t < log(2^(emin-1)) = (emin-1)*log(2), then exp(t) will underflow */
if (mpfr_cmp_si_2exp (MPC_RE(t), -372130558, 1) < 0)
goto underflow;
q = mpfr_get_exp (MPC_RE(t)) > 0 ? mpfr_get_exp (MPC_RE(t)) : 0;
if (mpfr_get_exp (MPC_IM(t)) > (mp_exp_t) q)
q = mpfr_get_exp (MPC_IM(t));
pr = mpfr_get_prec (MPC_RE(z));
pi = mpfr_get_prec (MPC_IM(z));
p = (pr > pi) ? pr : pi;
p += 11; /* experimentally, seems to give less than 10% of failures in
Ziv's strategy */
mpc_init2 (u, p);
pr += MPC_RND_RE(rnd) == GMP_RNDN;
pi += MPC_RND_IM(rnd) == GMP_RNDN;
maxprec = MPFR_PREC(MPC_RE(z));
if (MPFR_PREC(MPC_IM(z)) > maxprec)
maxprec = MPFR_PREC(MPC_IM(z));
for (loop = 0;; loop++)
{
mp_exp_t dr, di;
if (p + q > 64) /* otherwise we reuse the initial approximation
t of y*log(x), avoiding two computations */
{
mpc_set_prec (t, p + q);
mpc_log (t, x, MPC_RNDNN);
mpc_mul (t, t, y, MPC_RNDNN);
}
mpc_exp (u, t, MPC_RNDNN);
/* Since the error bound is global, we have to take into account the
exponent difference between the real and imaginary parts. We assume
either the real or the imaginary part of u is not zero.
*/
dr = mpfr_zero_p (MPC_RE(u)) ? mpfr_get_exp (MPC_IM(u))
: mpfr_get_exp (MPC_RE(u));
di = mpfr_zero_p (MPC_IM(u)) ? dr : mpfr_get_exp (MPC_IM(u));
if (dr > di)
{
di = dr - di;
dr = 0;
}
else
{
dr = di - dr;
di = 0;
}
/* the term -3 takes into account the factor 4 in the complex error
(see algorithms.tex) plus one due to the exponent difference: if
z = a + I*b, where the relative error on z is at most 2^(-p), and
EXP(a) = EXP(b) + k, the relative error on b is at most 2^(k-p) */
if ((z_imag || mpfr_can_round (MPC_RE(u), p - 3 - dr, GMP_RNDN, GMP_RNDZ, pr)) &&
(z_real || mpfr_can_round (MPC_IM(u), p - 3 - di, GMP_RNDN, GMP_RNDZ, pi)))
break;
/* if Re(u) is not known to be zero, assume it is a normal number, i.e.,
neither zero, Inf or NaN, otherwise we might enter an infinite loop */
MPC_ASSERT (z_imag || mpfr_number_p (MPC_RE(u)));
/* idem for Im(u) */
MPC_ASSERT (z_real || mpfr_number_p (MPC_IM(u)));
if (ret == -2) /* we did not yet call mpc_pow_exact, or it aborted
because intermediate computations had > maxprec bits */
{
/* check exact cases (see algorithms.tex) */
if (y_real)
{
maxprec *= 2;
ret = mpc_pow_exact (z, x, MPC_RE(y), rnd, maxprec);
if (ret != -1 && ret != -2)
goto exact;
}
p += dr + di + 64;
}
else
p += p / 2;
mpc_set_prec (t, p + q);
mpc_set_prec (u, p);
}
if (z_real)
{
/* When the result is real (see algorithm.tex for details),
Im(x^y) =
+ sign(imag(y))*0i, if |x| > 1
+ sign(imag(x))*sign(real(y))*0i, if |x| = 1
- sign(imag(y))*0i, if |x| < 1
*/
mpfr_t n;
int inex, cx1;
int sign_zi;
/* cx1 < 0 if |x| < 1
cx1 = 0 if |x| = 1
cx1 > 0 if |x| > 1
*/
mpfr_init (n);
inex = mpc_norm (n, x, GMP_RNDN);
cx1 = mpfr_cmp_ui (n, 1);
if (cx1 == 0 && inex != 0)
cx1 = -inex;
sign_zi = (cx1 < 0 && mpfr_signbit (MPC_IM (y)) == 0)
|| (cx1 == 0
&& mpfr_signbit (MPC_IM (x)) != mpfr_signbit (MPC_RE (y)))
|| (cx1 > 0 && mpfr_signbit (MPC_IM (y)));
ret = mpfr_set (MPC_RE(z), MPC_RE(u), MPC_RND_RE(rnd));
/* warning: mpfr_set_ui does not set Im(z) to -0 if Im(rnd) = RNDD */
ret = MPC_INEX (ret, mpfr_set_ui (MPC_IM (z), 0, MPC_RND_IM (rnd)));
if (MPC_RND_IM (rnd) == GMP_RNDD || sign_zi)
mpc_conj (z, z, MPC_RNDNN);
mpfr_clear (n);
}
else if (z_imag)
{
ret = mpfr_set (MPC_IM(z), MPC_IM(u), MPC_RND_IM(rnd));
ret = MPC_INEX(mpfr_set_ui (MPC_RE(z), 0, MPC_RND_RE(rnd)), ret);
}
else
ret = mpc_set (z, u, rnd);
exact:
mpc_clear (t);
mpc_clear (u);
end:
return ret;
underflow:
/* If we have an underflow, we know that |z| is too small to be
represented, but depending on arg(z), we should return +/-0 +/- I*0.
We assume t is the approximation of y*log(x), thus we want
exp(t) = exp(Re(t))+exp(I*Im(t)).
FIXME: this part of code is not 100% rigorous, since we don't consider
rounding errors.
*/
mpc_init2 (u, 64);
mpfr_const_pi (MPC_RE(u), GMP_RNDN);
mpfr_div_2exp (MPC_RE(u), MPC_RE(u), 1, GMP_RNDN); /* Pi/2 */
mpfr_remquo (MPC_RE(u), &Q, MPC_IM(t), MPC_RE(u), GMP_RNDN);
if (mpfr_sgn (MPC_RE(u)) < 0)
Q--; /* corresponds to positive remainder */
mpfr_set_ui (MPC_RE(z), 0, GMP_RNDN);
mpfr_set_ui (MPC_IM(z), 0, GMP_RNDN);
switch (Q & 3)
{
case 0: /* first quadrant: round to (+0 +0) */
ret = MPC_INEX(-1, -1);
break;
case 1: /* second quadrant: round to (-0 +0) */
mpfr_neg (MPC_RE(z), MPC_RE(z), GMP_RNDN);
ret = MPC_INEX(1, -1);
break;
case 2: /* third quadrant: round to (-0 -0) */
mpfr_neg (MPC_RE(z), MPC_RE(z), GMP_RNDN);
mpfr_neg (MPC_IM(z), MPC_IM(z), GMP_RNDN);
ret = MPC_INEX(1, 1);
break;
case 3: /* fourth quadrant: round to (+0 -0) */
mpfr_neg (MPC_IM(z), MPC_IM(z), GMP_RNDN);
ret = MPC_INEX(-1, 1);
break;
}
goto clear_t_and_u;
overflow:
/* If we have an overflow, we know that |z| is too large to be
represented, but depending on arg(z), we should return +/-Inf +/- I*Inf.
We assume t is the approximation of y*log(x), thus we want
exp(t) = exp(Re(t))+exp(I*Im(t)).
FIXME: this part of code is not 100% rigorous, since we don't consider
rounding errors.
*/
mpc_init2 (u, 64);
mpfr_const_pi (MPC_RE(u), GMP_RNDN);
mpfr_div_2exp (MPC_RE(u), MPC_RE(u), 1, GMP_RNDN); /* Pi/2 */
/* the quotient is rounded to the nearest integer in mpfr_remquo */
mpfr_remquo (MPC_RE(u), &Q, MPC_IM(t), MPC_RE(u), GMP_RNDN);
if (mpfr_sgn (MPC_RE(u)) < 0)
Q--; /* corresponds to positive remainder */
switch (Q & 3)
{
case 0: /* first quadrant */
mpfr_set_inf (MPC_RE(z), 1);
mpfr_set_inf (MPC_IM(z), 1);
ret = MPC_INEX(1, 1);
break;
case 1: /* second quadrant */
mpfr_set_inf (MPC_RE(z), -1);
mpfr_set_inf (MPC_IM(z), 1);
ret = MPC_INEX(-1, 1);
break;
case 2: /* third quadrant */
mpfr_set_inf (MPC_RE(z), -1);
mpfr_set_inf (MPC_IM(z), -1);
ret = MPC_INEX(-1, -1);
break;
case 3: /* fourth quadrant */
mpfr_set_inf (MPC_RE(z), 1);
mpfr_set_inf (MPC_IM(z), -1);
ret = MPC_INEX(1, -1);
break;
}
clear_t_and_u:
mpc_clear (t);
mpc_clear (u);
return ret;
}
int
mpc_log10 (mpc_ptr rop, mpc_srcptr op, mpc_rnd_t rnd)
{
int ok = 0, loops = 0, check_exact = 0, special_re, special_im,
inex, inex_re, inex_im;
mpfr_prec_t prec;
mpfr_t log10;
mpc_t log;
mpfr_init2 (log10, 2);
mpc_init2 (log, 2);
prec = MPC_MAX_PREC (rop);
/* compute log(op)/log(10) */
while (ok == 0) {
loops ++;
prec += (loops <= 2) ? mpc_ceil_log2 (prec) + 4 : prec / 2;
mpfr_set_prec (log10, prec);
mpc_set_prec (log, prec);
inex = mpc_log (log, op, rnd); /* error <= 1 ulp */
if (!mpfr_number_p (mpc_imagref (log))
|| mpfr_zero_p (mpc_imagref (log))) {
/* no need to divide by log(10) */
special_im = 1;
ok = 1;
}
else {
special_im = 0;
mpfr_const_log10 (log10);
mpfr_div (mpc_imagref (log), mpc_imagref (log), log10, MPFR_RNDN);
ok = mpfr_can_round (mpc_imagref (log), prec - 2,
MPFR_RNDN, MPFR_RNDZ,
MPC_PREC_IM(rop) + (MPC_RND_IM (rnd) == MPFR_RNDN));
}
if (ok) {
if (!mpfr_number_p (mpc_realref (log))
|| mpfr_zero_p (mpc_realref (log)))
special_re = 1;
else {
special_re = 0;
if (special_im)
/* log10 not yet computed */
mpfr_const_log10 (log10);
mpfr_div (mpc_realref (log), mpc_realref (log), log10, MPFR_RNDN);
/* error <= 24/7 ulp < 4 ulp for prec >= 4, see algorithms.tex */
ok = mpfr_can_round (mpc_realref (log), prec - 2,
MPFR_RNDN, MPFR_RNDZ,
MPC_PREC_RE(rop) + (MPC_RND_RE (rnd) == MPFR_RNDN));
}
/* Special code to deal with cases where the real part of log10(x+i*y)
is exact, like x=3 and y=1. Since Re(log10(x+i*y)) = log10(x^2+y^2)/2
this happens whenever x^2+y^2 is a nonnegative power of 10.
Indeed x^2+y^2 cannot equal 10^(a/2^b) for a, b integers, a odd, b>0,
since x^2+y^2 is rational, and 10^(a/2^b) is irrational.
Similarly, for b=0, x^2+y^2 cannot equal 10^a for a < 0 since x^2+y^2
is a rational with denominator a power of 2.
Now let x^2+y^2 = 10^s. Without loss of generality we can assume
x = u/2^e and y = v/2^e with u, v, e integers: u^2+v^2 = 10^s*2^(2e)
thus u^2+v^2 = 0 mod 2^(2e). By recurrence on e, necessarily
u = v = 0 mod 2^e, thus x and y are necessarily integers.
*/
if (!ok && !check_exact && mpfr_integer_p (mpc_realref (op)) &&
mpfr_integer_p (mpc_imagref (op))) {
mpz_t x, y;
unsigned long s, v;
check_exact = 1;
mpz_init (x);
mpz_init (y);
mpfr_get_z (x, mpc_realref (op), MPFR_RNDN); /* exact */
mpfr_get_z (y, mpc_imagref (op), MPFR_RNDN); /* exact */
mpz_mul (x, x, x);
mpz_mul (y, y, y);
mpz_add (x, x, y); /* x^2+y^2 */
v = mpz_scan1 (x, 0);
/* if x = 10^s then necessarily s = v */
s = mpz_sizeinbase (x, 10);
/* since s is either the number of digits of x or one more,
then x = 10^(s-1) or 10^(s-2) */
if (s == v + 1 || s == v + 2) {
mpz_div_2exp (x, x, v);
mpz_ui_pow_ui (y, 5, v);
if (mpz_cmp (y, x) == 0) {
/* Re(log10(x+i*y)) is exactly v/2
we reset the precision of Re(log) so that v can be
represented exactly */
mpfr_set_prec (mpc_realref (log),
sizeof(unsigned long)*CHAR_BIT);
mpfr_set_ui_2exp (mpc_realref (log), v, -1, MPFR_RNDN);
/* exact */
ok = 1;
}
}
mpz_clear (x);
mpz_clear (y);
}
}
}
inex_re = mpfr_set (mpc_realref(rop), mpc_realref (log), MPC_RND_RE (rnd));
if (special_re)
inex_re = MPC_INEX_RE (inex);
/* recover flag from call to mpc_log above */
inex_im = mpfr_set (mpc_imagref(rop), mpc_imagref (log), MPC_RND_IM (rnd));
if (special_im)
inex_im = MPC_INEX_IM (inex);
mpfr_clear (log10);
mpc_clear (log);
return MPC_INEX(inex_re, inex_im);
}
int
mpc_sin_cos (mpc_ptr rop_sin, mpc_ptr rop_cos, mpc_srcptr op,
mpc_rnd_t rnd_sin, mpc_rnd_t rnd_cos)
/* Feature not documented in the texinfo file: One of rop_sin or
rop_cos may be NULL, in which case it is not computed, and the
corresponding ternary inexact value is set to 0 (exact). */
{
if (!mpc_fin_p (op))
return mpc_sin_cos_nonfinite (rop_sin, rop_cos, op, rnd_sin, rnd_cos);
else if (mpfr_zero_p (MPC_IM (op)))
return mpc_sin_cos_real (rop_sin, rop_cos, op, rnd_sin, rnd_cos);
else if (mpfr_zero_p (MPC_RE (op)))
return mpc_sin_cos_imag (rop_sin, rop_cos, op, rnd_sin, rnd_cos);
else {
/* let op = a + i*b, then sin(op) = sin(a)*cosh(b) + i*cos(a)*sinh(b)
and cos(op) = cos(a)*cosh(b) - i*sin(a)*sinh(b).
For Re(sin(op)) (and analogously, the other parts), we use the
following algorithm, with rounding to nearest for all operations
and working precision w:
(1) x = o(sin(a))
(2) y = o(cosh(b))
(3) r = o(x*y)
then the error on r is at most 4 ulps, since we can write
r = sin(a)*cosh(b)*(1+t)^3 with |t| <= 2^(-w),
thus for w >= 2, r = sin(a)*cosh(b)*(1+4*t) with |t| <= 2^(-w),
thus the relative error is bounded by 4*2^(-w) <= 4*ulp(r).
*/
mpfr_t s, c, sh, ch, sch, csh;
mpfr_prec_t prec;
int ok;
int inex_re, inex_im, inex_sin, inex_cos;
prec = 2;
if (rop_sin != NULL)
prec = MPC_MAX (prec, MPC_MAX_PREC (rop_sin));
if (rop_cos != NULL)
prec = MPC_MAX (prec, MPC_MAX_PREC (rop_cos));
mpfr_init2 (s, 2);
mpfr_init2 (c, 2);
mpfr_init2 (sh, 2);
mpfr_init2 (ch, 2);
mpfr_init2 (sch, 2);
mpfr_init2 (csh, 2);
do {
ok = 1;
prec += mpc_ceil_log2 (prec) + 5;
mpfr_set_prec (s, prec);
mpfr_set_prec (c, prec);
mpfr_set_prec (sh, prec);
mpfr_set_prec (ch, prec);
mpfr_set_prec (sch, prec);
mpfr_set_prec (csh, prec);
mpfr_sin_cos (s, c, MPC_RE(op), GMP_RNDN);
mpfr_sinh_cosh (sh, ch, MPC_IM(op), GMP_RNDN);
if (rop_sin != NULL) {
/* real part of sine */
mpfr_mul (sch, s, ch, GMP_RNDN);
ok = (!mpfr_number_p (sch))
|| mpfr_can_round (sch, prec - 2, GMP_RNDN, GMP_RNDZ,
MPC_PREC_RE (rop_sin)
+ (MPC_RND_RE (rnd_sin) == GMP_RNDN));
if (ok) {
/* imaginary part of sine */
mpfr_mul (csh, c, sh, GMP_RNDN);
ok = (!mpfr_number_p (csh))
|| mpfr_can_round (csh, prec - 2, GMP_RNDN, GMP_RNDZ,
MPC_PREC_IM (rop_sin)
+ (MPC_RND_IM (rnd_sin) == GMP_RNDN));
}
}
if (rop_cos != NULL && ok) {
/* real part of cosine */
mpfr_mul (c, c, ch, GMP_RNDN);
ok = (!mpfr_number_p (c))
|| mpfr_can_round (c, prec - 2, GMP_RNDN, GMP_RNDZ,
MPC_PREC_RE (rop_cos)
+ (MPC_RND_RE (rnd_cos) == GMP_RNDN));
if (ok) {
/* imaginary part of cosine */
mpfr_mul (s, s, sh, GMP_RNDN);
mpfr_neg (s, s, GMP_RNDN);
ok = (!mpfr_number_p (s))
|| mpfr_can_round (s, prec - 2, GMP_RNDN, GMP_RNDZ,
MPC_PREC_IM (rop_cos)
+ (MPC_RND_IM (rnd_cos) == GMP_RNDN));
}
}
} while (ok == 0);
if (rop_sin != NULL) {
inex_re = mpfr_set (MPC_RE (rop_sin), sch, MPC_RND_RE (rnd_sin));
if (mpfr_inf_p (sch))
inex_re = mpfr_sgn (sch);
inex_im = mpfr_set (MPC_IM (rop_sin), csh, MPC_RND_IM (rnd_sin));
if (mpfr_inf_p (csh))
inex_im = mpfr_sgn (csh);
inex_sin = MPC_INEX (inex_re, inex_im);
}
else
inex_sin = MPC_INEX (0,0); /* return exact if not computed */
if (rop_cos != NULL) {
inex_re = mpfr_set (MPC_RE (rop_cos), c, MPC_RND_RE (rnd_cos));
if (mpfr_inf_p (c))
inex_re = mpfr_sgn (c);
inex_im = mpfr_set (MPC_IM (rop_cos), s, MPC_RND_IM (rnd_cos));
if (mpfr_inf_p (s))
inex_im = mpfr_sgn (s);
inex_cos = MPC_INEX (inex_re, inex_im);
}
else
inex_cos = MPC_INEX (0,0); /* return exact if not computed */
mpfr_clear (s);
mpfr_clear (c);
mpfr_clear (sh);
mpfr_clear (ch);
mpfr_clear (sch);
mpfr_clear (csh);
return (MPC_INEX12 (inex_sin, inex_cos));
}
}
int
main (void)
{
mpfr_t x;
mpfr_init (x);
/* check +infinity gives non-zero for mpfr_inf_p only */
mpfr_set_ui (x, 1L, GMP_RNDZ);
mpfr_div_ui (x, x, 0L, GMP_RNDZ);
if (mpfr_nan_p (x)) {
fprintf (stderr, "Error: mpfr_nan_p(+Inf) gives non-zero\n");
exit (1);
}
if (mpfr_inf_p (x) == 0) {
fprintf (stderr, "Error: mpfr_inf_p(+Inf) gives zero\n");
exit (1);
}
if (mpfr_number_p (x)) {
fprintf (stderr, "Error: mpfr_number_p(+Inf) gives non-zero\n");
exit (1);
}
/* same for -Inf */
mpfr_neg (x, x, GMP_RNDN);
if (mpfr_nan_p (x)) {
fprintf (stderr, "Error: mpfr_nan_p(-Inf) gives non-zero\n");
exit (1);
}
if (mpfr_inf_p (x) == 0) {
fprintf (stderr, "Error: mpfr_inf_p(-Inf) gives zero\n");
exit (1);
}
if (mpfr_number_p (x)) {
fprintf (stderr, "Error: mpfr_number_p(-Inf) gives non-zero\n");
exit (1);
}
/* same for NaN */
mpfr_sub (x, x, x, GMP_RNDN);
if (mpfr_nan_p (x) == 0) {
fprintf (stderr, "Error: mpfr_nan_p(NaN) gives zero\n");
exit (1);
}
if (mpfr_inf_p (x)) {
fprintf (stderr, "Error: mpfr_inf_p(NaN) gives non-zero\n");
exit (1);
}
if (mpfr_number_p (x)) {
fprintf (stderr, "Error: mpfr_number_p(NaN) gives non-zero\n");
exit (1);
}
/* same for an ordinary number */
mpfr_set_ui (x, 1, GMP_RNDN);
if (mpfr_nan_p (x)) {
fprintf (stderr, "Error: mpfr_nan_p(1) gives non-zero\n");
exit (1);
}
if (mpfr_inf_p (x)) {
fprintf (stderr, "Error: mpfr_inf_p(1) gives non-zero\n");
exit (1);
}
if (mpfr_number_p (x) == 0) {
fprintf (stderr, "Error: mpfr_number_p(1) gives zero\n");
exit (1);
}
mpfr_clear (x);
return 0;
}
/* Put in z the value of x^y, rounded according to 'rnd'.
Return the inexact flag in [0, 10]. */
int
mpc_pow (mpc_ptr z, mpc_srcptr x, mpc_srcptr y, mpc_rnd_t rnd)
{
int ret = -2, loop, x_real, x_imag, y_real, z_real = 0, z_imag = 0;
mpc_t t, u;
mpfr_prec_t p, pr, pi, maxprec;
int saved_underflow, saved_overflow;
/* save the underflow or overflow flags from MPFR */
saved_underflow = mpfr_underflow_p ();
saved_overflow = mpfr_overflow_p ();
x_real = mpfr_zero_p (mpc_imagref(x));
y_real = mpfr_zero_p (mpc_imagref(y));
if (y_real && mpfr_zero_p (mpc_realref(y))) /* case y zero */
{
if (x_real && mpfr_zero_p (mpc_realref(x)))
{
/* we define 0^0 to be (1, +0) since the real part is
coherent with MPFR where 0^0 gives 1, and the sign of the
imaginary part cannot be determined */
mpc_set_ui_ui (z, 1, 0, MPC_RNDNN);
return 0;
}
else /* x^0 = 1 +/- i*0 even for x=NaN see algorithms.tex for the
sign of zero */
{
mpfr_t n;
int inex, cx1;
int sign_zi;
/* cx1 < 0 if |x| < 1
cx1 = 0 if |x| = 1
cx1 > 0 if |x| > 1
*/
mpfr_init (n);
inex = mpc_norm (n, x, MPFR_RNDN);
cx1 = mpfr_cmp_ui (n, 1);
if (cx1 == 0 && inex != 0)
cx1 = -inex;
sign_zi = (cx1 < 0 && mpfr_signbit (mpc_imagref (y)) == 0)
|| (cx1 == 0
&& mpfr_signbit (mpc_imagref (x)) != mpfr_signbit (mpc_realref (y)))
|| (cx1 > 0 && mpfr_signbit (mpc_imagref (y)));
/* warning: mpc_set_ui_ui does not set Im(z) to -0 if Im(rnd)=RNDD */
ret = mpc_set_ui_ui (z, 1, 0, rnd);
if (MPC_RND_IM (rnd) == MPFR_RNDD || sign_zi)
mpc_conj (z, z, MPC_RNDNN);
mpfr_clear (n);
return ret;
}
}
if (!mpc_fin_p (x) || !mpc_fin_p (y))
{
/* special values: exp(y*log(x)) */
mpc_init2 (u, 2);
mpc_log (u, x, MPC_RNDNN);
mpc_mul (u, u, y, MPC_RNDNN);
ret = mpc_exp (z, u, rnd);
mpc_clear (u);
goto end;
}
if (x_real) /* case x real */
{
if (mpfr_zero_p (mpc_realref(x))) /* x is zero */
{
/* special values: exp(y*log(x)) */
mpc_init2 (u, 2);
mpc_log (u, x, MPC_RNDNN);
mpc_mul (u, u, y, MPC_RNDNN);
ret = mpc_exp (z, u, rnd);
mpc_clear (u);
goto end;
}
/* Special case 1^y = 1 */
if (mpfr_cmp_ui (mpc_realref(x), 1) == 0)
{
int s1, s2;
s1 = mpfr_signbit (mpc_realref (y));
s2 = mpfr_signbit (mpc_imagref (x));
ret = mpc_set_ui (z, +1, rnd);
/* the sign of the zero imaginary part is known in some cases (see
algorithm.tex). In such cases we have
(x +s*0i)^(y+/-0i) = x^y + s*sign(y)*0i
where s = +/-1. We extend here this rule to fix the sign of the
zero part.
Note that the sign must also be set explicitly when rnd=RNDD
because mpfr_set_ui(z_i, 0, rnd) always sets z_i to +0.
*/
if (MPC_RND_IM (rnd) == MPFR_RNDD || s1 != s2)
mpc_conj (z, z, MPC_RNDNN);
goto end;
}
/* x^y is real when:
(a) x is real and y is integer
(b) x is real non-negative and y is real */
if (y_real && (mpfr_integer_p (mpc_realref(y)) ||
mpfr_cmp_ui (mpc_realref(x), 0) >= 0))
{
int s1, s2;
s1 = mpfr_signbit (mpc_realref (y));
s2 = mpfr_signbit (mpc_imagref (x));
ret = mpfr_pow (mpc_realref(z), mpc_realref(x), mpc_realref(y), MPC_RND_RE(rnd));
ret = MPC_INEX(ret, mpfr_set_ui (mpc_imagref(z), 0, MPC_RND_IM(rnd)));
/* the sign of the zero imaginary part is known in some cases
(see algorithm.tex). In such cases we have (x +s*0i)^(y+/-0i)
= x^y + s*sign(y)*0i where s = +/-1.
We extend here this rule to fix the sign of the zero part.
Note that the sign must also be set explicitly when rnd=RNDD
because mpfr_set_ui(z_i, 0, rnd) always sets z_i to +0.
*/
if (MPC_RND_IM(rnd) == MPFR_RNDD || s1 != s2)
mpfr_neg (mpc_imagref(z), mpc_imagref(z), MPC_RND_IM(rnd));
goto end;
}
/* (-1)^(n+I*t) is real for n integer and t real */
if (mpfr_cmp_si (mpc_realref(x), -1) == 0 && mpfr_integer_p (mpc_realref(y)))
z_real = 1;
/* for x real, x^y is imaginary when:
(a) x is negative and y is half-an-integer
(b) x = -1 and Re(y) is half-an-integer
*/
if ((mpfr_cmp_ui (mpc_realref(x), 0) < 0) && is_odd (mpc_realref(y), 1)
&& (y_real || mpfr_cmp_si (mpc_realref(x), -1) == 0))
z_imag = 1;
}
else /* x non real */
/* I^(t*I) and (-I)^(t*I) are real for t real,
I^(n+t*I) and (-I)^(n+t*I) are real for n even and t real, and
I^(n+t*I) and (-I)^(n+t*I) are imaginary for n odd and t real
(s*I)^n is real for n even and imaginary for n odd */
if ((mpc_cmp_si_si (x, 0, 1) == 0 || mpc_cmp_si_si (x, 0, -1) == 0 ||
(mpfr_cmp_ui (mpc_realref(x), 0) == 0 && y_real)) &&
mpfr_integer_p (mpc_realref(y)))
{ /* x is I or -I, and Re(y) is an integer */
if (is_odd (mpc_realref(y), 0))
z_imag = 1; /* Re(y) odd: z is imaginary */
else
z_real = 1; /* Re(y) even: z is real */
}
else /* (t+/-t*I)^(2n) is imaginary for n odd and real for n even */
if (mpfr_cmpabs (mpc_realref(x), mpc_imagref(x)) == 0 && y_real &&
mpfr_integer_p (mpc_realref(y)) && is_odd (mpc_realref(y), 0) == 0)
{
if (is_odd (mpc_realref(y), -1)) /* y/2 is odd */
z_imag = 1;
else
z_real = 1;
}
pr = mpfr_get_prec (mpc_realref(z));
pi = mpfr_get_prec (mpc_imagref(z));
p = (pr > pi) ? pr : pi;
p += 12; /* experimentally, seems to give less than 10% of failures in
Ziv's strategy; probably wrong now since q is not computed */
if (p < 64)
p = 64;
mpc_init2 (u, p);
mpc_init2 (t, p);
pr += MPC_RND_RE(rnd) == MPFR_RNDN;
pi += MPC_RND_IM(rnd) == MPFR_RNDN;
maxprec = MPC_MAX_PREC (z);
x_imag = mpfr_zero_p (mpc_realref(x));
for (loop = 0;; loop++)
{
int ret_exp;
mpfr_exp_t dr, di;
mpfr_prec_t q;
mpc_log (t, x, MPC_RNDNN);
mpc_mul (t, t, y, MPC_RNDNN);
/* Compute q such that |Re (y log x)|, |Im (y log x)| < 2^q.
We recompute it at each loop since we might get different
bounds if the precision is not enough. */
q = mpfr_get_exp (mpc_realref(t)) > 0 ? mpfr_get_exp (mpc_realref(t)) : 0;
if (mpfr_get_exp (mpc_imagref(t)) > (mpfr_exp_t) q)
q = mpfr_get_exp (mpc_imagref(t));
mpfr_clear_overflow ();
mpfr_clear_underflow ();
ret_exp = mpc_exp (u, t, MPC_RNDNN);
if (mpfr_underflow_p () || mpfr_overflow_p ()) {
/* under- and overflow flags are set by mpc_exp */
mpc_set (z, u, MPC_RNDNN);
ret = ret_exp;
goto exact;
}
/* Since the error bound is global, we have to take into account the
exponent difference between the real and imaginary parts. We assume
either the real or the imaginary part of u is not zero.
*/
dr = mpfr_zero_p (mpc_realref(u)) ? mpfr_get_exp (mpc_imagref(u))
: mpfr_get_exp (mpc_realref(u));
di = mpfr_zero_p (mpc_imagref(u)) ? dr : mpfr_get_exp (mpc_imagref(u));
if (dr > di)
{
di = dr - di;
dr = 0;
}
else
{
dr = di - dr;
di = 0;
}
/* the term -3 takes into account the factor 4 in the complex error
(see algorithms.tex) plus one due to the exponent difference: if
z = a + I*b, where the relative error on z is at most 2^(-p), and
EXP(a) = EXP(b) + k, the relative error on b is at most 2^(k-p) */
if ((z_imag || (p > q + 3 + dr && mpfr_can_round (mpc_realref(u), p - q - 3 - dr, MPFR_RNDN, MPFR_RNDZ, pr))) &&
(z_real || (p > q + 3 + di && mpfr_can_round (mpc_imagref(u), p - q - 3 - di, MPFR_RNDN, MPFR_RNDZ, pi))))
break;
/* if Re(u) is not known to be zero, assume it is a normal number, i.e.,
neither zero, Inf or NaN, otherwise we might enter an infinite loop */
MPC_ASSERT (z_imag || mpfr_number_p (mpc_realref(u)));
/* idem for Im(u) */
MPC_ASSERT (z_real || mpfr_number_p (mpc_imagref(u)));
if (ret == -2) /* we did not yet call mpc_pow_exact, or it aborted
because intermediate computations had > maxprec bits */
{
/* check exact cases (see algorithms.tex) */
if (y_real)
{
maxprec *= 2;
ret = mpc_pow_exact (z, x, mpc_realref(y), rnd, maxprec);
if (ret != -1 && ret != -2)
goto exact;
}
p += dr + di + 64;
}
else
p += p / 2;
mpc_set_prec (t, p);
mpc_set_prec (u, p);
}
if (z_real)
{
/* When the result is real (see algorithm.tex for details),
Im(x^y) =
+ sign(imag(y))*0i, if |x| > 1
+ sign(imag(x))*sign(real(y))*0i, if |x| = 1
- sign(imag(y))*0i, if |x| < 1
*/
mpfr_t n;
int inex, cx1;
int sign_zi, sign_rex, sign_imx;
/* cx1 < 0 if |x| < 1
cx1 = 0 if |x| = 1
cx1 > 0 if |x| > 1
*/
sign_rex = mpfr_signbit (mpc_realref (x));
sign_imx = mpfr_signbit (mpc_imagref (x));
mpfr_init (n);
inex = mpc_norm (n, x, MPFR_RNDN);
cx1 = mpfr_cmp_ui (n, 1);
if (cx1 == 0 && inex != 0)
cx1 = -inex;
sign_zi = (cx1 < 0 && mpfr_signbit (mpc_imagref (y)) == 0)
|| (cx1 == 0 && sign_imx != mpfr_signbit (mpc_realref (y)))
|| (cx1 > 0 && mpfr_signbit (mpc_imagref (y)));
/* copy RE(y) to n since if z==y we will destroy Re(y) below */
mpfr_set_prec (n, mpfr_get_prec (mpc_realref (y)));
mpfr_set (n, mpc_realref (y), MPFR_RNDN);
ret = mpfr_set (mpc_realref(z), mpc_realref(u), MPC_RND_RE(rnd));
if (y_real && (x_real || x_imag))
{
/* FIXME: with y_real we assume Im(y) is really 0, which is the case
for example when y comes from pow_fr, but in case Im(y) is +0 or
-0, we might get different results */
mpfr_set_ui (mpc_imagref (z), 0, MPC_RND_IM (rnd));
fix_sign (z, sign_rex, sign_imx, n);
ret = MPC_INEX(ret, 0); /* imaginary part is exact */
}
else
{
ret = MPC_INEX (ret, mpfr_set_ui (mpc_imagref (z), 0, MPC_RND_IM (rnd)));
/* warning: mpfr_set_ui does not set Im(z) to -0 if Im(rnd) = RNDD */
if (MPC_RND_IM (rnd) == MPFR_RNDD || sign_zi)
mpc_conj (z, z, MPC_RNDNN);
}
mpfr_clear (n);
}
else if (z_imag)
{
ret = mpfr_set (mpc_imagref(z), mpc_imagref(u), MPC_RND_IM(rnd));
/* if z is imaginary and y real, then x cannot be real */
if (y_real && x_imag)
{
int sign_rex = mpfr_signbit (mpc_realref (x));
/* If z overlaps with y we set Re(z) before checking Re(y) below,
but in that case y=0, which was dealt with above. */
mpfr_set_ui (mpc_realref (z), 0, MPC_RND_RE (rnd));
/* Note: fix_sign only does something when y is an integer,
then necessarily y = 1 or 3 (mod 4), and in that case the
sign of Im(x) is irrelevant. */
fix_sign (z, sign_rex, 0, mpc_realref (y));
ret = MPC_INEX(0, ret);
}
else
ret = MPC_INEX(mpfr_set_ui (mpc_realref(z), 0, MPC_RND_RE(rnd)), ret);
}
else
ret = mpc_set (z, u, rnd);
exact:
mpc_clear (t);
mpc_clear (u);
/* restore underflow and overflow flags from MPFR */
if (saved_underflow)
mpfr_set_underflow ();
if (saved_overflow)
mpfr_set_overflow ();
end:
return ret;
}
inline bool IsFinite( const BigFloat& alpha )
{ return mpfr_number_p( alpha.LockedPointer() ) != 0; }
int
mpc_tan (mpc_ptr rop, mpc_srcptr op, mpc_rnd_t rnd)
{
mpc_t x, y;
mpfr_prec_t prec;
mpfr_exp_t err;
int ok = 0;
int inex;
/* special values */
if (!mpc_fin_p (op))
{
if (mpfr_nan_p (mpc_realref (op)))
{
if (mpfr_inf_p (mpc_imagref (op)))
/* tan(NaN -i*Inf) = +/-0 -i */
/* tan(NaN +i*Inf) = +/-0 +i */
{
/* exact unless 1 is not in exponent range */
inex = mpc_set_si_si (rop, 0,
(MPFR_SIGN (mpc_imagref (op)) < 0) ? -1 : +1,
rnd);
}
else
/* tan(NaN +i*y) = NaN +i*NaN, when y is finite */
/* tan(NaN +i*NaN) = NaN +i*NaN */
{
mpfr_set_nan (mpc_realref (rop));
mpfr_set_nan (mpc_imagref (rop));
inex = MPC_INEX (0, 0); /* always exact */
}
}
else if (mpfr_nan_p (mpc_imagref (op)))
{
if (mpfr_cmp_ui (mpc_realref (op), 0) == 0)
/* tan(-0 +i*NaN) = -0 +i*NaN */
/* tan(+0 +i*NaN) = +0 +i*NaN */
{
mpc_set (rop, op, rnd);
inex = MPC_INEX (0, 0); /* always exact */
}
else
/* tan(x +i*NaN) = NaN +i*NaN, when x != 0 */
{
mpfr_set_nan (mpc_realref (rop));
mpfr_set_nan (mpc_imagref (rop));
inex = MPC_INEX (0, 0); /* always exact */
}
}
else if (mpfr_inf_p (mpc_realref (op)))
{
if (mpfr_inf_p (mpc_imagref (op)))
/* tan(-Inf -i*Inf) = -/+0 -i */
/* tan(-Inf +i*Inf) = -/+0 +i */
/* tan(+Inf -i*Inf) = +/-0 -i */
/* tan(+Inf +i*Inf) = +/-0 +i */
{
const int sign_re = mpfr_signbit (mpc_realref (op));
int inex_im;
mpfr_set_ui (mpc_realref (rop), 0, MPC_RND_RE (rnd));
mpfr_setsign (mpc_realref (rop), mpc_realref (rop), sign_re, MPFR_RNDN);
/* exact, unless 1 is not in exponent range */
inex_im = mpfr_set_si (mpc_imagref (rop),
mpfr_signbit (mpc_imagref (op)) ? -1 : +1,
MPC_RND_IM (rnd));
inex = MPC_INEX (0, inex_im);
}
else
/* tan(-Inf +i*y) = tan(+Inf +i*y) = NaN +i*NaN, when y is
finite */
{
mpfr_set_nan (mpc_realref (rop));
mpfr_set_nan (mpc_imagref (rop));
inex = MPC_INEX (0, 0); /* always exact */
}
}
else
/* tan(x -i*Inf) = +0*sin(x)*cos(x) -i, when x is finite */
/* tan(x +i*Inf) = +0*sin(x)*cos(x) +i, when x is finite */
{
mpfr_t c;
mpfr_t s;
int inex_im;
mpfr_init (c);
mpfr_init (s);
mpfr_sin_cos (s, c, mpc_realref (op), MPFR_RNDN);
mpfr_set_ui (mpc_realref (rop), 0, MPC_RND_RE (rnd));
mpfr_setsign (mpc_realref (rop), mpc_realref (rop),
mpfr_signbit (c) != mpfr_signbit (s), MPFR_RNDN);
/* exact, unless 1 is not in exponent range */
inex_im = mpfr_set_si (mpc_imagref (rop),
(mpfr_signbit (mpc_imagref (op)) ? -1 : +1),
MPC_RND_IM (rnd));
inex = MPC_INEX (0, inex_im);
mpfr_clear (s);
mpfr_clear (c);
}
return inex;
}
if (mpfr_zero_p (mpc_realref (op)))
/* tan(-0 -i*y) = -0 +i*tanh(y), when y is finite. */
/* tan(+0 +i*y) = +0 +i*tanh(y), when y is finite. */
{
int inex_im;
mpfr_set (mpc_realref (rop), mpc_realref (op), MPC_RND_RE (rnd));
inex_im = mpfr_tanh (mpc_imagref (rop), mpc_imagref (op), MPC_RND_IM (rnd));
return MPC_INEX (0, inex_im);
}
if (mpfr_zero_p (mpc_imagref (op)))
/* tan(x -i*0) = tan(x) -i*0, when x is finite. */
/* tan(x +i*0) = tan(x) +i*0, when x is finite. */
{
int inex_re;
inex_re = mpfr_tan (mpc_realref (rop), mpc_realref (op), MPC_RND_RE (rnd));
mpfr_set (mpc_imagref (rop), mpc_imagref (op), MPC_RND_IM (rnd));
return MPC_INEX (inex_re, 0);
}
/* ordinary (non-zero) numbers */
/* tan(op) = sin(op) / cos(op).
We use the following algorithm with rounding away from 0 for all
operations, and working precision w:
(1) x = A(sin(op))
(2) y = A(cos(op))
(3) z = A(x/y)
the error on Im(z) is at most 81 ulp,
the error on Re(z) is at most
7 ulp if k < 2,
8 ulp if k = 2,
else 5+k ulp, where
k = Exp(Re(x))+Exp(Re(y))-2min{Exp(Re(y)), Exp(Im(y))}-Exp(Re(x/y))
see proof in algorithms.tex.
*/
prec = MPC_MAX_PREC(rop);
mpc_init2 (x, 2);
mpc_init2 (y, 2);
err = 7;
do
{
mpfr_exp_t k, exr, eyr, eyi, ezr;
ok = 0;
/* FIXME: prevent addition overflow */
prec += mpc_ceil_log2 (prec) + err;
mpc_set_prec (x, prec);
mpc_set_prec (y, prec);
/* rounding away from zero: except in the cases x=0 or y=0 (processed
above), sin x and cos y are never exact, so rounding away from 0 is
rounding towards 0 and adding one ulp to the absolute value */
mpc_sin_cos (x, y, op, MPC_RNDZZ, MPC_RNDZZ);
MPFR_ADD_ONE_ULP (mpc_realref (x));
MPFR_ADD_ONE_ULP (mpc_imagref (x));
MPFR_ADD_ONE_ULP (mpc_realref (y));
MPFR_ADD_ONE_ULP (mpc_imagref (y));
MPC_ASSERT (mpfr_zero_p (mpc_realref (x)) == 0);
if ( mpfr_inf_p (mpc_realref (x)) || mpfr_inf_p (mpc_imagref (x))
|| mpfr_inf_p (mpc_realref (y)) || mpfr_inf_p (mpc_imagref (y))) {
/* If the real or imaginary part of x is infinite, it means that
Im(op) was large, in which case the result is
sign(tan(Re(op)))*0 + sign(Im(op))*I,
where sign(tan(Re(op))) = sign(Re(x))*sign(Re(y)). */
int inex_re, inex_im;
mpfr_set_ui (mpc_realref (rop), 0, MPFR_RNDN);
if (mpfr_sgn (mpc_realref (x)) * mpfr_sgn (mpc_realref (y)) < 0)
{
mpfr_neg (mpc_realref (rop), mpc_realref (rop), MPFR_RNDN);
inex_re = 1;
}
else
inex_re = -1; /* +0 is rounded down */
if (mpfr_sgn (mpc_imagref (op)) > 0)
{
mpfr_set_ui (mpc_imagref (rop), 1, MPFR_RNDN);
inex_im = 1;
}
else
{
mpfr_set_si (mpc_imagref (rop), -1, MPFR_RNDN);
inex_im = -1;
}
inex = MPC_INEX(inex_re, inex_im);
goto end;
}
exr = mpfr_get_exp (mpc_realref (x));
eyr = mpfr_get_exp (mpc_realref (y));
eyi = mpfr_get_exp (mpc_imagref (y));
/* some parts of the quotient may be exact */
inex = mpc_div (x, x, y, MPC_RNDZZ);
/* OP is no pure real nor pure imaginary, so in theory the real and
imaginary parts of its tangent cannot be null. However due to
rouding errors this might happen. Consider for example
tan(1+14*I) = 1.26e-10 + 1.00*I. For small precision sin(op) and
cos(op) differ only by a factor I, thus after mpc_div x = I and
its real part is zero. */
if (mpfr_zero_p (mpc_realref (x)) || mpfr_zero_p (mpc_imagref (x)))
{
err = prec; /* double precision */
continue;
}
if (MPC_INEX_RE (inex))
MPFR_ADD_ONE_ULP (mpc_realref (x));
if (MPC_INEX_IM (inex))
MPFR_ADD_ONE_ULP (mpc_imagref (x));
MPC_ASSERT (mpfr_zero_p (mpc_realref (x)) == 0);
ezr = mpfr_get_exp (mpc_realref (x));
/* FIXME: compute
k = Exp(Re(x))+Exp(Re(y))-2min{Exp(Re(y)), Exp(Im(y))}-Exp(Re(x/y))
avoiding overflow */
k = exr - ezr + MPC_MAX(-eyr, eyr - 2 * eyi);
err = k < 2 ? 7 : (k == 2 ? 8 : (5 + k));
/* Can the real part be rounded? */
ok = (!mpfr_number_p (mpc_realref (x)))
|| mpfr_can_round (mpc_realref(x), prec - err, MPFR_RNDN, MPFR_RNDZ,
MPC_PREC_RE(rop) + (MPC_RND_RE(rnd) == MPFR_RNDN));
if (ok)
{
/* Can the imaginary part be rounded? */
ok = (!mpfr_number_p (mpc_imagref (x)))
|| mpfr_can_round (mpc_imagref(x), prec - 6, MPFR_RNDN, MPFR_RNDZ,
MPC_PREC_IM(rop) + (MPC_RND_IM(rnd) == MPFR_RNDN));
}
}
while (ok == 0);
inex = mpc_set (rop, x, rnd);
end:
mpc_clear (x);
mpc_clear (y);
return inex;
}
bool
Floating_is_number (Floating* self)
{
return mpfr_number_p(*self->value);
}
static void
check_special (void)
{
mpfr_t a, d, q;
mpfr_exp_t emax, emin;
int i;
mpfr_init2 (a, 100L);
mpfr_init2 (d, 100L);
mpfr_init2 (q, 100L);
/* 1/nan == nan */
mpfr_set_ui (a, 1L, MPFR_RNDN);
MPFR_SET_NAN (d);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_NAN);
/* nan/1 == nan */
MPFR_SET_NAN (a);
mpfr_set_ui (d, 1L, MPFR_RNDN);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_NAN);
/* +inf/1 == +inf */
MPFR_SET_INF (a);
MPFR_SET_POS (a);
mpfr_set_ui (d, 1L, MPFR_RNDN);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q));
MPFR_ASSERTN (mpfr_sgn (q) > 0);
MPFR_ASSERTN (__gmpfr_flags == 0);
/* +inf/-1 == -inf */
MPFR_SET_INF (a);
MPFR_SET_POS (a);
mpfr_set_si (d, -1, MPFR_RNDN);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q));
MPFR_ASSERTN (mpfr_sgn (q) < 0);
MPFR_ASSERTN (__gmpfr_flags == 0);
/* -inf/1 == -inf */
MPFR_SET_INF (a);
MPFR_SET_NEG (a);
mpfr_set_ui (d, 1L, MPFR_RNDN);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q));
MPFR_ASSERTN (mpfr_sgn (q) < 0);
MPFR_ASSERTN (__gmpfr_flags == 0);
/* -inf/-1 == +inf */
MPFR_SET_INF (a);
MPFR_SET_NEG (a);
mpfr_set_si (d, -1, MPFR_RNDN);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q));
MPFR_ASSERTN (mpfr_sgn (q) > 0);
MPFR_ASSERTN (__gmpfr_flags == 0);
/* 1/+inf == +0 */
mpfr_set_ui (a, 1L, MPFR_RNDN);
MPFR_SET_INF (d);
MPFR_SET_POS (d);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_number_p (q));
MPFR_ASSERTN (mpfr_sgn (q) == 0);
MPFR_ASSERTN (MPFR_IS_POS (q));
MPFR_ASSERTN (__gmpfr_flags == 0);
/* 1/-inf == -0 */
mpfr_set_ui (a, 1L, MPFR_RNDN);
MPFR_SET_INF (d);
MPFR_SET_NEG (d);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_number_p (q));
MPFR_ASSERTN (mpfr_sgn (q) == 0);
MPFR_ASSERTN (MPFR_IS_NEG (q));
MPFR_ASSERTN (__gmpfr_flags == 0);
/* -1/+inf == -0 */
mpfr_set_si (a, -1, MPFR_RNDN);
MPFR_SET_INF (d);
MPFR_SET_POS (d);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_number_p (q));
MPFR_ASSERTN (mpfr_sgn (q) == 0);
MPFR_ASSERTN (MPFR_IS_NEG (q));
MPFR_ASSERTN (__gmpfr_flags == 0);
/* -1/-inf == +0 */
mpfr_set_si (a, -1, MPFR_RNDN);
MPFR_SET_INF (d);
MPFR_SET_NEG (d);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_number_p (q));
MPFR_ASSERTN (mpfr_sgn (q) == 0);
MPFR_ASSERTN (MPFR_IS_POS (q));
MPFR_ASSERTN (__gmpfr_flags == 0);
/* 0/0 == nan */
mpfr_set_ui (a, 0L, MPFR_RNDN);
mpfr_set_ui (d, 0L, MPFR_RNDN);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_NAN);
/* +inf/+inf == nan */
MPFR_SET_INF (a);
MPFR_SET_POS (a);
MPFR_SET_INF (d);
MPFR_SET_POS (d);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_NAN);
/* 1/+0 = +inf */
mpfr_set_ui (a, 1, MPFR_RNDZ);
mpfr_set_ui (d, 0, MPFR_RNDZ);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) > 0);
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_DIVBY0);
/* 1/-0 = -inf */
mpfr_set_ui (a, 1, MPFR_RNDZ);
mpfr_set_ui (d, 0, MPFR_RNDZ);
mpfr_neg (d, d, MPFR_RNDZ);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) < 0);
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_DIVBY0);
/* -1/+0 = -inf */
mpfr_set_si (a, -1, MPFR_RNDZ);
mpfr_set_ui (d, 0, MPFR_RNDZ);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) < 0);
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_DIVBY0);
/* -1/-0 = +inf */
mpfr_set_si (a, -1, MPFR_RNDZ);
mpfr_set_ui (d, 0, MPFR_RNDZ);
mpfr_neg (d, d, MPFR_RNDZ);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) > 0);
MPFR_ASSERTN (__gmpfr_flags == MPFR_FLAGS_DIVBY0);
/* +inf/+0 = +inf */
MPFR_SET_INF (a);
MPFR_SET_POS (a);
mpfr_set_ui (d, 0, MPFR_RNDZ);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) > 0);
MPFR_ASSERTN (__gmpfr_flags == 0);
/* +inf/-0 = -inf */
MPFR_SET_INF (a);
MPFR_SET_POS (a);
mpfr_set_ui (d, 0, MPFR_RNDZ);
mpfr_neg (d, d, MPFR_RNDZ);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) < 0);
MPFR_ASSERTN (__gmpfr_flags == 0);
/* -inf/+0 = -inf */
MPFR_SET_INF (a);
MPFR_SET_NEG (a);
mpfr_set_ui (d, 0, MPFR_RNDZ);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) < 0);
MPFR_ASSERTN (__gmpfr_flags == 0);
/* -inf/-0 = +inf */
MPFR_SET_INF (a);
MPFR_SET_NEG (a);
mpfr_set_ui (d, 0, MPFR_RNDZ);
mpfr_neg (d, d, MPFR_RNDZ);
mpfr_clear_flags ();
MPFR_ASSERTN (test_div (q, a, d, MPFR_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) > 0);
MPFR_ASSERTN (__gmpfr_flags == 0);
/* check overflow */
emax = mpfr_get_emax ();
set_emax (1);
mpfr_set_ui (a, 1, MPFR_RNDZ);
mpfr_set_ui (d, 1, MPFR_RNDZ);
mpfr_div_2exp (d, d, 1, MPFR_RNDZ);
mpfr_clear_flags ();
test_div (q, a, d, MPFR_RNDU); /* 1 / 0.5 = 2 -> overflow */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) > 0);
MPFR_ASSERTN (__gmpfr_flags == (MPFR_FLAGS_OVERFLOW | MPFR_FLAGS_INEXACT));
set_emax (emax);
/* check underflow */
emin = mpfr_get_emin ();
set_emin (-1);
mpfr_set_ui (a, 1, MPFR_RNDZ);
mpfr_div_2exp (a, a, 2, MPFR_RNDZ);
mpfr_set_prec (d, mpfr_get_prec (q) + 8);
for (i = -1; i <= 1; i++)
{
int sign;
/* Test 2^(-2) / (+/- (2 + eps)), with eps < 0, eps = 0, eps > 0.
-> underflow.
With div.c r5513, this test fails for eps > 0 in MPFR_RNDN. */
mpfr_set_ui (d, 2, MPFR_RNDZ);
if (i < 0)
mpfr_nextbelow (d);
if (i > 0)
mpfr_nextabove (d);
for (sign = 0; sign <= 1; sign++)
{
mpfr_clear_flags ();
test_div (q, a, d, MPFR_RNDZ); /* result = 0 */
MPFR_ASSERTN (__gmpfr_flags ==
(MPFR_FLAGS_UNDERFLOW | MPFR_FLAGS_INEXACT));
MPFR_ASSERTN (sign ? MPFR_IS_NEG (q) : MPFR_IS_POS (q));
MPFR_ASSERTN (MPFR_IS_ZERO (q));
mpfr_clear_flags ();
test_div (q, a, d, MPFR_RNDN); /* result = 0 iff eps >= 0 */
MPFR_ASSERTN (__gmpfr_flags ==
(MPFR_FLAGS_UNDERFLOW | MPFR_FLAGS_INEXACT));
MPFR_ASSERTN (sign ? MPFR_IS_NEG (q) : MPFR_IS_POS (q));
if (i < 0)
mpfr_nexttozero (q);
MPFR_ASSERTN (MPFR_IS_ZERO (q));
mpfr_neg (d, d, MPFR_RNDN);
}
}
set_emin (emin);
mpfr_clear (a);
mpfr_clear (d);
mpfr_clear (q);
}
static void
check_nan (void)
{
mpfr_t a, d, q;
mp_exp_t emax, emin;
mpfr_init2 (a, 100L);
mpfr_init2 (d, 100L);
mpfr_init2 (q, 100L);
/* 1/nan == nan */
mpfr_set_ui (a, 1L, GMP_RNDN);
MPFR_SET_NAN (d);
MPFR_ASSERTN (test_div (q, a, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_nan_p (q));
/* nan/1 == nan */
MPFR_SET_NAN (a);
mpfr_set_ui (d, 1L, GMP_RNDN);
MPFR_ASSERTN (test_div (q, a, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_nan_p (q));
/* +inf/1 == +inf */
MPFR_CLEAR_FLAGS (a);
MPFR_SET_INF (a);
MPFR_SET_POS (a);
mpfr_set_ui (d, 1L, GMP_RNDN);
MPFR_ASSERTN (test_div (q, a, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q));
MPFR_ASSERTN (mpfr_sgn (q) > 0);
/* 1/+inf == 0 */
mpfr_set_ui (a, 1L, GMP_RNDN);
MPFR_CLEAR_FLAGS (d);
MPFR_SET_INF (d);
MPFR_SET_POS (d);
MPFR_ASSERTN (test_div (q, a, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_number_p (q));
MPFR_ASSERTN (mpfr_sgn (q) == 0);
/* 0/0 == nan */
mpfr_set_ui (a, 0L, GMP_RNDN);
mpfr_set_ui (d, 0L, GMP_RNDN);
MPFR_ASSERTN (test_div (q, a, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_nan_p (q));
/* +inf/+inf == nan */
MPFR_CLEAR_FLAGS (a);
MPFR_SET_INF (a);
MPFR_SET_POS (a);
MPFR_CLEAR_FLAGS (d);
MPFR_SET_INF (d);
MPFR_SET_POS (d);
MPFR_ASSERTN (test_div (q, a, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_nan_p (q));
/* 1/+0 = +Inf */
mpfr_set_ui (a, 1, GMP_RNDZ);
mpfr_set_ui (d, 0, GMP_RNDZ);
MPFR_ASSERTN (test_div (q, a, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) > 0);
/* 1/-0 = -Inf */
mpfr_set_ui (a, 1, GMP_RNDZ);
mpfr_set_ui (d, 0, GMP_RNDZ);
mpfr_neg (d, d, GMP_RNDZ);
MPFR_ASSERTN (test_div (q, a, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) < 0);
/* -1/+0 = -Inf */
mpfr_set_si (a, -1, GMP_RNDZ);
mpfr_set_ui (d, 0, GMP_RNDZ);
MPFR_ASSERTN (test_div (q, a, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) < 0);
/* -1/-0 = +Inf */
mpfr_set_si (a, -1, GMP_RNDZ);
mpfr_set_ui (d, 0, GMP_RNDZ);
mpfr_neg (d, d, GMP_RNDZ);
MPFR_ASSERTN (test_div (q, a, d, GMP_RNDZ) == 0); /* exact */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) > 0);
/* check overflow */
emax = mpfr_get_emax ();
set_emax (1);
mpfr_set_ui (a, 1, GMP_RNDZ);
mpfr_set_ui (d, 1, GMP_RNDZ);
mpfr_div_2exp (d, d, 1, GMP_RNDZ);
test_div (q, a, d, GMP_RNDU); /* 1 / 0.5 = 2 -> overflow */
MPFR_ASSERTN (mpfr_inf_p (q) && mpfr_sgn (q) > 0);
set_emax (emax);
/* check underflow */
emin = mpfr_get_emin ();
set_emin (-1);
mpfr_set_ui (a, 1, GMP_RNDZ);
mpfr_div_2exp (a, a, 2, GMP_RNDZ);
mpfr_set_ui (d, 2, GMP_RNDZ);
test_div (q, a, d, GMP_RNDZ); /* 0.5*2^(-2) -> underflow */
MPFR_ASSERTN (mpfr_cmp_ui (q, 0) == 0 && MPFR_IS_POS (q));
test_div (q, a, d, GMP_RNDN); /* 0.5*2^(-2) -> underflow */
MPFR_ASSERTN (mpfr_cmp_ui (q, 0) == 0 && MPFR_IS_POS (q));
set_emin (emin);
mpfr_clear (a);
mpfr_clear (d);
mpfr_clear (q);
}
void externalPlot(char *library, mpfr_t a, mpfr_t b, mp_prec_t samplingPrecision, int random, node *func, int mode, mp_prec_t prec, char *name, int type) {
void *descr;
void (*myFunction)(mpfr_t, mpfr_t);
char *error;
mpfr_t x_h,x,y,temp,perturb,ulp,min_value;
double xd, yd;
FILE *file;
gmp_randstate_t state;
char *gplotname;
char *dataname;
char *outputname;
gmp_randinit_default (state);
if(samplingPrecision > prec) {
sollyaFprintf(stderr, "Error: you must use a sampling precision lower than the current precision\n");
return;
}
descr = dlopen(library, RTLD_NOW);
if (descr==NULL) {
sollyaFprintf(stderr, "Error: the given library (%s) is not available (%s)!\n",library,dlerror());
return;
}
dlerror(); /* Clear any existing error */
myFunction = (void (*)(mpfr_t, mpfr_t)) dlsym(descr, "f");
if ((error = dlerror()) != NULL) {
sollyaFprintf(stderr, "Error: the function f cannot be found in library %s (%s)\n",library,error);
return;
}
if(name==NULL) {
gplotname = (char *)safeCalloc(13 + strlen(PACKAGE_NAME), sizeof(char));
sprintf(gplotname,"/tmp/%s-%04d.p",PACKAGE_NAME,fileNumber);
dataname = (char *)safeCalloc(15 + strlen(PACKAGE_NAME), sizeof(char));
sprintf(dataname,"/tmp/%s-%04d.dat",PACKAGE_NAME,fileNumber);
outputname = (char *)safeCalloc(1, sizeof(char));
fileNumber++;
if (fileNumber >= NUMBEROFFILES) fileNumber=0;
}
else {
gplotname = (char *)safeCalloc(strlen(name)+3,sizeof(char));
sprintf(gplotname,"%s.p",name);
dataname = (char *)safeCalloc(strlen(name)+5,sizeof(char));
sprintf(dataname,"%s.dat",name);
outputname = (char *)safeCalloc(strlen(name)+5,sizeof(char));
if ((type==PLOTPOSTSCRIPT) || (type==PLOTPOSTSCRIPTFILE)) sprintf(outputname,"%s.eps",name);
}
/* Beginning of the interesting part of the code */
file = fopen(gplotname, "w");
if (file == NULL) {
sollyaFprintf(stderr,"Error: the file %s requested by plot could not be opened for writing: ",gplotname);
sollyaFprintf(stderr,"\"%s\".\n",strerror(errno));
return;
}
sollyaFprintf(file, "# Gnuplot script generated by %s\n",PACKAGE_NAME);
if ((type==PLOTPOSTSCRIPT) || (type==PLOTPOSTSCRIPTFILE)) sollyaFprintf(file,"set terminal postscript eps color\nset out \"%s\"\n",outputname);
sollyaFprintf(file, "set xrange [%1.50e:%1.50e]\n", mpfr_get_d(a, GMP_RNDD),mpfr_get_d(b, GMP_RNDU));
sollyaFprintf(file, "plot \"%s\" using 1:2 with dots t \"\"\n",dataname);
fclose(file);
file = fopen(dataname, "w");
if (file == NULL) {
sollyaFprintf(stderr,"Error: the file %s requested by plot could not be opened for writing: ",dataname);
sollyaFprintf(stderr,"\"%s\".\n",strerror(errno));
return;
}
mpfr_init2(x_h,samplingPrecision);
mpfr_init2(perturb, prec);
mpfr_init2(x,prec);
mpfr_init2(y,prec);
mpfr_init2(temp,prec);
mpfr_init2(ulp,prec);
mpfr_init2(min_value,53);
mpfr_sub(min_value, b, a, GMP_RNDN);
mpfr_div_2ui(min_value, min_value, 12, GMP_RNDN);
mpfr_set(x_h,a,GMP_RNDD);
while(mpfr_less_p(x_h,b)) {
mpfr_set(x, x_h, GMP_RNDN); // exact
if (mpfr_zero_p(x_h)) {
mpfr_set(x_h, min_value, GMP_RNDU);
}
else {
if (mpfr_cmpabs(x_h, min_value) < 0) mpfr_set_d(x_h, 0., GMP_RNDN);
else mpfr_nextabove(x_h);
}
if(random) {
mpfr_sub(ulp, x_h, x, GMP_RNDN);
mpfr_urandomb(perturb, state);
mpfr_mul(perturb, perturb, ulp, GMP_RNDN);
mpfr_add(x, x, perturb, GMP_RNDN);
}
(*myFunction)(temp,x);
evaluateFaithful(y, func, x,prec);
mpfr_sub(temp, temp, y, GMP_RNDN);
if(mode==RELATIVE) mpfr_div(temp, temp, y, GMP_RNDN);
xd = mpfr_get_d(x, GMP_RNDN);
if (xd >= MAX_VALUE_GNUPLOT) xd = MAX_VALUE_GNUPLOT;
if (xd <= -MAX_VALUE_GNUPLOT) xd = -MAX_VALUE_GNUPLOT;
sollyaFprintf(file, "%1.50e",xd);
if (!mpfr_number_p(temp)) {
if (verbosity >= 2) {
changeToWarningMode();
sollyaPrintf("Information: function undefined or not evaluable in point %s = ",variablename);
printValue(&x);
sollyaPrintf("\nThis point will not be plotted.\n");
restoreMode();
}
}
yd = mpfr_get_d(temp, GMP_RNDN);
if (yd >= MAX_VALUE_GNUPLOT) yd = MAX_VALUE_GNUPLOT;
if (yd <= -MAX_VALUE_GNUPLOT) yd = -MAX_VALUE_GNUPLOT;
sollyaFprintf(file, "\t%1.50e\n", yd);
}
fclose(file);
/* End of the interesting part.... */
dlclose(descr);
mpfr_clear(x);
mpfr_clear(y);
mpfr_clear(x_h);
mpfr_clear(temp);
mpfr_clear(perturb);
mpfr_clear(ulp);
mpfr_clear(min_value);
if ((name==NULL) || (type==PLOTFILE)) {
if (fork()==0) {
daemon(1,1);
execlp("gnuplot", "gnuplot", "-persist", gplotname, NULL);
perror("An error occurred when calling gnuplot ");
exit(1);
}
else wait(NULL);
}
else { /* Case we have an output: no daemon */
if (fork()==0) {
execlp("gnuplot", "gnuplot", "-persist", gplotname, NULL);
perror("An error occurred when calling gnuplot ");
exit(1);
}
else {
wait(NULL);
if((type==PLOTPOSTSCRIPT)) {
remove(gplotname);
remove(dataname);
}
}
}
free(gplotname);
free(dataname);
free(outputname);
return;
}
void
ovm_q_pow(oregister_t *l, oregister_t *r)
{
switch (r->t) {
case t_void:
if (!cfg_float_format) {
l->t = t_float;
l->v.d = 1.0;
}
else {
l->t = t_mpr;
mpfr_set_ui(orr(l), 1, thr_rnd);
}
break;
case t_word:
if (!cfg_float_format) {
l->t = t_float;
l->v.d = pow(mpq_get_d(oqr(l)), r->v.w);
}
else {
mpfr_set_si(orr(r), r->v.w, thr_rnd);
goto mpr;
}
break;
case t_float:
if (mpq_sgn(oqr(l)) < 0 &&
finite(r->v.d) && rint(r->v.d) != r->v.d) {
real(r->v.dd) = r->v.d;
imag(r->v.dd) = 0.0;
goto cdd;
}
l->t = t_float;
l->v.d = pow(mpq_get_d(oqr(l)), r->v.d);
break;
case t_mpz:
if (!cfg_float_format) {
l->t = t_float;
l->v.d = pow(mpq_get_d(oqr(l)), mpz_get_d(ozr(r)));
}
else {
mpfr_set_z(orr(r), ozr(r), thr_rnd);
goto mpr;
}
break;
case t_rat:
if (mpq_sgn(oqr(l)) < 0) {
if (!cfg_float_format) {
real(r->v.dd) = mpq_get_d(oqr(r));
imag(r->v.dd) = 0.0;
goto cdd;
}
mpc_set_q(occ(r), oqr(r), thr_rndc);
goto mpc;
}
else {
if (!cfg_float_format) {
l->t = t_float;
l->v.d = pow(mpq_get_d(oqr(l)), rat_get_d(r->v.r));
}
else {
mpq_set_si(oqr(r), rat_num(r->v.r), rat_den(r->v.r));
mpfr_set_q(orr(r), oqr(r), thr_rnd);
goto mpr;
}
}
break;
case t_mpq:
if (mpq_sgn(oqr(r)) < 0) {
if (!cfg_float_format) {
real(r->v.dd) = mpq_get_d(oqr(r));
imag(r->v.dd) = 0.0;
goto cdd;
}
mpc_set_q(occ(r), oqr(r), thr_rndc);
goto mpc;
}
else {
if (!cfg_float_format) {
l->t = t_float;
l->v.d = pow(mpq_get_d(oqr(l)), mpq_get_d(oqr(r)));
}
else {
mpfr_set_q(orr(r), oqr(r), thr_rnd);
goto mpr;
}
}
break;
case t_mpr:
if (mpq_sgn(oqr(l)) < 0 &&
mpfr_number_p(orr(r)) && !mpfr_integer_p(orr(r))) {
mpc_set_q(occ(r), oqr(r), thr_rndc);
goto mpc;
}
mpr:
l->t = t_mpr;
mpfr_set_q(orr(l), oqr(l), thr_rnd);
mpfr_pow(orr(l), orr(l), orr(r), thr_rnd);
break;
case t_cdd:
cdd:
l->t = t_cdd;
real(l->v.dd) = mpq_get_d(oqr(l));
imag(l->v.dd) = 0.0;
l->v.dd = cpow(l->v.dd, r->v.dd);
check_cdd(l);
break;
case t_cqq:
if (!cfg_float_format) {
real(r->v.dd) = mpq_get_d(oqr(r));
imag(r->v.dd) = mpq_get_d(oqi(r));
goto cdd;
}
mpc_set_q_q(occ(r), oqr(r), oqi(r), thr_rndc);
case t_mpc:
mpc:
l->t = t_mpc;
mpc_set_q(occ(l), oqr(l), thr_rndc);
mpc_pow(occ(l), occ(l), occ(r), thr_rndc);
check_mpc(l);
break;
default:
ovm_raise(except_not_a_number);
}
}
/* Convert R "mpfr" object (list of "mpfr1") to R "character" vector,
* using precision 'prec' which can be NA/NULL in which case
* "full precision" (as long as necessary) is used : */
SEXP mpfr2str(SEXP x, SEXP digits, SEXP base) {
int n = length(x), i;
int n_dig = isNull(digits) ? 0 : asInteger(digits);
int dig_n_max = -1;
SEXP val = PROTECT(allocVector(VECSXP, 4)),
nms, str, exp, fini, zero;
int *i_exp, *is_fin, *is_0;
int B = asInteger(base); // = base for output
double p_fact = (B == 2) ? 1. : log(B) / M_LN2;
char *ch = NULL;
mpfr_t R_i;
if(n_dig < 0)
error("'digits' must be NULL or integer >= 0");
/* be "overprotective" for now ... */
SET_VECTOR_ELT(val, 0, str = PROTECT(allocVector(STRSXP, n)));
SET_VECTOR_ELT(val, 1, exp = PROTECT(allocVector(INTSXP, n)));
SET_VECTOR_ELT(val, 2, fini= PROTECT(allocVector(LGLSXP, n)));
SET_VECTOR_ELT(val, 3, zero= PROTECT(allocVector(LGLSXP, n)));
nms = PROTECT(allocVector(STRSXP, 4));
SET_STRING_ELT(nms, 0, mkChar("str"));
SET_STRING_ELT(nms, 1, mkChar("exp"));
SET_STRING_ELT(nms, 2, mkChar("finite"));
SET_STRING_ELT(nms, 3, mkChar("is.0"));
setAttrib(val, R_NamesSymbol, nms);
i_exp = INTEGER(exp);
is_fin= LOGICAL(fini);
is_0 = LOGICAL(zero);
mpfr_init(R_i); /* with default precision */
for(i=0; i < n; i++) {
mpfr_exp_t exp = (mpfr_exp_t) 0;
mpfr_exp_t *exp_ptr = &exp;
int dig_needed;
R_asMPFR(VECTOR_ELT(x, i), R_i);
#ifdef __Rmpfr_FIRST_TRY_FAILS__
/* Observing memory problems, e.g., see ../tests/00-bug.R.~3~
* Originally hoped it was solvable via R_alloc() etc, but it seems the problem is
* deeper and I currently suspect a problem/bug in MPFR library's mpfr_get_str(..) */
ch = mpfr_get_str(NULL, exp_ptr, B,
(size_t) n_dig, R_i, MPFR_RNDN);
#else
if(n_dig) {/* use it as desired precision */
dig_needed = n_dig;
} else { /* n_dig = 0 --> string will use "enough" digits */
dig_needed = p_fact * (int)R_i->_mpfr_prec;
}
if (i == 0) { /* first time */
dig_n_max = dig_needed;
ch = (char *) R_alloc(dig_needed + 2, sizeof(char));
}
else if(!n_dig && dig_needed > dig_n_max) {
ch = (char *) S_realloc(ch, dig_needed + 2, dig_n_max + 2,
sizeof(char));
dig_n_max = dig_needed;
}
/* char * mpfr_get_str (char *STR, mpfr_exp_t *EXPPTR, int B,
* size_t N, mpfr_t OP, mpfr_rnd_t RND) */
mpfr_get_str(ch, exp_ptr, B,
(size_t) n_dig, R_i, MPFR_RNDN);
#endif
SET_STRING_ELT(str, i, mkChar(ch));
i_exp[i] = (int) exp_ptr[0];
is_fin[i]= mpfr_number_p(R_i);
is_0 [i] = mpfr_zero_p(R_i);
#ifdef __Rmpfr_FIRST_TRY_FAILS__
mpfr_free_str(ch);
#endif
}
mpfr_clear (R_i);
mpfr_free_cache();
UNPROTECT(6);
return val;
}
int
mpfr_regular_p (mpfr_srcptr z)
{
return (mpfr_number_p (z) && !mpfr_zero_p (z));
}
int
main (void)
{
mpfr_t x;
tests_start_mpfr ();
mpfr_init (x);
/* check +infinity gives non-zero for mpfr_inf_p only */
mpfr_set_ui (x, 1L, MPFR_RNDZ);
mpfr_div_ui (x, x, 0L, MPFR_RNDZ);
if (mpfr_nan_p (x) || (mpfr_nan_p) (x) )
{
printf ("Error: mpfr_nan_p(+Inf) gives non-zero\n");
exit (1);
}
if (mpfr_inf_p (x) == 0)
{
printf ("Error: mpfr_inf_p(+Inf) gives zero\n");
exit (1);
}
if (mpfr_number_p (x) || (mpfr_number_p) (x) )
{
printf ("Error: mpfr_number_p(+Inf) gives non-zero\n");
exit (1);
}
if (mpfr_zero_p (x) || (mpfr_zero_p) (x) )
{
printf ("Error: mpfr_zero_p(+Inf) gives non-zero\n");
exit (1);
}
if (mpfr_regular_p (x) || (mpfr_regular_p) (x) )
{
printf ("Error: mpfr_regular_p(+Inf) gives non-zero\n");
exit (1);
}
/* same for -Inf */
mpfr_neg (x, x, MPFR_RNDN);
if (mpfr_nan_p (x) || (mpfr_nan_p(x)))
{
printf ("Error: mpfr_nan_p(-Inf) gives non-zero\n");
exit (1);
}
if (mpfr_inf_p (x) == 0)
{
printf ("Error: mpfr_inf_p(-Inf) gives zero\n");
exit (1);
}
if (mpfr_number_p (x) || (mpfr_number_p)(x) )
{
printf ("Error: mpfr_number_p(-Inf) gives non-zero\n");
exit (1);
}
if (mpfr_zero_p (x) || (mpfr_zero_p)(x) )
{
printf ("Error: mpfr_zero_p(-Inf) gives non-zero\n");
exit (1);
}
if (mpfr_regular_p (x) || (mpfr_regular_p) (x) )
{
printf ("Error: mpfr_regular_p(-Inf) gives non-zero\n");
exit (1);
}
/* same for NaN */
mpfr_sub (x, x, x, MPFR_RNDN);
if (mpfr_nan_p (x) == 0)
{
printf ("Error: mpfr_nan_p(NaN) gives zero\n");
exit (1);
}
if (mpfr_inf_p (x) || (mpfr_inf_p)(x) )
{
printf ("Error: mpfr_inf_p(NaN) gives non-zero\n");
exit (1);
}
if (mpfr_number_p (x) || (mpfr_number_p) (x) )
{
printf ("Error: mpfr_number_p(NaN) gives non-zero\n");
exit (1);
}
if (mpfr_zero_p (x) || (mpfr_zero_p)(x) )
{
printf ("Error: mpfr_number_p(NaN) gives non-zero\n");
exit (1);
}
if (mpfr_regular_p (x) || (mpfr_regular_p) (x) )
{
printf ("Error: mpfr_regular_p(NaN) gives non-zero\n");
exit (1);
}
/* same for a regular number */
mpfr_set_ui (x, 1, MPFR_RNDN);
if (mpfr_nan_p (x) || (mpfr_nan_p)(x))
{
printf ("Error: mpfr_nan_p(1) gives non-zero\n");
exit (1);
}
if (mpfr_inf_p (x) || (mpfr_inf_p)(x) )
{
printf ("Error: mpfr_inf_p(1) gives non-zero\n");
exit (1);
}
if (mpfr_number_p (x) == 0)
{
printf ("Error: mpfr_number_p(1) gives zero\n");
exit (1);
}
if (mpfr_zero_p (x) || (mpfr_zero_p) (x) )
{
printf ("Error: mpfr_zero_p(1) gives non-zero\n");
exit (1);
}
if (mpfr_regular_p (x) == 0 || (mpfr_regular_p) (x) == 0)
{
printf ("Error: mpfr_regular_p(1) gives zero\n");
exit (1);
}
/* Same for +0 */
mpfr_set_ui (x, 0, MPFR_RNDN);
if (mpfr_nan_p (x) || (mpfr_nan_p)(x))
{
printf ("Error: mpfr_nan_p(+0) gives non-zero\n");
exit (1);
}
if (mpfr_inf_p (x) || (mpfr_inf_p)(x) )
{
printf ("Error: mpfr_inf_p(+0) gives non-zero\n");
exit (1);
}
if (mpfr_number_p (x) == 0)
{
printf ("Error: mpfr_number_p(+0) gives zero\n");
exit (1);
}
if (mpfr_zero_p (x) == 0 )
{
printf ("Error: mpfr_zero_p(+0) gives zero\n");
exit (1);
}
if (mpfr_regular_p (x) || (mpfr_regular_p) (x) )
{
printf ("Error: mpfr_regular_p(+0) gives non-zero\n");
exit (1);
}
/* Same for -0 */
mpfr_set_ui (x, 0, MPFR_RNDN);
mpfr_neg (x, x, MPFR_RNDN);
if (mpfr_nan_p (x) || (mpfr_nan_p)(x))
{
printf ("Error: mpfr_nan_p(-0) gives non-zero\n");
exit (1);
}
if (mpfr_inf_p (x) || (mpfr_inf_p)(x) )
{
printf ("Error: mpfr_inf_p(-0) gives non-zero\n");
exit (1);
}
if (mpfr_number_p (x) == 0)
{
printf ("Error: mpfr_number_p(-0) gives zero\n");
exit (1);
}
if (mpfr_zero_p (x) == 0 )
{
printf ("Error: mpfr_zero_p(-0) gives zero\n");
exit (1);
}
if (mpfr_regular_p (x) || (mpfr_regular_p) (x) )
{
printf ("Error: mpfr_regular_p(-0) gives non-zero\n");
exit (1);
}
mpfr_clear (x);
tests_end_mpfr ();
return 0;
}
int
mpc_sqrt (mpc_ptr a, mpc_srcptr b, mpc_rnd_t rnd)
{
int ok_w, ok_t = 0;
mpfr_t w, t;
mp_rnd_t rnd_w, rnd_t;
mp_prec_t prec_w, prec_t;
/* the rounding mode and the precision required for w and t, which can */
/* be either the real or the imaginary part of a */
mp_prec_t prec;
int inex_w, inex_t = 1, inex, loops = 0;
/* comparison of the real/imaginary part of b with 0 */
const int re_cmp = mpfr_cmp_ui (MPC_RE (b), 0);
const int im_cmp = mpfr_cmp_ui (MPC_IM (b), 0);
/* we need to know the sign of Im(b) when it is +/-0 */
const int im_sgn = mpfr_signbit (MPC_IM (b)) == 0? 0 : -1;
/* special values */
/* sqrt(x +i*Inf) = +Inf +I*Inf, even if x = NaN */
/* sqrt(x -i*Inf) = +Inf -I*Inf, even if x = NaN */
if (mpfr_inf_p (MPC_IM (b)))
{
mpfr_set_inf (MPC_RE (a), +1);
mpfr_set_inf (MPC_IM (a), im_sgn);
return MPC_INEX (0, 0);
}
if (mpfr_inf_p (MPC_RE (b)))
{
if (mpfr_signbit (MPC_RE (b)))
{
if (mpfr_number_p (MPC_IM (b)))
{
/* sqrt(-Inf +i*y) = +0 +i*Inf, when y positive */
/* sqrt(-Inf +i*y) = +0 -i*Inf, when y positive */
mpfr_set_ui (MPC_RE (a), 0, GMP_RNDN);
mpfr_set_inf (MPC_IM (a), im_sgn);
return MPC_INEX (0, 0);
}
else
{
/* sqrt(-Inf +i*NaN) = NaN +/-i*Inf */
mpfr_set_nan (MPC_RE (a));
mpfr_set_inf (MPC_IM (a), im_sgn);
return MPC_INEX (0, 0);
}
}
else
{
if (mpfr_number_p (MPC_IM (b)))
{
/* sqrt(+Inf +i*y) = +Inf +i*0, when y positive */
/* sqrt(+Inf +i*y) = +Inf -i*0, when y positive */
mpfr_set_inf (MPC_RE (a), +1);
mpfr_set_ui (MPC_IM (a), 0, GMP_RNDN);
if (im_sgn)
mpc_conj (a, a, MPC_RNDNN);
return MPC_INEX (0, 0);
}
else
{
/* sqrt(+Inf -i*Inf) = +Inf -i*Inf */
/* sqrt(+Inf +i*Inf) = +Inf +i*Inf */
/* sqrt(+Inf +i*NaN) = +Inf +i*NaN */
return mpc_set (a, b, rnd);
}
}
}
/* sqrt(x +i*NaN) = NaN +i*NaN, if x is not infinite */
/* sqrt(NaN +i*y) = NaN +i*NaN, if y is not infinite */
if (mpfr_nan_p (MPC_RE (b)) || mpfr_nan_p (MPC_IM (b)))
{
mpfr_set_nan (MPC_RE (a));
mpfr_set_nan (MPC_IM (a));
return MPC_INEX (0, 0);
}
/* purely real */
if (im_cmp == 0)
{
if (re_cmp == 0)
{
mpc_set_ui_ui (a, 0, 0, MPC_RNDNN);
if (im_sgn)
mpc_conj (a, a, MPC_RNDNN);
return MPC_INEX (0, 0);
}
else if (re_cmp > 0)
{
inex_w = mpfr_sqrt (MPC_RE (a), MPC_RE (b), MPC_RND_RE (rnd));
mpfr_set_ui (MPC_IM (a), 0, GMP_RNDN);
if (im_sgn)
mpc_conj (a, a, MPC_RNDNN);
return MPC_INEX (inex_w, 0);
}
else
{
mpfr_init2 (w, MPFR_PREC (MPC_RE (b)));
mpfr_neg (w, MPC_RE (b), GMP_RNDN);
if (im_sgn)
{
inex_w = -mpfr_sqrt (MPC_IM (a), w, INV_RND (MPC_RND_IM (rnd)));
mpfr_neg (MPC_IM (a), MPC_IM (a), GMP_RNDN);
}
else
inex_w = mpfr_sqrt (MPC_IM (a), w, MPC_RND_IM (rnd));
mpfr_set_ui (MPC_RE (a), 0, GMP_RNDN);
mpfr_clear (w);
return MPC_INEX (0, inex_w);
}
}
/* purely imaginary */
if (re_cmp == 0)
{
mpfr_t y;
y[0] = MPC_IM (b)[0];
/* If y/2 underflows, so does sqrt(y/2) */
mpfr_div_2ui (y, y, 1, GMP_RNDN);
if (im_cmp > 0)
{
inex_w = mpfr_sqrt (MPC_RE (a), y, MPC_RND_RE (rnd));
inex_t = mpfr_sqrt (MPC_IM (a), y, MPC_RND_IM (rnd));
}
else
{
mpfr_neg (y, y, GMP_RNDN);
inex_w = mpfr_sqrt (MPC_RE (a), y, MPC_RND_RE (rnd));
inex_t = -mpfr_sqrt (MPC_IM (a), y, INV_RND (MPC_RND_IM (rnd)));
mpfr_neg (MPC_IM (a), MPC_IM (a), GMP_RNDN);
}
return MPC_INEX (inex_w, inex_t);
}
prec = MPC_MAX_PREC(a);
mpfr_init (w);
mpfr_init (t);
if (re_cmp >= 0)
{
rnd_w = MPC_RND_RE (rnd);
prec_w = MPFR_PREC (MPC_RE (a));
rnd_t = MPC_RND_IM(rnd);
prec_t = MPFR_PREC (MPC_IM (a));
}
else
{
rnd_w = MPC_RND_IM(rnd);
prec_w = MPFR_PREC (MPC_IM (a));
rnd_t = MPC_RND_RE(rnd);
prec_t = MPFR_PREC (MPC_RE (a));
if (im_cmp < 0)
{
rnd_w = INV_RND(rnd_w);
rnd_t = INV_RND(rnd_t);
}
}
do
{
loops ++;
prec += (loops <= 2) ? mpc_ceil_log2 (prec) + 4 : prec / 2;
mpfr_set_prec (w, prec);
mpfr_set_prec (t, prec);
/* let b = x + iy */
/* w = sqrt ((|x| + sqrt (x^2 + y^2)) / 2), rounded down */
/* total error bounded by 3 ulps */
inex_w = mpc_abs (w, b, GMP_RNDD);
if (re_cmp < 0)
inex_w |= mpfr_sub (w, w, MPC_RE (b), GMP_RNDD);
else
inex_w |= mpfr_add (w, w, MPC_RE (b), GMP_RNDD);
inex_w |= mpfr_div_2ui (w, w, 1, GMP_RNDD);
inex_w |= mpfr_sqrt (w, w, GMP_RNDD);
ok_w = mpfr_can_round (w, (mp_exp_t) prec - 2, GMP_RNDD, GMP_RNDU,
prec_w + (rnd_w == GMP_RNDN));
if (!inex_w || ok_w)
{
/* t = y / 2w, rounded away */
/* total error bounded by 7 ulps */
const mp_rnd_t r = im_sgn ? GMP_RNDD : GMP_RNDU;
inex_t = mpfr_div (t, MPC_IM (b), w, r);
inex_t |= mpfr_div_2ui (t, t, 1, r);
ok_t = mpfr_can_round (t, (mp_exp_t) prec - 3, r, GMP_RNDZ,
prec_t + (rnd_t == GMP_RNDN));
/* As for w; since t was rounded away, we check whether rounding to 0
is possible. */
}
}
while ((inex_w && !ok_w) || (inex_t && !ok_t));
if (re_cmp > 0)
inex = MPC_INEX (mpfr_set (MPC_RE (a), w, MPC_RND_RE(rnd)),
mpfr_set (MPC_IM (a), t, MPC_RND_IM(rnd)));
else if (im_cmp > 0)
inex = MPC_INEX (mpfr_set (MPC_RE(a), t, MPC_RND_RE(rnd)),
mpfr_set (MPC_IM(a), w, MPC_RND_IM(rnd)));
else
inex = MPC_INEX (mpfr_neg (MPC_RE (a), t, MPC_RND_RE(rnd)),
mpfr_neg (MPC_IM (a), w, MPC_RND_IM(rnd)));
mpfr_clear (w);
mpfr_clear (t);
return inex;
}
int
main (int argc, char *argv[])
{
mpfr_t x, y;
unsigned long k, bd, nc, i;
char *str, *str2;
mp_exp_t e;
int base, logbase, prec, baseprec, ret;
tests_start_mpfr ();
if (argc >= 2) /* tset_str <string> [<prec>] [<base>] */
{
prec = (argc >= 3) ? atoi (argv[2]) : 53;
base = (argc >= 4) ? atoi (argv[3]) : 2;
mpfr_init2 (x, prec);
mpfr_set_str (x, argv[1], base, GMP_RNDN);
mpfr_out_str (stdout, 10, 0, x, GMP_RNDN);
puts ("");
mpfr_clear (x);
return 0;
}
mpfr_init2 (x, 2);
nc = (argc > 1) ? atoi(argv[1]) : 53;
if (nc < 100)
nc = 100;
bd = randlimb () & 8;
str2 = str = (char*) (*__gmp_allocate_func) (nc * sizeof(char));
if (bd)
{
for(k = 1; k <= bd; k++)
*(str2++) = (randlimb () & 1) + '0';
}
else
*(str2++) = '0';
*(str2++) = '.';
for (k = 1; k < nc - 17 - bd; k++)
*(str2++) = '0' + (char) (randlimb () & 1);
*(str2++) = 'e';
sprintf (str2, "%d", (int) (randlimb () & INT_MAX) + INT_MIN/2);
mpfr_set_prec (x, nc + 10);
mpfr_set_str_binary (x, str);
mpfr_set_prec (x, 54);
mpfr_set_str_binary (x, "0.100100100110110101001010010101111000001011100100101010E-529");
mpfr_init2 (y, 54);
mpfr_set_str (y, "4.936a52bc17254@-133", 16, GMP_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (1a):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
mpfr_set_str_binary (x, "0.111111101101110010111010100110000111011001010100001101E-529");
mpfr_set_str (y, "0.fedcba98765434P-529", 16, GMP_RNDN);
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (1b):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
(*__gmp_free_func) (str, nc * sizeof(char));
mpfr_set_prec (x, 53);
mpfr_set_str_binary (x, "+110101100.01010000101101000000100111001000101011101110E00");
mpfr_set_str_binary (x, "1.0");
if (mpfr_cmp_ui (x, 1))
{
printf ("Error in mpfr_set_str_binary for s=1.0\n");
mpfr_clear(x);
mpfr_clear(y);
exit(1);
}
mpfr_set_str_binary (x, "+0000");
mpfr_set_str_binary (x, "+0000E0");
mpfr_set_str_binary (x, "0000E0");
if (mpfr_cmp_ui (x, 0))
{
printf ("Error in mpfr_set_str_binary for s=0.0\n");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
mpfr_set_str (x, "+243495834958.53452345E1", 10, GMP_RNDN);
mpfr_set_str (x, "9007199254740993", 10, GMP_RNDN);
mpfr_set_str (x, "9007199254740992", 10, GMP_RNDU);
mpfr_set_str (x, "9007199254740992", 10, GMP_RNDD);
mpfr_set_str (x, "9007199254740992", 10, GMP_RNDZ);
/* check a random number printed and read is not modified */
prec = 53;
mpfr_set_prec (x, prec);
mpfr_set_prec (y, prec);
for (i=0;i<N;i++)
{
mpfr_random (x);
k = RND_RAND ();
logbase = (randlimb () % 5) + 1;
base = 1 << logbase;
/* Warning: the number of bits needed to print exactly a number of
'prec' bits in base 2^logbase may be greater than ceil(prec/logbase),
for example 0.11E-1 in base 2 cannot be written exactly with only
one digit in base 4 */
if (base == 2)
baseprec = prec;
else
baseprec = 1 + (prec - 2 + logbase) / logbase;
str = mpfr_get_str (NULL, &e, base, baseprec, x, (mp_rnd_t) k);
mpfr_set_str (y, str, base, (mp_rnd_t) k);
MPFR_EXP(y) += logbase * (e - strlen (str));
if (mpfr_cmp (x, y))
{
printf ("mpfr_set_str o mpfr_get_str <> id for rnd_mode=%s\n",
mpfr_print_rnd_mode ((mp_rnd_t) k));
printf ("x=");
mpfr_print_binary (x);
puts ("");
printf ("s=%s, exp=%d, base=%d\n", str, (int) e, base);
printf ("y=");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
(*__gmp_free_func) (str, strlen (str) + 1);
}
for (i = 2; i <= 36; i++)
{
if (mpfr_set_str (x, "@NaN@(garbage)", i, GMP_RNDN) != 0 ||
!mpfr_nan_p(x))
{
printf ("mpfr_set_str failed on @NaN@(garbage)\n");
exit (1);
}
/*
if (mpfr_set_str (x, "@Inf@garbage", i, GMP_RNDN) != 0 ||
!mpfr_inf_p(x) || MPFR_SIGN(x) < 0)
{
printf ("mpfr_set_str failed on @Inf@garbage\n");
exit (1);
}
if (mpfr_set_str (x, "-@Inf@garbage", i, GMP_RNDN) != 0 ||
!mpfr_inf_p(x) || MPFR_SIGN(x) > 0)
{
printf ("mpfr_set_str failed on -@Inf@garbage\n");
exit (1);
}
if (mpfr_set_str (x, "+@Inf@garbage", i, GMP_RNDN) != 0 ||
!mpfr_inf_p(x) || MPFR_SIGN(x) < 0)
{
printf ("mpfr_set_str failed on +@Inf@garbage\n");
exit (1);
}
*/
if (i > 16)
continue;
if (mpfr_set_str (x, "NaN", i, GMP_RNDN) != 0 ||
!mpfr_nan_p(x))
{
printf ("mpfr_set_str failed on NaN\n");
exit (1);
}
if (mpfr_set_str (x, "Inf", i, GMP_RNDN) != 0 ||
!mpfr_inf_p(x) || MPFR_SIGN(x) < 0)
{
printf ("mpfr_set_str failed on Inf\n");
exit (1);
}
if (mpfr_set_str (x, "-Inf", i, GMP_RNDN) != 0 ||
!mpfr_inf_p(x) || MPFR_SIGN(x) > 0)
{
printf ("mpfr_set_str failed on -Inf\n");
exit (1);
}
if (mpfr_set_str (x, "+Inf", i, GMP_RNDN) != 0 ||
!mpfr_inf_p(x) || MPFR_SIGN(x) < 0)
{
printf ("mpfr_set_str failed on +Inf\n");
exit (1);
}
}
/* check that mpfr_set_str works for uppercase letters too */
mpfr_set_prec (x, 10);
mpfr_set_str (x, "B", 16, GMP_RNDN);
if (mpfr_cmp_ui (x, 11) != 0)
{
printf ("mpfr_set_str does not work for uppercase letters\n");
exit (1);
}
/* start of tests added by Alain Delplanque */
/* in this example an overflow can occur */
mpfr_set_prec (x, 64);
mpfr_set_prec (y, 64);
mpfr_set_str_binary (x, "1.0E-532");
mpfr_set_str (y, "0.71128279983522479470@-160", 10, GMP_RNDU);
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (2):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
/* in this example, I think there was a pb in the old function :
result of mpfr_set_str_old for the same number , but with more
precision is: 1.111111111110000000000000000111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100111000100001100000010101100111010e184
this result is the same as mpfr_set_str */
mpfr_set_prec (x, 64);
mpfr_set_prec (y, 64);
mpfr_set_str_binary (x, "1.111111111110000000000000000111111111111111111111111110000000001E184");
mpfr_set_str (y, "0.jo08hg31hc5mmpj5mjjmgn55p2h35g@39", 27, GMP_RNDU);
/* y = 49027884868983130654865109690613178467841148597221480052 */
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (3):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
/* not exact rounding in mpfr_set_str
same number with more precision is : 1.111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011011111101000001101110110010101101000010100110011101110010001110e195
this result is the same as mpfr_set_str */
/* problem was : can_round was call with GMP_RNDN round mode,
so can_round use an error : 1/2 * 2^err * ulp(y)
instead of 2^err * ulp(y)
I have increase err by 1 */
mpfr_set_prec (x, 64); /* it was round down instead of up */
mpfr_set_prec (y, 64);
mpfr_set_str_binary (x, "1.111111111111111111111111111000000000000000000000000000000000001e195");
mpfr_set_str (y, "0.6e23ekb6acgh96abk10b6c9f2ka16i@45", 21, GMP_RNDU);
/* y = 100433627392042473064661483711179345482301462325708736552078 */
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (4):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
/* may be an error in mpfr_set_str_old
with more precision : 1.111111100000001111110000000000011111011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110111101010001110111011000010111001011100110110e180 */
mpfr_set_prec (x, 64); /* it was round down instead of up */
mpfr_set_prec (y, 64);
mpfr_set_str_binary (x, "1.111111100000001111110000000000011111011111111111111111111111111e180");
mpfr_set_str (y, "0.10j8j2k82ehahha56390df0a1de030@41", 23, GMP_RNDZ);
/* y = 3053110535624388280648330929253842828159081875986159414 */
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (5):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
mpfr_set_prec (x, 64);
mpfr_set_prec (y, 64);
mpfr_set_str (y, "0.jrchfhpp9en7hidqm9bmcofid9q3jg@39", 28, GMP_RNDU);
/* y = 196159429139499688661464718784226062699788036696626429952 */
mpfr_set_str_binary (x, "0.1111111111111111111111111111111000000000000011100000001111100001E187");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (6):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
mpfr_set_prec (x, 64);
mpfr_set_prec (y, 64);
mpfr_set_str (y, "0.h148m5ld5cf8gk1kd70b6ege92g6ba@47", 24, GMP_RNDZ);
/* y = 52652933527468502324759448399183654588831274530295083078827114496 */
mpfr_set_str_binary (x, "0.1111111111111100000000001000000000000000000011111111111111101111E215");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (7):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
/* worst cases for rounding to nearest in double precision */
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str (y, "5e125", 10, GMP_RNDN);
mpfr_set_str_binary (x, "0.10111101000101110110011000100000101001010000000111111E418");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (8):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
mpfr_set_str (y, "69e267", 10, GMP_RNDN);
mpfr_set_str_binary (x, "0.10000101101111100101101100000110010011001010011011010E894");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (9):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
mpfr_set_str (y, "623e100", 10, GMP_RNDN);
mpfr_set_str_binary (x, "0.10110010000001010011000101111001110101000001111011111E342");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (10):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
mpfr_set_str (y, "3571e263", 10, GMP_RNDN);
mpfr_set_str_binary (x, "0.10110001001100100010011000110000111010100000110101010E886");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (11):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
mpfr_set_str (y, "75569e-254", 10, GMP_RNDN);
mpfr_set_str_binary (x, "0.10101101001000110001011011001000111000110101010110011E-827");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (12):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
mpfr_set_str (y, "920657e-23", 10, GMP_RNDN);
mpfr_set_str_binary (x, "0.10101001110101001100110000101110110111101111001101100E-56");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (13):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
mpfr_set_str (y, "9210917e80", 10, GMP_RNDN);
mpfr_set_str_binary (x, "0.11101101000100011001000110100011111100110000000110010E289");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (14):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
mpfr_set_str (y, "87575437e-309", 10, GMP_RNDN);
mpfr_set_str_binary (x, "0.11110000001110011001000000110000000100000010101101100E-1000");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (15):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
mpfr_set_str (y, "245540327e122", 10, GMP_RNDN);
mpfr_set_str_binary (x, "0.10001101101100010001100011110000110001100010111001011E434");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (16):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
mpfr_set_str (y, "491080654e122", 10, GMP_RNDN);
mpfr_set_str_binary (x, "0.10001101101100010001100011110000110001100010111001011E435");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (17):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
mpfr_set_str (y, "83356057653e193", 10, GMP_RNDN);
mpfr_set_str_binary (x, "0.10101010001001110011011011010111011100010101000011000E678");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_str (18):\n");
mpfr_print_binary (x);
puts ("");
mpfr_print_binary (y);
puts ("");
mpfr_clear (x);
mpfr_clear (y);
exit (1);
}
CHECK53(y, "83356057653e193", GMP_RNDN, x,
"0.10101010001001110011011011010111011100010101000011000E678",
18);
CHECK53(y, "619534293513e124", GMP_RNDN, x,
"0.10001000011000010000000110000001111111110000011110001e452",
19);
CHECK53(y, "3142213164987e-294", GMP_RNDN, x,
"0.11101001101000000100111011111101111001010001001101111e-935",
20);
CHECK53(y, "36167929443327e-159", GMP_RNDN, x,
"0.11100111001110111110000101011001100110010100011111100e-483",
21);
CHECK53(y, "904198236083175e-161", GMP_RNDN, x,
"0.11100111001110111110000101011001100110010100011111100e-485",
22);
CHECK53(y, "3743626360493413e-165", GMP_RNDN, x,
"0.11000100000100011101001010111101011011011111011111001e-496",
23);
CHECK53(y, "94080055902682397e-242", GMP_RNDN, x,
"0.10110010010011000000111100011100111100110011011001010e-747",
24);
CHECK53(y, "7e-303", GMP_RNDD, x,
"0.10011001100111001000100110001110001000110111110001011e-1003",
25);
CHECK53(y, "7e-303", GMP_RNDU, x,
"0.10011001100111001000100110001110001000110111110001100e-1003",
26);
CHECK53(y, "93e-234", GMP_RNDD, x,
"0.10010011110110010111001001111001000010000000001110101E-770",
27);
CHECK53(y, "93e-234", GMP_RNDU, x,
"0.10010011110110010111001001111001000010000000001110110E-770",
28);
CHECK53(y, "755e174", GMP_RNDD, x,
"0.10111110110010011000110010011111101111000111111000101E588",
29);
CHECK53(y, "755e174", GMP_RNDU, x,
"0.10111110110010011000110010011111101111000111111000110E588",
30);
CHECK53(y, "8699e-276", GMP_RNDD, x,
"0.10010110100101101111100100100011011101100110100101100E-903",
31);
CHECK53(y, "8699e-276", GMP_RNDU, x,
"0.10010110100101101111100100100011011101100110100101101E-903",
32);
CHECK53(y, "82081e41", GMP_RNDD, x,
"0.10111000000010000010111011111001111010100011111001011E153",
33);
CHECK53(y, "82081e41", GMP_RNDU, x,
"0.10111000000010000010111011111001111010100011111001100E153",
34);
CHECK53(y, "584169e229", GMP_RNDD, x,
"0.11101011001010111000001011001110111000111100110101010E780",
35);
CHECK53(y, "584169e229", GMP_RNDU, x,
"0.11101011001010111000001011001110111000111100110101011E780",
36);
CHECK53(y, "5783893e-128", GMP_RNDD, x,
"0.10011000111100000110011110000101100111110011101110100E-402",
37);
CHECK53(y, "5783893e-128", GMP_RNDU, x,
"0.10011000111100000110011110000101100111110011101110101E-402",
38);
CHECK53(y, "87575437e-310", GMP_RNDD, x,
"0.11000000001011100000110011110011010000000010001010110E-1003",
39);
CHECK53(y, "87575437e-310", GMP_RNDU, x,
"0.11000000001011100000110011110011010000000010001010111E-1003",
40);
CHECK53(y, "245540327e121", GMP_RNDD, x,
"0.11100010101101001111010010110100011100000100101000100E430",
41);
CHECK53(y, "245540327e121", GMP_RNDU, x,
"0.11100010101101001111010010110100011100000100101000101E430",
42);
CHECK53(y, "9078555839e-109", GMP_RNDD, x,
"0.11111110001010111010110000110011100110001010011101101E-329",
43);
CHECK53(y, "9078555839e-109", GMP_RNDU, x,
"0.11111110001010111010110000110011100110001010011101110E-329",
44);
CHECK53(y, "42333842451e201", GMP_RNDD, x,
"0.10000000110001001101000100110110111110101011101011111E704",
45);
CHECK53(y, "42333842451e201", GMP_RNDU, x,
"0.10000000110001001101000100110110111110101011101100000E704",
46);
CHECK53(y, "778380362293e218", GMP_RNDD, x,
"0.11001101010111000001001100001100110010000001010010010E764",
47);
CHECK53(y, "778380362293e218", GMP_RNDU, x,
"0.11001101010111000001001100001100110010000001010010011E764",
48);
CHECK53(y, "7812878489261e-179", GMP_RNDD, x,
"0.10010011011011010111001111011101111101101101001110100E-551",
49);
CHECK53(y, "7812878489261e-179", GMP_RNDU, x,
"0.10010011011011010111001111011101111101101101001110101E-551",
50);
CHECK53(y, "77003665618895e-73", GMP_RNDD, x,
"0.11000101111110111111001111111101001101111000000101001E-196",
51);
CHECK53(y, "77003665618895e-73", GMP_RNDU, x,
"0.11000101111110111111001111111101001101111000000101010E-196",
52);
CHECK53(y, "834735494917063e-300", GMP_RNDD, x,
"0.11111110001101100001001101111100010011001110111010001E-947",
53);
CHECK53(y, "834735494917063e-300", GMP_RNDU, x,
"0.11111110001101100001001101111100010011001110111010010E-947",
54);
CHECK53(y, "6182410494241627e-119", GMP_RNDD, x,
"0.10001101110010110010001011000010001000101110100000111E-342",
55);
CHECK53(y, "6182410494241627e-119", GMP_RNDU, x,
"0.10001101110010110010001011000010001000101110100001000E-342",
56);
CHECK53(y, "26153245263757307e49", GMP_RNDD, x,
"0.10011110111100000000001011011110101100010000011011110E218",
57);
CHECK53(y, "26153245263757307e49", GMP_RNDU, x,
"0.10011110111100000000001011011110101100010000011011111E218",
58);
/* to check this problem : I convert limb (10--0 or 101--1) into base b
with more than mp_bits_per_limb digits,
so when convert into base 2 I should have
the limb that I have choose */
/* this use mpfr_get_str */
{
size_t nb_digit = mp_bits_per_limb;
mp_limb_t check_limb[2] = {MPFR_LIMB_HIGHBIT, ~(MPFR_LIMB_HIGHBIT >> 1)};
int base[3] = {10, 16, 19};
mp_rnd_t rnd[3] = {GMP_RNDU, GMP_RNDN, GMP_RNDD};
int cbase, climb, crnd;
char *str;
mpfr_set_prec (x, mp_bits_per_limb); /* x and y have only one limb */
mpfr_set_prec (y, mp_bits_per_limb);
str = (char*) (*__gmp_allocate_func) (N + 20);
mpfr_set_ui (x, 1, GMP_RNDN); /* ensures that x is not NaN or Inf */
for (; nb_digit < N; nb_digit *= 10)
for (cbase = 0; cbase < 3; cbase++)
for (climb = 0; climb < 2; climb++)
for (crnd = 0; crnd < 3; crnd++)
{
char *str1;
mp_exp_t exp;
*(MPFR_MANT(x)) = check_limb[climb];
MPFR_EXP(x) = 0;
mpfr_get_str (str + 2, &exp, base[cbase],
nb_digit, x, rnd[crnd]);
str[0] = '-';
str[(str[2] == '-')] = '0';
str[(str[2] == '-') + 1] = '.';
for (str1 = str; *str1 != 0; str1++)
;
sprintf (str1, "@%i", (int) exp);
mpfr_set_str (y, str, base[cbase], rnd[2 - crnd]);
if (mpfr_cmp (x, y) != 0)
{
printf ("Error in mpfr_set_str for nb_digit=%u, base=%d, "
"rnd=%s:\n", (unsigned int) nb_digit, base[cbase],
mpfr_print_rnd_mode (rnd[crnd]));
printf ("instead of: ");
mpfr_print_binary (x);
puts ("");
printf ("return : ");
mpfr_print_binary (y);
puts ("");
exit (1);
}
}
(*__gmp_free_func) (str, N + 20);
}
/* end of tests added by Alain Delplanque */
/* check that flags are correctly cleared */
mpfr_set_nan (x);
mpfr_set_str (x, "+0.0", 10, GMP_RNDN);
if (!mpfr_number_p(x) || mpfr_cmp_ui (x, 0) != 0 || mpfr_sgn (x) < 0)
{
printf ("x <- +0.0 failed after x=NaN\n");
exit (1);
}
mpfr_set_str (x, "-0.0", 10, GMP_RNDN);
if (!mpfr_number_p(x) || mpfr_cmp_ui (x, 0) != 0 || mpfr_sgn (x) > 0)
{
printf ("x <- -0.0 failed after x=NaN\n");
exit (1);
}
/* check invalid input */
ret = mpfr_set_str (x, "1E10toto", 10, GMP_RNDN);
MPFR_ASSERTN (ret == -1);
ret = mpfr_set_str (x, "1p10toto", 16, GMP_RNDN);
MPFR_ASSERTN (ret == -1);
ret = mpfr_set_str (x, "", 16, GMP_RNDN);
MPFR_ASSERTN (ret == -1);
ret = mpfr_set_str (x, "+", 16, GMP_RNDN);
MPFR_ASSERTN (ret == -1);
ret = mpfr_set_str (x, "-", 16, GMP_RNDN);
MPFR_ASSERTN (ret == -1);
ret = mpfr_set_str (x, "this_is_an_invalid_number_in_base_36", 36, GMP_RNDN);
MPFR_ASSERTN (ret == -1);
ret = mpfr_set_str (x, "1.2.3", 10, GMP_RNDN);
MPFR_ASSERTN (ret == -1);
mpfr_set_prec (x, 135);
ret = mpfr_set_str (x, "thisisavalidnumberinbase36", 36, GMP_RNDN);
mpfr_set_prec (y, 135);
mpfr_set_str (y, "23833565676460972739462619524519814462546", 10, GMP_RNDN);
MPFR_ASSERTN (mpfr_cmp (x, y) == 0 && ret == 0);
/* coverage test for set_str_binary */
mpfr_set_str_binary (x, "NaN");
MPFR_ASSERTN(mpfr_nan_p (x));
mpfr_set_str_binary (x, "Inf");
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) > 0);
mpfr_set_str_binary (x, "+Inf");
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) > 0);
mpfr_set_str_binary (x, "-Inf");
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) < 0);
mpfr_set_prec (x, 3);
mpfr_set_str_binary (x, "0.01E2");
MPFR_ASSERTN(mpfr_cmp_ui (x, 1) == 0);
mpfr_set_str_binary (x, "-0.01E2");
MPFR_ASSERTN(mpfr_cmp_si (x, -1) == 0);
mpfr_clear (x);
mpfr_clear (y);
check_underflow ();
tests_end_mpfr ();
return 0;
}
int
main (int argc, char *argv[])
{
mpfr_t x, y;
mpfr_exp_t emin, emax;
tests_start_mpfr ();
test_set_underflow ();
test_set_overflow ();
check_default_rnd();
mpfr_init (x);
mpfr_init (y);
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
if (emin >= emax)
{
printf ("Error: emin >= emax\n");
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_mul_2exp (x, x, 1024, MPFR_RNDN);
mpfr_set_double_range ();
mpfr_check_range (x, 0, MPFR_RNDN);
if (!mpfr_inf_p (x) || (mpfr_sgn(x) <= 0))
{
printf ("Error: 2^1024 rounded to nearest should give +Inf\n");
exit (1);
}
set_emax (1025);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_mul_2exp (x, x, 1024, MPFR_RNDN);
mpfr_set_double_range ();
mpfr_check_range (x, 0, MPFR_RNDD);
if (!mpfr_number_p (x))
{
printf ("Error: 2^1024 rounded down should give a normal number\n");
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_mul_2exp (x, x, 1023, MPFR_RNDN);
mpfr_add (x, x, x, MPFR_RNDN);
if (!mpfr_inf_p (x) || (mpfr_sgn(x) <= 0))
{
printf ("Error: x+x rounded to nearest for x=2^1023 should give +Inf\n");
printf ("emax = %ld\n", mpfr_get_emax ());
printf ("got ");
mpfr_print_binary (x);
puts ("");
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_mul_2exp (x, x, 1023, MPFR_RNDN);
mpfr_add (x, x, x, MPFR_RNDD);
if (!mpfr_number_p (x))
{
printf ("Error: x+x rounded down for x=2^1023 should give"
" a normal number\n");
exit (1);
}
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_div_2exp (x, x, 1022, MPFR_RNDN);
mpfr_set_str_binary (y, "1.1e-1022"); /* y = 3/2*x */
mpfr_sub (y, y, x, MPFR_RNDZ);
if (mpfr_cmp_ui (y, 0))
{
printf ("Error: y-x rounded to zero should give 0"
" for y=3/2*2^(-1022), x=2^(-1022)\n");
printf ("y=");
mpfr_print_binary (y);
puts ("");
exit (1);
}
set_emin (-1026);
mpfr_set_ui (x, 1, MPFR_RNDN);
mpfr_div_2exp (x, x, 1025, MPFR_RNDN);
mpfr_set_double_range ();
mpfr_check_range (x, 0, MPFR_RNDN);
if (!MPFR_IS_ZERO (x) )
{
printf ("Error: x rounded to nearest for x=2^-1024 should give Zero\n");
printf ("emin = %ld\n", mpfr_get_emin ());
printf ("got ");
mpfr_dump (x);
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
set_emin (emin);
set_emax (emax);
check_emin_emax();
check_flags();
check_set_get_prec ();
check_powerof2 ();
check_set ();
tests_end_mpfr ();
return 0;
}
