/*
Bound for scaled Bessel function: 2/(2 pi x)^(1/2)
Bound for tail of integral: 2 N (k / (pi N))^(k / 2) / (k - 2).
*/
void
scaled_bessel_tail_bound(arb_t b, ulong k, const arb_t N, slong prec)
{
arb_const_pi(b, prec);
arb_mul(b, b, N, prec);
arb_ui_div(b, k, b, prec);
arb_sqrt(b, b, prec);
arb_pow_ui(b, b, k, prec);
arb_mul(b, b, N, prec);
arb_mul_ui(b, b, 2, prec);
arb_div_ui(b, b, k - 2, prec);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("doublefac_ui....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
arb_t a, b, c;
ulong n;
slong prec1, prec2;
prec1 = 2 + n_randint(state, 300);
prec2 = 2 + n_randint(state, 300);
arb_init(a);
arb_init(b);
arb_init(c);
n = n_randtest(state);
if (n + 1 == 0 || n + 2 == 0)
n -= 2;
arb_doublefac_ui(a, n, prec1);
arb_doublefac_ui(b, n + 2, prec1);
arb_mul_ui(c, a, n + 2, prec2);
if (!arb_overlaps(b, c))
{
flint_printf("FAIL: overlap\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);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
static void
bound_I(arb_ptr I, const arb_t A, const arb_t B, const arb_t C, slong len, slong wp)
{
slong k;
arb_t D, Dk, L, T, Bm1;
arb_init(D);
arb_init(Dk);
arb_init(Bm1);
arb_init(T);
arb_init(L);
arb_sub_ui(Bm1, B, 1, wp);
arb_one(L);
/* T = 1 / (A^Bm1 * Bm1) */
arb_inv(T, A, wp);
arb_pow(T, T, Bm1, wp);
arb_div(T, T, Bm1, wp);
if (len > 1)
{
arb_log(D, A, wp);
arb_add(D, D, C, wp);
arb_mul(D, D, Bm1, wp);
arb_set(Dk, D);
}
for (k = 0; k < len; k++)
{
if (k > 0)
{
arb_mul_ui(L, L, k, wp);
arb_add(L, L, Dk, wp);
arb_mul(Dk, Dk, D, wp);
}
arb_mul(I + k, L, T, wp);
arb_div(T, T, Bm1, wp);
}
arb_clear(D);
arb_clear(Dk);
arb_clear(Bm1);
arb_clear(T);
arb_clear(L);
}
static void _stirling_number_2_vec_next(arb_ptr row,
arb_srcptr prev, slong n, slong klen, slong prec)
{
slong k;
if (klen > n) arb_one(row + n);
if (n != 0 && klen != 0) arb_zero(row);
for (k = FLINT_MIN(n, klen) - 1; k >= 1; k--)
{
arb_mul_ui(row + k, prev + k, k, prec);
arb_add(row + k, prev + k - 1, row + k, prec);
}
for (k = n + 1; k < klen; k++)
arb_zero(row + k);
}
void
_arb_poly_sinh_cosh_series_basecase(arb_ptr s, arb_ptr c, arb_srcptr h, slong hlen,
slong n, slong prec)
{
slong j, k, alen = FLINT_MIN(n, hlen);
arb_ptr a;
arb_t t, u;
arb_sinh_cosh(s, c, h, prec);
if (hlen == 1)
{
_arb_vec_zero(s + 1, n - 1);
_arb_vec_zero(c + 1, n - 1);
return;
}
arb_init(t);
arb_init(u);
a = _arb_vec_init(alen);
for (k = 1; k < alen; k++)
arb_mul_ui(a + k, h + k, k, prec);
for (k = 1; k < n; k++)
{
arb_zero(t);
arb_zero(u);
for (j = 1; j < FLINT_MIN(k + 1, hlen); j++)
{
arb_addmul(t, a + j, s + k - j, prec);
arb_addmul(u, a + j, c + k - j, prec);
}
arb_div_ui(c + k, t, k, prec);
arb_div_ui(s + k, u, k, prec);
}
arb_clear(t);
arb_clear(u);
_arb_vec_clear(a, alen);
}
void
_arb_poly_inv_borel_transform(arb_ptr res, arb_srcptr poly, slong len, slong prec)
{
slong i;
arb_t t;
arb_init(t);
arb_one(t);
for (i = 0; i < len; i++)
{
if (i > 1)
arb_mul_ui(t, t, i, prec);
arb_mul(res + i, poly + i, t, prec);
}
arb_clear(t);
}
void
arb_const_catalan_eval(arb_t s, slong prec)
{
hypgeom_t series;
arb_t t;
arb_init(t);
hypgeom_init(series);
fmpz_poly_set_str(series->A, "3 19 56 40");
fmpz_poly_set_str(series->B, "1 1");
fmpz_poly_set_str(series->P, "5 0 0 0 32 -64");
fmpz_poly_set_str(series->Q, "5 9 96 352 512 256");
prec += FLINT_CLOG2(prec);
arb_hypgeom_infsum(s, t, series, prec, prec);
arb_mul_ui(t, t, 18, prec);
arb_div(s, s, t, prec);
hypgeom_clear(series);
arb_clear(t);
}
void
arb_const_log2_hypgeom_eval(arb_t s, slong prec)
{
hypgeom_t series;
arb_t t;
arb_init(t);
hypgeom_init(series);
fmpz_poly_set_str(series->A, "1 1");
fmpz_poly_set_str(series->B, "1 1");
fmpz_poly_set_str(series->P, "2 0 -1");
fmpz_poly_set_str(series->Q, "2 4 8");
prec += FLINT_CLOG2(prec);
arb_hypgeom_infsum(s, t, series, prec, prec);
arb_mul_ui(s, s, 3, prec);
arb_mul_2exp_si(t, t, 2);
arb_div(s, s, t, prec);
hypgeom_clear(series);
arb_clear(t);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("cos_pi_fmpq_algebraic....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t c1, c2;
ulong p, q, g;
slong prec;
prec = 2 + n_randint(state, 5000);
q = 1 + n_randint(state, 500);
p = n_randint(state, q / 2 + 1);
g = n_gcd(q, p);
q /= g;
p /= g;
arb_init(c1);
arb_init(c2);
_arb_cos_pi_fmpq_algebraic(c1, p, q, prec);
arb_const_pi(c2, prec);
arb_mul_ui(c2, c2, p, prec);
arb_div_ui(c2, c2, q, prec);
arb_cos(c2, c2, prec);
if (!arb_overlaps(c1, c2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("p/q = %wu/%wu", p, q); flint_printf("\n\n");
flint_printf("c1 = "); arb_printd(c1, 15); flint_printf("\n\n");
flint_printf("c2 = "); arb_printd(c2, 15); flint_printf("\n\n");
abort();
}
if (arb_rel_accuracy_bits(c1) < prec - 2)
{
flint_printf("FAIL: accuracy\n\n");
flint_printf("p/q = %wu/%wu", p, q); flint_printf("\n\n");
flint_printf("prec=%wd eff=%wd\n", prec, arb_rel_accuracy_bits(c1));
flint_printf("c1 = "); arb_printd(c1, 15); flint_printf("\n\n");
flint_printf("c2 = "); arb_printd(c2, 15); flint_printf("\n\n");
abort();
}
arb_clear(c1);
arb_clear(c2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
_acb_poly_zeta_em_tail_naive(acb_ptr sum, const acb_t s, const acb_t Na, acb_srcptr Nasx, slong M, slong d, slong prec)
{
acb_ptr u, term;
acb_t Na2, splus, rec;
arb_t x;
fmpz_t c;
int aint;
slong r;
BERNOULLI_ENSURE_CACHED(2 * M);
u = _acb_vec_init(d);
term = _acb_vec_init(d);
acb_init(splus);
acb_init(rec);
acb_init(Na2);
arb_init(x);
fmpz_init(c);
_acb_vec_zero(sum, d);
/* u = 1/2 * Nasx */
_acb_vec_scalar_mul_2exp_si(u, Nasx, d, -WORD(1));
/* term = u * (s+x) / (N+a) */
_acb_poly_mullow_cpx(u, u, d, s, d, prec);
_acb_vec_scalar_div(term, u, d, Na, prec);
/* (N+a)^2 or 1/(N+a)^2 */
acb_mul(Na2, Na, Na, prec);
aint = acb_is_int(Na2);
if (!aint)
acb_inv(Na2, Na2, prec);
for (r = 1; r <= M; r++)
{
/* flint_printf("sum 2: %wd %wd\n", r, M); */
/* sum += bernoulli number * term */
arb_set_round_fmpz(x, fmpq_numref(bernoulli_cache + 2 * r), prec);
arb_div_fmpz(x, x, fmpq_denref(bernoulli_cache + 2 * r), prec);
_acb_vec_scalar_mul_arb(u, term, d, x, prec);
_acb_vec_add(sum, sum, u, d, prec);
/* multiply term by ((s+x)+2r-1)((s+x)+2r) / ((N+a)^2 * (2*r+1)*(2*r+2)) */
acb_set(splus, s);
arb_add_ui(acb_realref(splus), acb_realref(splus), 2*r-1, prec);
_acb_poly_mullow_cpx(term, term, d, splus, d, prec);
arb_add_ui(acb_realref(splus), acb_realref(splus), 1, prec);
_acb_poly_mullow_cpx(term, term, d, splus, d, prec);
/* TODO: combine with previous multiplication? */
if (aint)
{
arb_mul_ui(x, acb_realref(Na2), 2*r+1, prec);
arb_mul_ui(x, x, 2*r+2, prec);
_acb_vec_scalar_div_arb(term, term, d, x, prec);
}
else
{
fmpz_set_ui(c, 2*r+1);
fmpz_mul_ui(c, c, 2*r+2);
acb_div_fmpz(rec, Na2, c, prec);
_acb_vec_scalar_mul(term, term, d, rec, prec);
}
}
_acb_vec_clear(u, d);
_acb_vec_clear(term, d);
acb_clear(splus);
acb_clear(rec);
acb_clear(Na2);
arb_clear(x);
fmpz_clear(c);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("bernoulli_poly_ui....");
fflush(stdout);
flint_randinit(state);
/* test multiplication theorem */
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
arb_t x, t, res1, res2;
ulong n, m, k;
slong prec;
n = n_randint(state, 50);
m = 1 + n_randint(state, 5);
prec = 2 + n_randint(state, 200);
arb_init(x);
arb_init(t);
arb_init(res1);
arb_init(res2);
arb_randtest(x, state, 2 + n_randint(state, 200), 20);
arb_randtest(res1, state, 2 + n_randint(state, 200), 20);
arb_mul_ui(t, x, m, prec);
arb_bernoulli_poly_ui(res1, n, t, prec);
arb_zero(res2);
for (k = 0; k < m; k++)
{
arb_set_ui(t, k);
arb_div_ui(t, t, m, prec);
arb_add(t, t, x, prec);
arb_bernoulli_poly_ui(t, n, t, prec);
arb_add(res2, res2, t, prec);
}
if (n > 0)
{
arb_ui_pow_ui(t, m, n - 1, prec);
arb_mul(res2, res2, t, prec);
}
else
{
arb_div_ui(res2, res2, m, prec);
}
if (!arb_overlaps(res1, res2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("n = %wu, m = %wu\n\n", n, m);
flint_printf("x = "); arb_printd(x, 15); flint_printf("\n\n");
flint_printf("res1 = "); arb_printd(res1, 15); flint_printf("\n\n");
flint_printf("res2 = "); arb_printd(res2, 15); flint_printf("\n\n");
abort();
}
arb_clear(x);
arb_clear(t);
arb_clear(res1);
arb_clear(res2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void arb_fib_fmpz(arb_t f, const fmpz_t n, slong prec)
{
arb_t t, u;
slong wp, sign, i;
if (fmpz_sgn(n) < 0)
{
fmpz_t m;
fmpz_init(m);
fmpz_neg(m, n);
arb_fib_fmpz(f, m, prec);
if (fmpz_is_even(m))
arb_neg(f, f);
fmpz_clear(m);
return;
}
if (fmpz_cmp_ui(n, 4) <= 0)
{
ulong x = fmpz_get_ui(n);
arb_set_ui(f, x - (x > 1));
return;
}
wp = ARF_PREC_ADD(prec, 3 * fmpz_bits(n));
arb_init(u);
arb_init(t);
arb_set_ui(f, UWORD(1));
arb_set_ui(u, UWORD(1));
sign = -1;
for (i = fmpz_flog_ui(n, UWORD(2)) - 1; i > 0; i--)
{
arb_mul(t, f, f, wp);
arb_add(f, f, u, wp);
arb_mul_2exp_si(f, f, -1);
arb_mul(f, f, f, wp);
arb_mul_2exp_si(f, f, 1);
arb_submul_ui(f, t, 3, wp);
arb_sub_si(f, f, 2 * sign, wp);
arb_mul_ui(u, t, 5, wp);
arb_add_si(u, u, 2 * sign, wp);
sign = 1;
if (fmpz_tstbit(n, i))
{
arb_set(t, f);
arb_add(f, f, u, wp);
arb_mul_2exp_si(f, f, -1);
arb_mul_2exp_si(t, t, 1);
arb_add(u, f, t, wp);
sign = -1;
}
}
if (fmpz_tstbit(n, 0))
{
arb_add(f, f, u, wp);
arb_mul_2exp_si(f, f, -1);
arb_mul(f, f, u, wp);
arb_sub_si(f, f, sign, prec);
}
else
{
arb_mul(f, f, u, prec);
}
arb_clear(u);
arb_clear(t);
}
void Lib_Arb_Mul_Ui(ArbPtr f, ArbPtr g, uint32_t x, int32_t prec)
{
arb_mul_ui( (arb_ptr) f, (arb_ptr) g, x, prec);
}
int main()
{
long iter;
flint_rand_t state;
printf("mul_ui....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b, c, d;
ulong x;
long prec;
arb_init(a);
arb_init(b);
arb_init(c);
arb_init(d);
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);
x = n_randtest(state);
prec = 2 + n_randint(state, 2000);
arb_set_ui(b, x);
arb_mul_ui(c, a, x, prec);
arb_mul(d, a, b, prec);
if (!arb_equal(c, d))
{
printf("FAIL\n\n");
printf("a = "); arb_print(a); printf("\n\n");
printf("b = "); arb_print(b); printf("\n\n");
printf("c = "); arb_print(c); printf("\n\n");
printf("d = "); arb_print(d); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
arb_clear(d);
}
/* aliasing */
for (iter = 0; iter < 10000; iter++)
{
arb_t a, b, c;
ulong x;
long prec;
arb_init(a);
arb_init(b);
arb_init(c);
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);
x = n_randtest(state);
prec = 2 + n_randint(state, 2000);
arb_set_ui(b, x);
arb_mul_ui(c, a, x, prec);
arb_mul_ui(a, a, x, prec);
if (!arb_equal(a, c))
{
printf("FAIL (aliasing)\n\n");
printf("a = "); arb_print(a); printf("\n\n");
printf("b = "); arb_print(b); printf("\n\n");
printf("c = "); arb_print(c); printf("\n\n");
abort();
}
arb_clear(a);
arb_clear(b);
arb_clear(c);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}