int arb_calc_refine_root_bisect(arf_interval_t r, arb_calc_func_t func,
void * param, const arf_interval_t start, slong iter, slong prec)
{
int asign, bsign, msign, result;
slong i;
arf_interval_t t, u;
arb_t m, v;
arf_interval_init(t);
arf_interval_init(u);
arb_init(m);
arb_init(v);
arb_set_arf(m, &start->a);
func(v, m, param, 1, prec);
asign = _arb_sign(v);
arb_set_arf(m, &start->b);
func(v, m, param, 1, prec);
bsign = _arb_sign(v);
/* must have proper sign changes */
if (asign == 0 || bsign == 0 || asign == bsign)
{
result = ARB_CALC_IMPRECISE_INPUT;
}
else
{
arf_interval_set(r, start);
result = ARB_CALC_SUCCESS;
for (i = 0; i < iter; i++)
{
msign = arb_calc_partition(t, u, func, param, r, prec);
/* the algorithm fails if the value at the midpoint cannot
be distinguished from zero */
if (msign == 0)
{
result = ARB_CALC_NO_CONVERGENCE;
break;
}
if (msign == asign)
arf_interval_swap(r, u);
else
arf_interval_swap(r, t);
}
}
arf_interval_clear(t);
arf_interval_clear(u);
arb_clear(m);
arb_clear(v);
return result;
}
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;
}
void Lib_Arb_Set_D(ArbPtr x, double d)
{
arf_t rop;
arf_init(rop);
arf_set_d(rop, d);
arb_set_arf((arb_ptr)x, rop);
arf_clear(rop);
}
void Lib_Arb_Set_Mpfr(ArbPtr x, MpfrPtr a)
{
arf_t rop;
arf_init(rop);
arf_set_mpfr(rop, (mpfr_ptr) a);
arb_set_arf((arb_ptr) x, rop);
arf_clear(rop);
}
/* atan(x) = x + eps, |eps| < x^3*/
void
arb_atan_eps(arb_t z, const arf_t x, slong prec)
{
fmpz_t mag;
fmpz_init(mag);
fmpz_mul_ui(mag, ARF_EXPREF(x), 3);
arb_set_arf(z, x);
arb_set_round(z, z, prec);
arb_add_error_2exp_fmpz(z, mag);
fmpz_clear(mag);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("div_arf....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b, c, d;
arf_t x;
slong prec;
arb_init(a);
arb_init(b);
arb_init(c);
arb_init(d);
arf_init(x);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 100);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 100);
arb_randtest_special(c, state, 1 + n_randint(state, 2000), 100);
arf_randtest_special(x, state, 1 + n_randint(state, 2000), 100);
prec = 2 + n_randint(state, 2000);
arb_set_arf(b, x);
arb_div_arf(c, a, x, prec);
arb_div(d, a, b, prec);
if (!arb_equal(c, d))
{
flint_printf("FAIL\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_printf("c = "); arb_print(c); flint_printf("\n\n");
flint_printf("d = "); arb_print(d); flint_printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arb_clear(d);
arf_clear(x);
}
/* aliasing */
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b, c;
arf_t x;
slong prec;
arb_init(a);
arb_init(b);
arb_init(c);
arf_init(x);
arb_randtest_special(a, state, 1 + n_randint(state, 2000), 100);
arb_randtest_special(b, state, 1 + n_randint(state, 2000), 100);
arb_randtest_special(c, state, 1 + n_randint(state, 2000), 100);
arf_randtest_special(x, state, 1 + n_randint(state, 2000), 100);
prec = 2 + n_randint(state, 2000);
arb_set_arf(b, x);
arb_div_arf(c, a, x, prec);
arb_div_arf(a, a, x, prec);
if (!arb_equal(a, c))
{
flint_printf("FAIL (aliasing)\n\n");
flint_printf("a = "); arb_print(a); flint_printf("\n\n");
flint_printf("b = "); arb_print(b); flint_printf("\n\n");
flint_printf("c = "); arb_print(c); flint_printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arf_clear(x);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int fmpq_poly_check_unique_real_root(const fmpq_poly_t pol, const arb_t a, slong prec)
{
if (pol->length < 2)
return 0;
else if (pol->length == 2)
{
/* linear polynomial */
fmpq_t root;
int ans;
fmpq_init(root);
fmpq_set_fmpz_frac(root, fmpq_poly_numref(pol), fmpq_poly_numref(pol) + 1);
fmpq_neg(root, root);
ans = arb_contains_fmpq(a, root);
fmpq_clear(root);
return ans;
}
else
{
arb_t b, c;
arf_t l, r;
fmpz * der;
int lsign, rsign;
fmpz_poly_t pol2;
slong n;
/* 1 - cheap test: */
/* - sign(left) * sign(right) = -1 */
/* - no zero of the derivative */
arb_init(b);
arb_init(c);
arf_init(l);
arf_init(r);
arb_get_interval_arf(l, r, a, prec);
arb_set_arf(b, l);
_fmpz_poly_evaluate_arb(c, pol->coeffs, pol->length, b, 2*prec);
lsign = arb_sgn2(c);
arb_set_arf(b, r);
_fmpz_poly_evaluate_arb(c, pol->coeffs, pol->length, b, 2*prec);
rsign = arb_sgn2(c);
arb_clear(c);
if (lsign * rsign == -1)
{
der = _fmpz_vec_init(pol->length - 1);
_fmpz_poly_derivative(der, pol->coeffs, pol->length);
_fmpz_poly_evaluate_arb(b, der, pol->length - 1, a, prec);
_fmpz_vec_clear(der, pol->length - 1);
if (!arb_contains_zero(b))
{
arf_clear(l);
arf_clear(r);
arb_clear(b);
return 1;
}
}
else
return 0;
arb_clear(b);
/* 2 - expensive testing */
fmpq_t ql, qr;
fmpq_init(ql);
fmpq_init(qr);
arf_get_fmpq(ql, l);
arf_get_fmpq(qr, r);
fmpz_poly_init(pol2);
fmpz_poly_fit_length(pol2, pol->length);
_fmpz_vec_set(pol2->coeffs, pol->coeffs, pol->length);
pol2->length = pol->length;
_fmpz_poly_scale_0_1_fmpq(pol2->coeffs, pol2->length, ql, qr);
n = fmpz_poly_num_real_roots_0_1(pol2);
fmpz_poly_clear(pol2);
fmpq_clear(ql);
fmpq_clear(qr);
return (n == 1);
}
}
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;
}
