void
acb_hypgeom_fresnel(acb_t res1, acb_t res2, const acb_t z, int normalized, slong prec)
{
slong wp;
acb_t w;
arb_t c;
if (!acb_is_finite(z))
{
if (res1 != NULL) acb_indeterminate(res1);
if (res2 != NULL) acb_indeterminate(res2);
return;
}
acb_init(w);
arb_init(c);
wp = prec + 8;
if (normalized)
{
arb_const_pi(c, wp);
arb_sqrt(c, c, wp);
arb_mul_2exp_si(c, c, -1);
acb_mul_arb(w, z, c, wp);
acb_hypgeom_fresnel_erf_error(res1, res2, w, wp);
}
else
{
arb_sqrt_ui(c, 2, wp);
arb_mul_2exp_si(c, c, -1);
acb_mul_arb(w, z, c, wp);
acb_hypgeom_fresnel_erf_error(res1, res2, w, wp);
arb_const_pi(c, wp);
arb_mul_2exp_si(c, c, -1);
arb_sqrt(c, c, wp);
if (res1 != NULL) acb_mul_arb(res1, res1, c, wp);
if (res2 != NULL) acb_mul_arb(res2, res2, c, wp);
}
if (res1 != NULL)
{
acb_mul_2exp_si(res1, res1, -2);
acb_set_round(res1, res1, prec);
}
if (res2 != NULL)
{
acb_mul_2exp_si(res2, res2, -2);
acb_set_round(res2, res2, prec);
}
acb_clear(w);
arb_clear(c);
}
void
_acb_pow_arb_exp(acb_t z, const acb_t x, const arb_t y, long prec)
{
acb_t t;
acb_init(t);
acb_log(t, x, prec);
acb_mul_arb(t, t, y, prec);
acb_exp(z, t, prec);
acb_clear(t);
}
static void
_acb_gamma(acb_t y, const acb_t x, long prec, int inverse)
{
int reflect;
long r, n, wp;
acb_t t, u, v;
wp = prec + FLINT_BIT_COUNT(prec);
acb_gamma_stirling_choose_param(&reflect, &r, &n, x, 1, 0, wp);
acb_init(t);
acb_init(u);
acb_init(v);
if (reflect)
{
/* gamma(x) = (rf(1-x, r) * pi) / (gamma(1-x+r) sin(pi x)) */
acb_sub_ui(t, x, 1, wp);
acb_neg(t, t);
acb_rising_ui_rec(u, t, r, wp);
arb_const_pi(acb_realref(v), wp);
acb_mul_arb(u, u, acb_realref(v), wp);
acb_add_ui(t, t, r, wp);
acb_gamma_stirling_eval(v, t, n, 0, wp);
acb_exp(v, v, wp);
acb_sin_pi(t, x, wp);
acb_mul(v, v, t, wp);
}
else
{
/* gamma(x) = gamma(x+r) / rf(x,r) */
acb_add_ui(t, x, r, wp);
acb_gamma_stirling_eval(u, t, n, 0, wp);
acb_exp(u, u, prec);
acb_rising_ui_rec(v, x, r, wp);
}
if (inverse)
acb_div(y, v, u, prec);
else
acb_div(y, u, v, prec);
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
int
f_aj(arb_t m, const arb_t t, params_t * p, slong prec)
{
slong k;
acb_t z, zu;
arb_t abs;
arb_init(abs);
acb_init(z);
acb_init(zu);
arb_const_pi(abs, prec);
arb_mul_2exp_si(abs, abs, -2); /* Pi/4 */
arb_set(acb_realref(z), t);
arb_set(acb_imagref(z), abs);
acb_sinh(z, z, prec);
arb_mul_2exp_si(abs, abs, 1); /* Pi/2 */
acb_mul_arb(z, z, abs, prec);
acb_tanh(z, z, prec);
arb_one(m);
for (k = 0; k < p->len; k++)
{
acb_sub(zu, z, p->z + k, prec);
if (acb_contains_zero(zu))
{
arb_clear(abs);
acb_clear(zu);
acb_clear(z);
return 0;
}
acb_abs(abs, zu, prec);
arb_mul(m, m, abs, prec);
}
arb_inv(m, m, prec);
arb_clear(abs);
acb_clear(zu);
acb_clear(z);
return 1;
}
void
acb_digamma(acb_t y, const acb_t x, long prec)
{
int reflect;
long r, n, wp;
acb_t t, u, v;
wp = prec + FLINT_BIT_COUNT(prec);
acb_gamma_stirling_choose_param(&reflect, &r, &n, x, 1, 1, wp);
acb_init(t);
acb_init(u);
acb_init(v);
/* psi(x) = psi((1-x)+r) - h(1-x,r) - pi*cot(pi*x) */
if (reflect)
{
acb_sub_ui(t, x, 1, wp);
acb_neg(t, t);
acb_cot_pi(v, x, wp);
arb_const_pi(acb_realref(u), wp);
acb_mul_arb(v, v, acb_realref(u), wp);
acb_rising2_ui(y, u, t, r, wp);
acb_div(u, u, y, wp);
acb_add(v, v, u, wp);
acb_add_ui(t, t, r, wp);
acb_gamma_stirling_eval(u, t, n, 1, wp);
acb_sub(y, u, v, wp);
}
else
{
acb_add_ui(t, x, r, wp);
acb_gamma_stirling_eval(u, t, n, 1, wp);
acb_rising2_ui(y, t, x, r, wp);
acb_div(t, t, y, wp);
acb_sub(y, u, t, prec);
}
acb_clear(t);
acb_clear(u);
acb_clear(v);
}
void
acb_dirichlet_vec_mellin_arb(acb_ptr res, const dirichlet_group_t G, const dirichlet_char_t chi, slong len, const arb_t t, slong n, slong prec)
{
slong k;
arb_t tk, xt, stk, st;
acb_ptr a;
mag_t e;
a = _acb_vec_init(len);
acb_dirichlet_chi_vec(a, G, chi, len, prec);
if (dirichlet_parity_char(G, chi))
{
for (k = 2; k < len; k++)
acb_mul_si(a + k, a + k, k, prec);
}
arb_init(tk);
arb_init(xt);
arb_init(st);
arb_init(stk);
mag_init(e);
arb_sqrt(st, t, prec);
arb_one(tk);
arb_one(stk);
for (k = 0; k < n; k++)
{
_acb_dirichlet_theta_argument_at_arb(xt, G->q, tk, prec);
mag_tail_kexpk2_arb(e, xt, len);
arb_neg(xt, xt);
arb_exp(xt, xt, prec);
/* TODO: reduce len */
acb_dirichlet_qseries_arb(res + k, a, xt, len, prec);
acb_add_error_mag(res + k, e);
acb_mul_arb(res + k, res + k, stk, prec);
arb_mul(tk, tk, t, prec);
arb_mul(stk, stk, st, prec);
}
mag_clear(e);
arb_clear(xt);
arb_clear(tk);
arb_clear(stk);
arb_clear(st);
_acb_vec_clear(a, len);
}
void
_arb_poly_evaluate_acb_horner(acb_t y, arb_srcptr f, long len,
const acb_t x, long prec)
{
if (len == 0)
{
acb_zero(y);
}
else if (len == 1 || acb_is_zero(x))
{
acb_set_round_arb(y, f, prec);
}
else if (len == 2)
{
acb_mul_arb(y, x, f + 1, prec);
acb_add_arb(y, y, f + 0, prec);
}
else
{
long i = len - 1;
acb_t t, u;
acb_init(t);
acb_init(u);
acb_set_arb(u, f + i);
for (i = len - 2; i >= 0; i--)
{
acb_mul(t, u, x, prec);
acb_add_arb(u, t, f + i, prec);
}
acb_swap(y, u);
acb_clear(t);
acb_clear(u);
}
}
void
acb_hypgeom_bessel_k_asymp(acb_t res, const acb_t nu, const acb_t z, slong prec)
{
acb_t t, a, b, w;
acb_init(t);
acb_init(a);
acb_init(b);
acb_init(w);
acb_one(a);
acb_mul_2exp_si(a, a, -1);
acb_add(a, a, nu, prec);
acb_mul_2exp_si(b, nu, 1);
acb_add_ui(b, b, 1, prec);
acb_mul_2exp_si(w, z, 1);
acb_hypgeom_u_asymp(t, a, b, w, -1, prec);
acb_neg(w, z);
acb_exp(w, w, prec);
acb_mul(t, t, w, prec);
acb_mul_2exp_si(w, z, 1);
acb_rsqrt(w, w, prec);
acb_mul(res, t, w, prec);
arb_const_sqrt_pi(acb_realref(w), prec);
acb_mul_arb(res, res, acb_realref(w), prec);
acb_clear(t);
acb_clear(a);
acb_clear(b);
acb_clear(w);
}
void
acb_calc_cauchy_bound(arb_t bound, acb_calc_func_t func, void * param,
const acb_t x, const arb_t radius, slong maxdepth, slong prec)
{
slong i, n, depth, wp;
arb_t pi, theta, v, s1, c1, s2, c2, st, ct;
acb_t t, u;
arb_t b;
arb_init(pi);
arb_init(theta);
arb_init(v);
arb_init(s1);
arb_init(c1);
arb_init(s2);
arb_init(c2);
arb_init(st);
arb_init(ct);
acb_init(t);
acb_init(u);
arb_init(b);
wp = prec + 20;
arb_const_pi(pi, wp);
arb_zero_pm_inf(b);
for (depth = 0, n = 16; depth < maxdepth; n *= 2, depth++)
{
arb_zero(b);
/* theta = 2 pi / n */
arb_div_ui(theta, pi, n, wp);
arb_mul_2exp_si(theta, theta, 1);
/* sine and cosine of i*theta and (i+1)*theta */
arb_zero(s1);
arb_one(c1);
arb_sin_cos(st, ct, theta, wp);
arb_set(s2, st);
arb_set(c2, ct);
for (i = 0; i < n; i++)
{
/* sine and cosine of 2 pi ([i,i+1]/n) */
/* since we use power of two subdivision points, the
sine and cosine are monotone on each subinterval */
arb_union(acb_realref(t), c1, c2, wp);
arb_union(acb_imagref(t), s1, s2, wp);
acb_mul_arb(t, t, radius, wp);
acb_add(t, t, x, prec);
/* next angle */
arb_mul(v, c2, ct, wp);
arb_mul(c1, s2, st, wp);
arb_sub(c1, v, c1, wp);
arb_mul(v, c2, st, wp);
arb_mul(s1, s2, ct, wp);
arb_add(s1, v, s1, wp);
arb_swap(c1, c2);
arb_swap(s1, s2);
func(u, t, param, 1, prec);
acb_abs(v, u, prec);
arb_add(b, b, v, prec);
}
arb_div_ui(b, b, n, prec);
if (arb_is_positive(b))
break;
}
arb_set(bound, b);
arb_clear(pi);
arb_clear(theta);
arb_clear(v);
acb_clear(t);
acb_clear(u);
arb_clear(b);
arb_clear(s1);
arb_clear(c1);
arb_clear(s2);
arb_clear(c2);
arb_clear(st);
arb_clear(ct);
}
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++)
{
acb_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);
acb_init(x);
acb_init(t);
acb_init(res1);
acb_init(res2);
acb_randtest(x, state, 2 + n_randint(state, 200), 20);
acb_randtest(res1, state, 2 + n_randint(state, 200), 20);
acb_mul_ui(t, x, m, prec);
acb_bernoulli_poly_ui(res1, n, t, prec);
acb_zero(res2);
for (k = 0; k < m; k++)
{
acb_set_ui(t, k);
acb_div_ui(t, t, m, prec);
acb_add(t, t, x, prec);
acb_bernoulli_poly_ui(t, n, t, prec);
acb_add(res2, res2, t, prec);
}
if (n > 0)
{
arb_ui_pow_ui(acb_realref(t), m, n - 1, prec);
acb_mul_arb(res2, res2, acb_realref(t), prec);
}
else
{
acb_div_ui(res2, res2, m, prec);
}
if (!acb_overlaps(res1, res2))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("n = %wu, m = %wu\n\n", n, m);
flint_printf("x = "); acb_printd(x, 15); flint_printf("\n\n");
flint_printf("res1 = "); acb_printd(res1, 15); flint_printf("\n\n");
flint_printf("res2 = "); acb_printd(res2, 15); flint_printf("\n\n");
abort();
}
acb_clear(x);
acb_clear(t);
acb_clear(res1);
acb_clear(res2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_legendre_q(acb_t res, const acb_t n, const acb_t m,
const acb_t z, int type, slong prec)
{
if (type == 0)
{
/* http://functions.wolfram.com/07.11.26.0033.01 */
/* todo: simplify the gamma quotients and the sqrt pi factor... */
acb_t a, b, c, z2, mn, nm, t, u;
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(z2);
acb_init(mn);
acb_init(nm);
acb_init(t);
acb_init(u);
acb_add(mn, m, n, prec); /* mn = m + n */
acb_sub(nm, n, m, prec); /* nm = n - m */
acb_mul(z2, z, z, prec); /* z2 = z^2 */
/* t = 2F1((1-m-n)/2, (n-m)/2+1, 3/2, z^2) */
acb_sub_ui(a, mn, 1, prec);
acb_neg(a, a);
acb_mul_2exp_si(a, a, -1);
acb_mul_2exp_si(b, nm, -1);
acb_add_ui(b, b, 1, prec);
acb_set_ui(c, 3);
acb_mul_2exp_si(c, c, -1);
acb_hypgeom_2f1(t, a, b, c, z2, 0, prec);
/* u = 2F1(-(m+n)/2, (n-m+1)/2, 1/2, z^2) */
acb_neg(a, mn);
acb_mul_2exp_si(a, a, -1);
acb_add_ui(b, nm, 1, prec);
acb_mul_2exp_si(b, b, -1);
acb_one(c);
acb_mul_2exp_si(c, c, -1);
acb_hypgeom_2f1(u, a, b, c, z2, 0, prec);
/* a = cospi((m+n)/2) gamma((m+n)/2+1) rgamma((n-m+1)/2) z */
/* b = sinpi((m+n)/2) gamma((m+n+1)/2) rgamma((n-m)/2+1) / 2 */
acb_mul_2exp_si(a, mn, -1);
acb_sin_cos_pi(b, a, a, prec);
acb_mul_2exp_si(c, mn, -1);
acb_add_ui(c, c, 1, prec);
acb_gamma(c, c, prec);
acb_mul(a, a, c, prec);
acb_add_ui(c, nm, 1, prec);
acb_mul_2exp_si(c, c, -1);
acb_rgamma(c, c, prec);
acb_mul(a, a, c, prec);
acb_mul(a, a, z, prec);
acb_add_ui(c, mn, 1, prec);
acb_mul_2exp_si(c, c, -1);
acb_gamma(c, c, prec);
acb_mul(b, b, c, prec);
acb_mul_2exp_si(c, nm, -1);
acb_add_ui(c, c, 1, prec);
acb_rgamma(c, c, prec);
acb_mul(b, b, c, prec);
acb_mul_2exp_si(b, b, -1);
/* at - bu */
acb_mul(t, t, a, prec);
acb_mul(u, u, b, prec);
acb_sub(t, t, u, prec);
/* prefactor sqrt(pi) 2^m (1-z^2)^(-m/2) */
if (!acb_is_zero(m))
{
acb_sub_ui(u, z2, 1, prec);
acb_neg(u, u);
acb_neg(c, m);
acb_mul_2exp_si(c, c, -1);
acb_pow(u, u, c, prec);
acb_set_ui(c, 2);
acb_pow(c, c, m, prec);
acb_mul(u, u, c, prec);
acb_mul(t, t, u, prec);
}
arb_const_sqrt_pi(acb_realref(u), prec);
acb_mul_arb(t, t, acb_realref(u), prec);
acb_set(res, t);
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(z2);
acb_clear(mn);
acb_clear(nm);
acb_clear(t);
acb_clear(u);
}
else if (type == 1)
{
if ((arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), -2) < 0 &&
arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), -2) < 0) ||
!_acb_hypgeom_legendre_q_single_valid(z))
{
_acb_hypgeom_legendre_q_double(res, n, m, z, prec);
}
else
{
_acb_hypgeom_legendre_q_single(res, n, m, z, prec);
}
}
else
{
flint_printf("unsupported 'type' %d for legendre q\n", type);
abort();
}
}
void
_acb_hypgeom_legendre_q_single(acb_t res, const acb_t n, const acb_t m,
const acb_t z, slong prec)
{
acb_t a, b, c, z2, t, u;
acb_init(a);
acb_init(b);
acb_init(c);
acb_init(z2);
acb_init(t);
acb_init(u);
/* invalid in (-1,0) */
if (!_acb_hypgeom_legendre_q_single_valid(z))
{
acb_indeterminate(res);
return;
}
acb_pow_si(z2, z, -2, prec); /* z2 = 1/z^2 */
/* t = 2F1r((m+n+1)/2, (m+n)/2+1, n+3/2, 1/z^2) */
acb_add(b, m, n, prec);
acb_add_ui(a, b, 1, prec);
acb_mul_2exp_si(a, a, -1);
acb_mul_2exp_si(b, b, -1);
acb_add_ui(b, b, 1, prec);
acb_set_ui(c, 3);
acb_mul_2exp_si(c, c, -1);
acb_add(c, c, n, prec);
acb_hypgeom_2f1(t, a, b, c, z2, 1, prec);
/* prefactor sqrt(pi) 2^-n (z+1)^(m/2) (z-1)^(m/2) exp(i pi m) */
/* (1/2) gamma(m+n+1) z^(-m-n-1) */
if (!acb_is_zero(m))
{
acb_add_ui(z2, z, 1, prec);
acb_mul_2exp_si(c, m, -1);
acb_pow(z2, z2, c, prec);
acb_mul(t, t, z2, prec);
acb_sub_ui(z2, z, 1, prec);
acb_mul_2exp_si(c, m, -1);
acb_pow(z2, z2, c, prec);
acb_mul(t, t, z2, prec);
acb_exp_pi_i(z2, m, prec);
acb_mul(t, t, z2, prec);
}
acb_set_ui(z2, 2);
acb_neg(c, n);
acb_pow(z2, z2, c, prec);
acb_mul(t, t, z2, prec);
acb_add(c, m, n, prec);
acb_add_ui(c, c, 1, prec);
acb_gamma(z2, c, prec);
acb_mul(t, t, z2, prec);
acb_neg(c, c);
acb_pow(z2, z, c, prec);
acb_mul(t, t, z2, prec);
acb_mul_2exp_si(t, t, -1);
arb_const_sqrt_pi(acb_realref(u), prec);
acb_mul_arb(t, t, acb_realref(u), prec);
acb_set(res, t);
acb_clear(a);
acb_clear(b);
acb_clear(c);
acb_clear(z2);
acb_clear(t);
acb_clear(u);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("sin_pi....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
acb_t x, y, a, b, c;
slong prec1, prec2;
prec1 = 2 + n_randint(state, 1000);
prec2 = prec1 + 30;
acb_init(x);
acb_init(y);
acb_init(a);
acb_init(b);
acb_init(c);
acb_randtest(x, state, 1 + n_randint(state, 1000), 2 + n_randint(state, 100));
acb_sin_pi(a, x, prec1);
acb_sin_pi(b, x, prec2);
/* check consistency */
if (!acb_overlaps(a, b))
{
flint_printf("FAIL: overlap\n\n");
flint_printf("x = "); acb_print(x); flint_printf("\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("b = "); acb_print(b); flint_printf("\n\n");
abort();
}
/* compare with cos */
arb_const_pi(acb_realref(c), prec1);
acb_mul_arb(y, x, acb_realref(c), prec1);
acb_sin(c, y, prec1);
if (!acb_overlaps(a, c))
{
flint_printf("FAIL: functional equation\n\n");
flint_printf("x = "); acb_print(x); flint_printf("\n\n");
flint_printf("y = "); acb_print(y); flint_printf("\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("c = "); acb_print(c); flint_printf("\n\n");
abort();
}
acb_sin_pi(x, x, prec1);
if (!acb_overlaps(a, x))
{
flint_printf("FAIL: aliasing\n\n");
flint_printf("a = "); acb_print(a); flint_printf("\n\n");
flint_printf("x = "); acb_print(x); flint_printf("\n\n");
abort();
}
acb_clear(x);
acb_clear(y);
acb_clear(a);
acb_clear(b);
acb_clear(c);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
static void
acb_log_sin_pi_half(acb_t res, const acb_t z, slong prec, int upper)
{
acb_t t, u, zmid;
arf_t n;
arb_t pi;
acb_init(t);
acb_init(u);
acb_init(zmid);
arf_init(n);
arb_init(pi);
arf_set(arb_midref(acb_realref(zmid)), arb_midref(acb_realref(z)));
arf_set(arb_midref(acb_imagref(zmid)), arb_midref(acb_imagref(z)));
arf_floor(n, arb_midref(acb_realref(zmid)));
arb_sub_arf(acb_realref(zmid), acb_realref(zmid), n, prec);
arb_const_pi(pi, prec);
if (arf_cmpabs_2exp_si(arb_midref(acb_imagref(zmid)), 2) < 1)
{
acb_sin_pi(t, zmid, prec);
acb_log(t, t, prec);
}
else /* i*pi*(z-0.5) + log((1-exp(-2i*pi*z))/2) */
{
acb_mul_2exp_si(t, zmid, 1);
acb_neg(t, t);
if (upper)
acb_conj(t, t);
acb_exp_pi_i(t, t, prec);
acb_sub_ui(t, t, 1, prec);
acb_neg(t, t);
acb_mul_2exp_si(t, t, -1);
acb_log(t, t, prec);
acb_one(u);
acb_mul_2exp_si(u, u, -1);
acb_sub(u, zmid, u, prec);
if (upper)
acb_conj(u, u);
acb_mul_onei(u, u);
acb_addmul_arb(t, u, pi, prec);
if (upper)
acb_conj(t, t);
}
if (upper)
arb_submul_arf(acb_imagref(t), pi, n, prec);
else
arb_addmul_arf(acb_imagref(t), pi, n, prec);
/* propagated error bound from the derivative pi cot(pi z) */
if (!acb_is_exact(z))
{
mag_t zm, um;
mag_init(zm);
mag_init(um);
acb_cot_pi(u, z, prec);
acb_mul_arb(u, u, pi, prec);
mag_hypot(zm, arb_radref(acb_realref(z)), arb_radref(acb_imagref(z)));
acb_get_mag(um, u);
mag_mul(um, um, zm);
acb_add_error_mag(t, um);
mag_clear(zm);
mag_clear(um);
}
acb_set(res, t);
acb_clear(t);
acb_clear(u);
acb_clear(zmid);
arf_clear(n);
arb_clear(pi);
}
