int
mag_close(const mag_t am, const mag_t bm)
{
arf_t t, a, b;
int res1, res2;
arf_init(t);
arf_init(a);
arf_init(b);
arf_set_mag(a, am);
arf_set_mag(b, bm);
arf_mul_ui(t, b, 257, MAG_BITS, ARF_RND_UP);
arf_mul_2exp_si(t, t, -8);
res1 = arf_cmp(a, t) <= 0;
arf_mul_ui(t, a, 257, MAG_BITS, ARF_RND_UP);
arf_mul_2exp_si(t, t, -8);
res2 = arf_cmp(b, t) <= 0;
arf_clear(t);
arf_clear(a);
arf_clear(b);
return res1 && res2;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("abs_bound_le_2exp_fmpz....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arf_t x, y;
fmpz_t b;
int cmp1, cmp2;
arf_init(x);
arf_init(y);
fmpz_init(b);
arf_randtest_not_zero(x, state, 2 + n_randint(state, 1000), 100);
arf_abs_bound_le_2exp_fmpz(b, x);
arf_one(y);
arf_mul_2exp_fmpz(y, y, b);
cmp1 = (arf_cmpabs(x, y) <= 0);
arf_mul_2exp_si(y, y, -1);
cmp2 = (arf_cmpabs(y, x) < 0);
arf_mul_2exp_si(y, y, 1);
if (!cmp1 || !cmp2)
{
flint_printf("FAIL\n\n");
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("y = "); arf_print(y); flint_printf("\n\n");
flint_printf("b = "); fmpz_print(b); flint_printf("\n\n");
flint_printf("cmp1 = %d, cmp2 = %d\n\n", cmp1, cmp2);
abort();
}
arf_clear(x);
arf_clear(y);
fmpz_clear(b);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int arb_calc_partition(arf_interval_t L, arf_interval_t R,
arb_calc_func_t func, void * param, const arf_interval_t block, slong prec)
{
arb_t t, m;
arf_t u;
int msign;
arb_init(t);
arb_init(m);
arf_init(u);
/* Compute the midpoint (TODO: try other points) */
arf_add(u, &block->a, &block->b, ARF_PREC_EXACT, ARF_RND_DOWN);
arf_mul_2exp_si(u, u, -1);
/* Evaluate and get sign at midpoint */
arb_set_arf(m, u);
func(t, m, param, 1, prec);
msign = _arb_sign(t);
/* L, R = block, split at midpoint */
arf_set(&L->a, &block->a);
arf_set(&R->b, &block->b);
arf_set(&L->b, u);
arf_set(&R->a, u);
arb_clear(t);
arb_clear(m);
arf_clear(u);
return msign;
}
int
_arf_add_eps(arf_t s, const arf_t x, int sgn, long prec, arf_rnd_t rnd)
{
arf_t t;
long bits;
bits = arf_bits(x);
if (bits == 0)
{
printf("_arf_add_eps\n");
abort();
}
bits = FLINT_MAX(bits, prec) + 10;
arf_init(t);
arf_set_si(t, sgn);
arf_mul_2exp_fmpz(t, t, ARF_EXPREF(x));
arf_mul_2exp_si(t, t, -bits);
arf_add(s, x, t, prec, rnd);
arf_clear(t);
return 1;
}
static __inline__ void
arb_nonnegative_part(arb_t z, const arb_t x, long prec)
{
if (arb_contains_negative(x))
{
arf_t t;
arf_init(t);
arf_set_mag(t, arb_radref(x));
arf_add(arb_midref(z), arb_midref(x), t, MAG_BITS, ARF_RND_CEIL);
if (arf_sgn(arb_midref(z)) <= 0)
{
mag_zero(arb_radref(z));
}
else
{
arf_mul_2exp_si(arb_midref(z), arb_midref(z), -1);
arf_get_mag(arb_radref(z), arb_midref(z));
/* XXX: needed since arf_get_mag is inexact */
arf_set_mag(arb_midref(z), arb_radref(z));
}
arf_clear(t);
}
else
{
arb_set(z, x);
}
}
void arf_twobytwo_diag(arf_t u1, arf_t u2, const arf_t a, const arf_t b, const arf_t d, slong prec) {
// Compute the orthogonal matrix that diagonalizes
//
// A = [a b]
// [b d]
//
// This matrix will have the form
//
// U = [cos x , -sin x]
// [sin x, cos x]
//
// where the diagonal matrix is U^t A U.
// We set u1 = cos x, u2 = -sin x.
if(arf_is_zero(b)) {
arf_set_ui(u1, 1);
arf_set_ui(u2, 0);
return;
}
arf_t x; arf_init(x);
arf_mul(u1, b, b, prec, ARF_RND_NEAR); // u1 = b^2
arf_sub(u2, a, d, prec, ARF_RND_NEAR); // u2 = a - d
arf_mul_2exp_si(u2, u2, -1); // u2 = (a - d)/2
arf_mul(u2, u2, u2, prec, ARF_RND_NEAR); // u2 = ( (a - d)/2 )^2
arf_add(u1, u1, u2, prec, ARF_RND_NEAR); // u1 = b^2 + ( (a-d)/2 )^2
arf_sqrt(u1, u1, prec, ARF_RND_NEAR); // u1 = sqrt(above)
arf_mul_2exp_si(u1, u1, 1); // u1 = 2 (sqrt (above) )
arf_add(u1, u1, d, prec, ARF_RND_NEAR); // u1 += d
arf_sub(u1, u1, a, prec, ARF_RND_NEAR); // u1 -= a
arf_mul_2exp_si(u1, u1, -1); // u1 = (d - a)/2 + sqrt(b^2 + ( (a-d)/2 )^2)
arf_mul(x, u1, u1, prec, ARF_RND_NEAR);
arf_addmul(x, b, b, prec, ARF_RND_NEAR); // x = u1^2 + b^2
arf_sqrt(x, x, prec, ARF_RND_NEAR); // x = sqrt(u1^2 + b^2)
arf_div(u2, u1, x, prec, ARF_RND_NEAR);
arf_div(u1, b, x, prec, ARF_RND_NEAR);
arf_neg(u1, u1);
arf_clear(x);
}
void
acb_lambertw_cleared_cut_fix_small(acb_t res, const acb_t z,
const acb_t ez1, const fmpz_t k, int flags, slong prec)
{
acb_t zz, zmid, zmide1;
arf_t eps;
acb_init(zz);
acb_init(zmid);
acb_init(zmide1);
arf_init(eps);
arf_mul_2exp_si(eps, arb_midref(acb_realref(z)), -prec);
acb_set(zz, z);
if (arf_sgn(arb_midref(acb_realref(zz))) < 0 &&
(!fmpz_is_zero(k) || arf_sgn(arb_midref(acb_realref(ez1))) < 0) &&
arf_cmpabs(arb_midref(acb_imagref(zz)), eps) < 0)
{
/* now the value must be in [0,2eps] */
arf_get_mag(arb_radref(acb_imagref(zz)), eps);
arf_set_mag(arb_midref(acb_imagref(zz)), arb_radref(acb_imagref(zz)));
if (arf_sgn(arb_midref(acb_imagref(z))) >= 0)
{
acb_lambertw_cleared_cut(res, zz, k, flags, prec);
}
else
{
fmpz_t kk;
fmpz_init(kk);
fmpz_neg(kk, k);
acb_lambertw_cleared_cut(res, zz, kk, flags, prec);
acb_conj(res, res);
fmpz_clear(kk);
}
}
else
{
acb_lambertw_cleared_cut(res, zz, k, flags, prec);
}
acb_clear(zz);
acb_clear(zmid);
acb_clear(zmide1);
arf_clear(eps);
}
void
arb_sqrtpos(arb_t z, const arb_t x, long prec)
{
if (!arb_is_finite(x))
{
if (mag_is_zero(arb_radref(x)) && arf_is_pos_inf(arb_midref(x)))
arb_pos_inf(z);
else
arb_zero_pm_inf(z);
}
else if (arb_contains_nonpositive(x))
{
arf_t t;
arf_init(t);
arf_set_mag(t, arb_radref(x));
arf_add(t, arb_midref(x), t, MAG_BITS, ARF_RND_CEIL);
if (arf_sgn(t) <= 0)
{
arb_zero(z);
}
else
{
arf_sqrt(t, t, MAG_BITS, ARF_RND_CEIL);
arf_mul_2exp_si(t, t, -1);
arf_set(arb_midref(z), t);
arf_get_mag(arb_radref(z), t);
}
arf_clear(t);
}
else
{
arb_sqrt(z, x, prec);
}
arb_nonnegative_part(z, z, prec);
}
int
_acb_poly_validate_real_roots(acb_srcptr roots, acb_srcptr poly, long len, long prec)
{
long i, deg, num_real;
arb_ptr real;
int result;
deg = len - 1;
num_real = 0;
result = 1;
if (deg <= 1)
return 1;
real = _arb_vec_init(deg);
/* pick out the candidate real roots */
for (i = 0; i < deg; i++)
{
if (arb_contains_zero(acb_imagref(roots + i)))
{
arb_set(real + num_real, acb_realref(roots + i));
num_real++;
}
}
/* number of real roots must be even if the polynomial is even,
and odd if the polynomial is odd (unless there are repeated roots...
in which case the input is invalid) */
if ((num_real % 2) != (deg % 2))
{
result = 0;
}
else if (num_real > 0)
{
int sign_neg_inf, sign_pos_inf, prev_sign;
acb_t t;
acb_init(t);
/* by assumption that the roots are real and isolated, the lead
coefficient really must be known to be either positive or negative */
sign_pos_inf = arb_is_positive(acb_realref(poly + deg)) ? 1 : -1;
sign_neg_inf = (deg % 2) ? -sign_pos_inf : sign_pos_inf;
/* now we check that there's a sign change between each root */
_arb_vec_sort_mid(real, num_real);
prev_sign = sign_neg_inf;
for (i = 0; i < num_real - 1; i++)
{
/* set t to the midpoint between the midpoints */
arb_zero(acb_imagref(t));
arf_add(arb_midref(acb_realref(t)),
arb_midref(real + i), arb_midref(real + i + 1), prec, ARF_RND_DOWN);
arf_mul_2exp_si(arb_midref(acb_realref(t)), arb_midref(acb_realref(t)), -1);
mag_zero(arb_radref(acb_realref(t)));
/* check that this point really is between both intervals (one interval
could be much wider than the other */
if (arb_lt(real + i, acb_realref(t)) && arb_lt(acb_realref(t), real + i + 1))
{
/* check sign change */
_acb_poly_evaluate(t, poly, len, t, prec);
if (prev_sign == 1)
result = arb_is_negative(acb_realref(t));
else
result = arb_is_positive(acb_realref(t));
if (!result)
break;
prev_sign = -prev_sign;
}
else
{
result = 0;
break;
}
}
acb_clear(t);
}
_arb_vec_clear(real, deg);
return result;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("is_int_2exp_si....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arf_t x, y;
fmpz_t t;
slong e;
int res1, res2;
arf_init(x);
arf_init(y);
fmpz_init(t);
arf_randtest_special(x, state, 2000, 100);
e = n_randtest(state);
arf_mul_2exp_si(y, x, e);
res1 = arf_is_int(x);
res2 = arf_is_int_2exp_si(y, e);
if (res1 != res2)
{
flint_printf("FAIL! (1)\n");
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("y = "); arf_print(y); flint_printf("\n\n");
flint_printf("res1 = %d, res2 = %d\n\n", res1, res2);
abort();
}
if (res1)
{
if (n_randint(state, 2))
arf_floor(y, x);
else
arf_ceil(y, x);
if (!arf_equal(x, y) || !arf_is_finite(x))
{
flint_printf("FAIL! (2)\n");
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("y = "); arf_print(y); flint_printf("\n\n");
flint_printf("res1 = %d\n\n", res1);
abort();
}
}
if (arf_is_finite(x) && !arf_is_zero(x))
{
arf_bot(t, x);
fmpz_neg(t, t);
arf_mul_2exp_fmpz(x, x, t);
res1 = arf_is_int(x);
arf_mul_2exp_si(y, x, -1);
res2 = arf_is_int(y);
if (!arf_is_int(x) || arf_is_int(y))
{
flint_printf("FAIL! (3)\n");
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("y = "); arf_print(y); flint_printf("\n\n");
flint_printf("res1 = %d, res2 = %d\n\n", res1, res2);
abort();
}
}
arf_clear(x);
arf_clear(y);
fmpz_clear(t);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("add_error....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b, c;
arf_t m, r;
arb_init(a);
arb_init(b);
arb_init(c);
arf_init(m);
arf_init(r);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(c, state, 1 + n_randint(state, 2000), 10);
arf_randtest_special(m, state, 1 + n_randint(state, 2000), 10);
arf_randtest_special(r, state, 1 + n_randint(state, 2000), 10);
/* c = a plus error bounds */
arb_set(c, a);
arf_set(arb_midref(b), m);
arf_get_mag(arb_radref(b), r);
arb_add_error(c, b);
/* b = a + random point */
arb_set(b, a);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), m, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), m, ARF_PREC_EXACT, ARF_RND_DOWN);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), r, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), r, ARF_PREC_EXACT, ARF_RND_DOWN);
/* should this be done differently? */
if (arf_is_nan(arb_midref(b)))
arf_zero(arb_midref(b));
if (!arb_contains(c, b))
{
printf("FAIL (arb_add_error)\n\n");
printf("a = "); arb_printn(a, 50, 0); printf("\n\n");
printf("b = "); arb_printn(b, 50, 0); printf("\n\n");
printf("c = "); arb_printn(c, 50, 0); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arf_clear(m);
arf_clear(r);
}
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b, c;
arf_t m;
arb_init(a);
arb_init(b);
arb_init(c);
arf_init(m);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(c, state, 1 + n_randint(state, 2000), 10);
arf_randtest_special(m, state, 1 + n_randint(state, 2000), 10);
/* c = a plus error bounds */
arb_set(c, a);
arb_add_error_arf(c, m);
/* b = a + random point */
arb_set(b, a);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), m, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), m, ARF_PREC_EXACT, ARF_RND_DOWN);
/* should this be done differently? */
if (arf_is_nan(arb_midref(b)))
arf_zero(arb_midref(b));
if (!arb_contains(c, b))
{
printf("FAIL (arb_add_error_arf)\n\n");
printf("a = "); arb_printn(a, 50, 0); printf("\n\n");
printf("b = "); arb_printn(b, 50, 0); printf("\n\n");
printf("c = "); arb_printn(c, 50, 0); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arf_clear(m);
}
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b, c;
arf_t t;
mag_t r;
arb_init(a);
arb_init(b);
arb_init(c);
mag_init(r);
arf_init(t);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 10);
mag_randtest(r, state, 10);
/* c = a plus error bounds */
arb_set(c, a);
arb_add_error_mag(c, r);
/* b = a + random point */
arb_set(b, a);
arf_set_mag(t, r);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
/* should this be done differently? */
if (arf_is_nan(arb_midref(b)))
arf_zero(arb_midref(b));
if (!arb_contains(c, b))
{
printf("FAIL (arb_add_error_mag)\n\n");
printf("a = "); arb_printn(a, 50, 0); printf("\n\n");
printf("b = "); arb_printn(b, 50, 0); printf("\n\n");
printf("c = "); arb_printn(c, 50, 0); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
mag_clear(r);
arf_clear(t);
}
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b, c;
arf_t t;
long e;
arb_init(a);
arb_init(b);
arb_init(c);
arf_init(t);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 10);
e = n_randint(state, 10) - 10;
/* c = a plus error bounds */
arb_set(c, a);
arb_add_error_2exp_si(c, e);
/* b = a + random point */
arb_set(b, a);
arf_one(t);
arf_mul_2exp_si(t, t, e);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
/* should this be done differently? */
if (arf_is_nan(arb_midref(b)))
arf_zero(arb_midref(b));
if (!arb_contains(c, b))
{
printf("FAIL (arb_add_error_2exp_si)\n\n");
printf("a = "); arb_printn(a, 50, 0); printf("\n\n");
printf("b = "); arb_printn(b, 50, 0); printf("\n\n");
printf("c = "); arb_printn(c, 50, 0); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arf_clear(t);
}
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b, c;
arf_t t;
fmpz_t e;
arb_init(a);
arb_init(b);
arb_init(c);
arf_init(t);
fmpz_init(e);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 10);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 10);
fmpz_randtest(e, state, 10);
/* c = a plus error bounds */
arb_set(c, a);
arb_add_error_2exp_fmpz(c, e);
/* b = a + random point */
arb_set(b, a);
arf_one(t);
arf_mul_2exp_fmpz(t, t, e);
if (n_randint(state, 2))
arf_add(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
else
arf_sub(arb_midref(b), arb_midref(b), t, ARF_PREC_EXACT, ARF_RND_DOWN);
/* should this be done differently? */
if (arf_is_nan(arb_midref(b)))
arf_zero(arb_midref(b));
if (!arb_contains(c, b))
{
printf("FAIL (arb_add_error_2exp_fmpz)\n\n");
printf("a = "); arb_printn(a, 50, 0); printf("\n\n");
printf("b = "); arb_printn(b, 50, 0); printf("\n\n");
printf("c = "); arb_printn(c, 50, 0); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arf_clear(t);
fmpz_clear(e);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("get_fmpz....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arf_t x, x2;
fmpz_t z, z2, e;
int ret1, ret2;
arf_init(x);
arf_init(x2);
fmpz_init(z);
fmpz_init(z2);
fmpz_init(e);
arf_randtest(x, state, 2 + n_randint(state, 1000), 10);
fmpz_randtest(z, state, 1 + n_randint(state, 1000));
fmpz_randtest(z2, state, 1 + n_randint(state, 1000));
fmpz_randtest(e, state, 1 + n_randint(state, 200));
arf_mul_2exp_fmpz(x2, x, e);
ret1 = arf_get_fmpz(z, x, ARF_RND_DOWN);
ret2 = arf_get_fmpz_fixed_fmpz(z2, x2, e);
if (!fmpz_equal(z, z2) || (ret1 != ret2))
{
flint_printf("FAIL (fixed_fmpz)\n\n");
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("x2 = "); arf_print(x2); flint_printf("\n\n");
flint_printf("z = "); fmpz_print(z); flint_printf("\n\n");
flint_printf("z2 = "); fmpz_print(z2); flint_printf("\n\n");
flint_printf("ret1 = %d, ret2 = %d\n\n", ret1, ret2);
flint_abort();
}
arf_clear(x);
arf_clear(x2);
fmpz_clear(z);
fmpz_clear(z2);
fmpz_clear(e);
}
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arf_t x, x2;
fmpz_t z, z2;
slong e;
int ret1, ret2;
arf_init(x);
arf_init(x2);
fmpz_init(z);
fmpz_init(z2);
arf_randtest(x, state, 2 + n_randint(state, 1000), 10);
fmpz_randtest(z, state, 1 + n_randint(state, 1000));
fmpz_randtest(z2, state, 1 + n_randint(state, 1000));
e = n_randtest(state);
arf_mul_2exp_si(x2, x, e);
ret1 = arf_get_fmpz(z, x, ARF_RND_DOWN);
ret2 = arf_get_fmpz_fixed_si(z2, x2, e);
if (!fmpz_equal(z, z2) || (ret1 != ret2))
{
flint_printf("FAIL (fixed_si)\n\n");
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("x2 = "); arf_print(x2); flint_printf("\n\n");
flint_printf("z = "); fmpz_print(z); flint_printf("\n\n");
flint_printf("z2 = "); fmpz_print(z2); flint_printf("\n\n");
flint_printf("ret1 = %d, ret2 = %d\n\n", ret1, ret2);
flint_abort();
}
arf_clear(x);
arf_clear(x2);
fmpz_clear(z);
fmpz_clear(z2);
}
for (iter = 0; iter < 1000000 * arb_test_multiplier(); iter++)
{
slong bits;
arf_t x;
mpfr_t y;
fmpz_t z, z2;
mpz_t w;
int ret1, ret2;
bits = 2 + n_randint(state, 1000);
arf_init(x);
mpfr_init2(y, bits);
fmpz_init(z);
fmpz_init(z2);
mpz_init(w);
arf_randtest(x, state, bits, 10);
fmpz_randtest(z, state, 1 + n_randint(state, 1000));
arf_get_mpfr(y, x, MPFR_RNDN);
switch (n_randint(state, 5))
{
case 0:
ret1 = arf_get_fmpz(z, x, ARF_RND_FLOOR);
ret2 = mpfr_get_z(w, y, MPFR_RNDD);
break;
case 1:
ret1 = arf_get_fmpz(z, x, ARF_RND_CEIL);
ret2 = mpfr_get_z(w, y, MPFR_RNDU);
break;
case 2:
ret1 = arf_get_fmpz(z, x, ARF_RND_DOWN);
ret2 = mpfr_get_z(w, y, MPFR_RNDZ);
break;
case 3:
ret1 = arf_get_fmpz(z, x, ARF_RND_UP);
ret2 = mpfr_get_z(w, y, MPFR_RNDA);
break;
default:
ret1 = arf_get_fmpz(z, x, ARF_RND_NEAR);
ret2 = mpfr_get_z(w, y, MPFR_RNDN);
break;
}
fmpz_set_mpz(z2, w);
if (!fmpz_equal(z, z2) || (ret1 != (ret2 != 0)))
{
flint_printf("FAIL\n\n");
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("z = "); fmpz_print(z); flint_printf("\n\n");
flint_printf("z2 = "); fmpz_print(z2); flint_printf("\n\n");
flint_printf("ret1 = %d, ret2 = %d\n\n", ret1, ret2);
flint_abort();
}
arf_clear(x);
mpfr_clear(y);
fmpz_clear(z);
fmpz_clear(z2);
mpz_clear(w);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
arb_log_arf(arb_t z, const arf_t x, slong prec)
{
if (arf_is_special(x))
{
if (arf_is_pos_inf(x))
arb_pos_inf(z);
else
arb_indeterminate(z);
}
else if (ARF_SGNBIT(x))
{
arb_indeterminate(z);
}
else if (ARF_IS_POW2(x))
{
if (fmpz_is_one(ARF_EXPREF(x)))
{
arb_zero(z);
}
else
{
fmpz_t exp;
fmpz_init(exp);
_fmpz_add_fast(exp, ARF_EXPREF(x), -1);
arb_const_log2(z, prec + 2);
arb_mul_fmpz(z, z, exp, prec);
fmpz_clear(exp);
}
}
else if (COEFF_IS_MPZ(*ARF_EXPREF(x)))
{
arb_log_arf_huge(z, x, prec);
}
else
{
slong exp, wp, wn, N, r, closeness_to_one;
mp_srcptr xp;
mp_size_t xn, tn;
mp_ptr tmp, w, t, u;
mp_limb_t p1, q1bits, p2, q2bits, error, error2, cy;
int negative, inexact, used_taylor_series;
TMP_INIT;
exp = ARF_EXP(x);
negative = 0;
ARF_GET_MPN_READONLY(xp, xn, x);
/* compute a c >= 0 such that |x-1| <= 2^(-c) if c > 0 */
closeness_to_one = 0;
if (exp == 0)
{
slong i;
closeness_to_one = FLINT_BITS - FLINT_BIT_COUNT(~xp[xn - 1]);
if (closeness_to_one == FLINT_BITS)
{
for (i = xn - 2; i > 0 && xp[i] == LIMB_ONES; i--)
closeness_to_one += FLINT_BITS;
closeness_to_one += (FLINT_BITS - FLINT_BIT_COUNT(~xp[i]));
}
}
else if (exp == 1)
{
closeness_to_one = FLINT_BITS - FLINT_BIT_COUNT(xp[xn - 1] & (~LIMB_TOP));
if (closeness_to_one == FLINT_BITS)
{
slong i;
for (i = xn - 2; xp[i] == 0; i--)
closeness_to_one += FLINT_BITS;
closeness_to_one += (FLINT_BITS - FLINT_BIT_COUNT(xp[i]));
}
closeness_to_one--;
}
/* if |t-1| <= 0.5 */
/* |log(1+t) - t| <= t^2 */
/* |log(1+t) - (t-t^2/2)| <= t^3 */
if (closeness_to_one > prec + 1)
{
inexact = arf_sub_ui(arb_midref(z), x, 1, prec, ARB_RND);
mag_set_ui_2exp_si(arb_radref(z), 1, -2 * closeness_to_one);
if (inexact)
arf_mag_add_ulp(arb_radref(z), arb_radref(z), arb_midref(z), prec);
return;
}
else if (2 * closeness_to_one > prec + 1)
{
arf_t t, u;
arf_init(t);
arf_init(u);
arf_sub_ui(t, x, 1, ARF_PREC_EXACT, ARF_RND_DOWN);
arf_mul(u, t, t, ARF_PREC_EXACT, ARF_RND_DOWN);
arf_mul_2exp_si(u, u, -1);
inexact = arf_sub(arb_midref(z), t, u, prec, ARB_RND);
mag_set_ui_2exp_si(arb_radref(z), 1, -3 * closeness_to_one);
if (inexact)
arf_mag_add_ulp(arb_radref(z), arb_radref(z), arb_midref(z), prec);
arf_clear(t);
arf_clear(u);
return;
}
/* Absolute working precision (NOT rounded to a limb multiple) */
wp = prec + closeness_to_one + 5;
/* Too high precision to use table */
if (wp > ARB_LOG_TAB2_PREC)
{
arf_log_via_mpfr(arb_midref(z), x, prec, ARB_RND);
arf_mag_set_ulp(arb_radref(z), arb_midref(z), prec);
return;
}
/* Working precision in limbs */
wn = (wp + FLINT_BITS - 1) / FLINT_BITS;
TMP_START;
tmp = TMP_ALLOC_LIMBS(4 * wn + 3);
w = tmp; /* requires wn+1 limbs */
t = w + wn + 1; /* requires wn+1 limbs */
u = t + wn + 1; /* requires 2wn+1 limbs */
/* read x-1 */
if (xn <= wn)
{
flint_mpn_zero(w, wn - xn);
mpn_lshift(w + wn - xn, xp, xn, 1);
error = 0;
}
else
{
mpn_lshift(w, xp + xn - wn, wn, 1);
error = 1;
}
/* First table-based argument reduction */
if (wp <= ARB_LOG_TAB1_PREC)
q1bits = ARB_LOG_TAB11_BITS;
else
q1bits = ARB_LOG_TAB21_BITS;
p1 = w[wn-1] >> (FLINT_BITS - q1bits);
/* Special case: covers logarithms of small integers */
if (xn == 1 && (w[wn-1] == (p1 << (FLINT_BITS - q1bits))))
{
p2 = 0;
flint_mpn_zero(t, wn);
used_taylor_series = 0;
N = r = 0; /* silence compiler warning */
}
else
{
/* log(1+w) = log(1+p/q) + log(1 + (qw-p)/(p+q)) */
w[wn] = mpn_mul_1(w, w, wn, UWORD(1) << q1bits) - p1;
mpn_divrem_1(w, 0, w, wn + 1, p1 + (UWORD(1) << q1bits));
error += 1;
/* Second table-based argument reduction (fused with log->atanh
conversion) */
if (wp <= ARB_LOG_TAB1_PREC)
q2bits = ARB_LOG_TAB11_BITS + ARB_LOG_TAB12_BITS;
else
q2bits = ARB_LOG_TAB21_BITS + ARB_LOG_TAB22_BITS;
p2 = w[wn-1] >> (FLINT_BITS - q2bits);
u[2 * wn] = mpn_lshift(u + wn, w, wn, q2bits);
flint_mpn_zero(u, wn);
flint_mpn_copyi(t, u + wn, wn + 1);
t[wn] += p2 + (UWORD(1) << (q2bits + 1));
u[2 * wn] -= p2;
mpn_tdiv_q(w, u, 2 * wn + 1, t, wn + 1);
/* propagated error from 1 ulp error: 2 atanh'(1/3) = 2.25 */
error += 3;
/* |w| <= 2^-r */
r = _arb_mpn_leading_zeros(w, wn);
/* N >= (wp-r)/(2r) */
N = (wp - r + (2*r-1)) / (2*r);
N = FLINT_MAX(N, 0);
/* Evaluate Taylor series */
_arb_atan_taylor_rs(t, &error2, w, wn, N, 0);
/* Multiply by 2 */
mpn_lshift(t, t, wn, 1);
/* Taylor series evaluation error (multiply by 2) */
error += error2 * 2;
used_taylor_series = 1;
}
/* Size of output number */
tn = wn;
/* First table lookup */
if (p1 != 0)
{
if (wp <= ARB_LOG_TAB1_PREC)
mpn_add_n(t, t, arb_log_tab11[p1] + ARB_LOG_TAB1_LIMBS - tn, tn);
else
mpn_add_n(t, t, arb_log_tab21[p1] + ARB_LOG_TAB2_LIMBS - tn, tn);
error++;
}
/* Second table lookup */
if (p2 != 0)
{
if (wp <= ARB_LOG_TAB1_PREC)
mpn_add_n(t, t, arb_log_tab12[p2] + ARB_LOG_TAB1_LIMBS - tn, tn);
else
mpn_add_n(t, t, arb_log_tab22[p2] + ARB_LOG_TAB2_LIMBS - tn, tn);
error++;
}
/* add exp * log(2) */
exp--;
if (exp > 0)
{
cy = mpn_addmul_1(t, arb_log_log2_tab + ARB_LOG_TAB2_LIMBS - tn, tn, exp);
t[tn] = cy;
tn += (cy != 0);
error += exp;
}
else if (exp < 0)
{
t[tn] = 0;
u[tn] = mpn_mul_1(u, arb_log_log2_tab + ARB_LOG_TAB2_LIMBS - tn, tn, -exp);
if (mpn_cmp(t, u, tn + 1) >= 0)
{
mpn_sub_n(t, t, u, tn + 1);
}
else
{
mpn_sub_n(t, u, t, tn + 1);
negative = 1;
}
error += (-exp);
tn += (t[tn] != 0);
}
/* The accumulated arithmetic error */
mag_set_ui_2exp_si(arb_radref(z), error, -wn * FLINT_BITS);
/* Truncation error from the Taylor series */
if (used_taylor_series)
mag_add_ui_2exp_si(arb_radref(z), arb_radref(z), 1, -r*(2*N+1) + 1);
/* Set the midpoint */
inexact = _arf_set_mpn_fixed(arb_midref(z), t, tn, wn, negative, prec);
if (inexact)
arf_mag_add_ulp(arb_radref(z), arb_radref(z), arb_midref(z), prec);
TMP_END;
}
}
void
arb_exp_arf_bb(arb_t z, const arf_t x, slong prec, int minus_one)
{
slong k, iter, bits, r, mag, q, wp, N;
slong argred_bits, start_bits;
mp_bitcnt_t Qexp[1];
int inexact;
fmpz_t t, u, T, Q;
arb_t w;
if (arf_is_zero(x))
{
if (minus_one)
arb_zero(z);
else
arb_one(z);
return;
}
if (arf_is_special(x))
{
abort();
}
mag = arf_abs_bound_lt_2exp_si(x);
/* We assume that this function only gets called with something
reasonable as input (huge/tiny input will be handled by
the main exp wrapper). */
if (mag > 200 || mag < -2 * prec - 100)
{
flint_printf("arb_exp_arf_bb: unexpectedly large/small input\n");
abort();
}
if (prec < 100000000)
{
argred_bits = 16;
start_bits = 32;
}
else
{
argred_bits = 32;
start_bits = 64;
}
/* Argument reduction: exp(x) -> exp(x/2^q). This improves efficiency
of the first iteration in the bit-burst algorithm. */
q = FLINT_MAX(0, mag + argred_bits);
/* Determine working precision. */
wp = prec + 10 + 2 * q + 2 * FLINT_BIT_COUNT(prec);
if (minus_one && mag < 0)
wp += (-mag);
fmpz_init(t);
fmpz_init(u);
fmpz_init(Q);
fmpz_init(T);
arb_init(w);
/* Convert x/2^q to a fixed-point number. */
inexact = arf_get_fmpz_fixed_si(t, x, -wp + q);
/* Aliasing of z and x is safe now that only use t. */
/* Start with z = 1. */
arb_one(z);
/* Bit-burst loop. */
for (iter = 0, bits = start_bits; !fmpz_is_zero(t);
iter++, bits *= 2)
{
/* Extract bits. */
r = FLINT_MIN(bits, wp);
fmpz_tdiv_q_2exp(u, t, wp - r);
/* Binary splitting (+1 fixed-point ulp truncation error). */
mag = fmpz_bits(u) - r;
N = bs_num_terms(mag, wp);
_arb_exp_sum_bs_powtab(T, Q, Qexp, u, r, N);
/* T = T / Q (+1 fixed-point ulp error). */
if (*Qexp >= wp)
{
fmpz_tdiv_q_2exp(T, T, *Qexp - wp);
fmpz_tdiv_q(T, T, Q);
}
else
{
fmpz_mul_2exp(T, T, wp - *Qexp);
fmpz_tdiv_q(T, T, Q);
}
/* T = 1 + T */
fmpz_one(Q);
fmpz_mul_2exp(Q, Q, wp);
fmpz_add(T, T, Q);
/* Now T = exp(u) with at most 2 fixed-point ulp error. */
/* Set z = z * T. */
arf_set_fmpz(arb_midref(w), T);
arf_mul_2exp_si(arb_midref(w), arb_midref(w), -wp);
mag_set_ui_2exp_si(arb_radref(w), 2, -wp);
arb_mul(z, z, w, wp);
/* Remove used bits. */
fmpz_mul_2exp(u, u, wp - r);
fmpz_sub(t, t, u);
}
/* We have exp(x + eps) - exp(x) < 2*eps (by assumption that the argument
reduction is large enough). */
if (inexact)
arb_add_error_2exp_si(z, -wp + 1);
fmpz_clear(t);
fmpz_clear(u);
fmpz_clear(Q);
fmpz_clear(T);
arb_clear(w);
/* exp(x) = exp(x/2^q)^(2^q) */
for (k = 0; k < q; k++)
arb_mul(z, z, z, wp);
if (minus_one)
arb_sub_ui(z, z, 1, wp);
arb_set_round(z, z, prec);
}
int
acb_calc_integrate_taylor(acb_t res,
acb_calc_func_t func, void * param,
const acb_t a, const acb_t b,
const arf_t inner_radius,
const arf_t outer_radius,
long accuracy_goal, long prec)
{
long num_steps, step, N, bp;
int result;
acb_t delta, m, x, y1, y2, sum;
acb_ptr taylor_poly;
arf_t err;
acb_init(delta);
acb_init(m);
acb_init(x);
acb_init(y1);
acb_init(y2);
acb_init(sum);
arf_init(err);
acb_sub(delta, b, a, prec);
/* precision used for bounds calculations */
bp = MAG_BITS;
/* compute the number of steps */
{
arf_t t;
arf_init(t);
acb_get_abs_ubound_arf(t, delta, bp);
arf_div(t, t, inner_radius, bp, ARF_RND_UP);
arf_mul_2exp_si(t, t, -1);
num_steps = (long) (arf_get_d(t, ARF_RND_UP) + 1.0);
/* make sure it's not something absurd */
num_steps = FLINT_MIN(num_steps, 10 * prec);
num_steps = FLINT_MAX(num_steps, 1);
arf_clear(t);
}
result = ARB_CALC_SUCCESS;
acb_zero(sum);
for (step = 0; step < num_steps; step++)
{
/* midpoint of subinterval */
acb_mul_ui(m, delta, 2 * step + 1, prec);
acb_div_ui(m, m, 2 * num_steps, prec);
acb_add(m, m, a, prec);
if (arb_calc_verbose)
{
printf("integration point %ld/%ld: ", 2 * step + 1, 2 * num_steps);
acb_printd(m, 15); printf("\n");
}
/* evaluate at +/- x */
/* TODO: exactify m, and include error in x? */
acb_div_ui(x, delta, 2 * num_steps, prec);
/* compute bounds and number of terms to use */
{
arb_t cbound, xbound, rbound;
arf_t C, D, R, X, T;
double DD, TT, NN;
arb_init(cbound);
arb_init(xbound);
arb_init(rbound);
arf_init(C);
arf_init(D);
arf_init(R);
arf_init(X);
arf_init(T);
/* R is the outer radius */
arf_set(R, outer_radius);
/* X = upper bound for |x| */
acb_get_abs_ubound_arf(X, x, bp);
arb_set_arf(xbound, X);
/* Compute C(m,R). Important subtlety: due to rounding when
computing m, we will in general be farther than R away from
the integration path. But since acb_calc_cauchy_bound
actually integrates over the area traced by a complex
interval, it will catch any extra singularities (giving
an infinite bound). */
arb_set_arf(rbound, outer_radius);
acb_calc_cauchy_bound(cbound, func, param, m, rbound, 8, bp);
arf_set_mag(C, arb_radref(cbound));
arf_add(C, arb_midref(cbound), C, bp, ARF_RND_UP);
/* Sanity check: we need C < inf and R > X */
if (arf_is_finite(C) && arf_cmp(R, X) > 0)
{
/* Compute upper bound for D = C * R * X / (R - X) */
arf_mul(D, C, R, bp, ARF_RND_UP);
arf_mul(D, D, X, bp, ARF_RND_UP);
arf_sub(T, R, X, bp, ARF_RND_DOWN);
arf_div(D, D, T, bp, ARF_RND_UP);
/* Compute upper bound for T = (X / R) */
arf_div(T, X, R, bp, ARF_RND_UP);
/* Choose N */
/* TODO: use arf arithmetic to avoid overflow */
/* TODO: use relative accuracy (look at |f(m)|?) */
DD = arf_get_d(D, ARF_RND_UP);
TT = arf_get_d(T, ARF_RND_UP);
NN = -(accuracy_goal * 0.69314718055994530942 + log(DD)) / log(TT);
N = NN + 0.5;
N = FLINT_MIN(N, 100 * prec);
N = FLINT_MAX(N, 1);
/* Tail bound: D / (N + 1) * T^N */
{
mag_t TT;
mag_init(TT);
arf_get_mag(TT, T);
mag_pow_ui(TT, TT, N);
arf_set_mag(T, TT);
mag_clear(TT);
}
arf_mul(D, D, T, bp, ARF_RND_UP);
arf_div_ui(err, D, N + 1, bp, ARF_RND_UP);
}
else
{
N = 1;
arf_pos_inf(err);
result = ARB_CALC_NO_CONVERGENCE;
}
if (arb_calc_verbose)
{
printf("N = %ld; bound: ", N); arf_printd(err, 15); printf("\n");
printf("R: "); arf_printd(R, 15); printf("\n");
printf("C: "); arf_printd(C, 15); printf("\n");
printf("X: "); arf_printd(X, 15); printf("\n");
}
arb_clear(cbound);
arb_clear(xbound);
arb_clear(rbound);
arf_clear(C);
arf_clear(D);
arf_clear(R);
arf_clear(X);
arf_clear(T);
}
/* evaluate Taylor polynomial */
taylor_poly = _acb_vec_init(N + 1);
func(taylor_poly, m, param, N, prec);
_acb_poly_integral(taylor_poly, taylor_poly, N + 1, prec);
_acb_poly_evaluate(y2, taylor_poly, N + 1, x, prec);
acb_neg(x, x);
_acb_poly_evaluate(y1, taylor_poly, N + 1, x, prec);
acb_neg(x, x);
/* add truncation error */
arb_add_error_arf(acb_realref(y1), err);
arb_add_error_arf(acb_imagref(y1), err);
arb_add_error_arf(acb_realref(y2), err);
arb_add_error_arf(acb_imagref(y2), err);
acb_add(sum, sum, y2, prec);
acb_sub(sum, sum, y1, prec);
if (arb_calc_verbose)
{
printf("values: ");
acb_printd(y1, 15); printf(" ");
acb_printd(y2, 15); printf("\n");
}
_acb_vec_clear(taylor_poly, N + 1);
if (result == ARB_CALC_NO_CONVERGENCE)
break;
}
acb_set(res, sum);
acb_clear(delta);
acb_clear(m);
acb_clear(x);
acb_clear(y1);
acb_clear(y2);
acb_clear(sum);
arf_clear(err);
return result;
}
