void
acb_lambertw_initial_asymp(acb_t w, const acb_t z, const fmpz_t k, slong prec)
{
acb_t L1, L2, t;
acb_init(L1);
acb_init(L2);
acb_init(t);
acb_const_pi(L2, prec);
acb_mul_2exp_si(L2, L2, 1);
acb_mul_fmpz(L2, L2, k, prec);
acb_mul_onei(L2, L2);
acb_log(L1, z, prec);
acb_add(L1, L1, L2, prec);
acb_log(L2, L1, prec);
/* L1 - L2 + L2/L1 + L2(L2-2)/(2 L1^2) */
acb_inv(t, L1, prec);
acb_mul_2exp_si(w, L2, 1);
acb_submul(w, L2, L2, prec);
acb_neg(w, w);
acb_mul(w, w, t, prec);
acb_mul_2exp_si(w, w, -1);
acb_add(w, w, L2, prec);
acb_mul(w, w, t, prec);
acb_sub(w, w, L2, prec);
acb_add(w, w, L1, prec);
acb_clear(L1);
acb_clear(L2);
acb_clear(t);
}
static void
_acb_mat_det_cofactor_3x3(acb_t t, const acb_mat_t A, slong prec)
{
acb_t a;
acb_init(a);
acb_mul (a, acb_mat_entry(A, 1, 0), acb_mat_entry(A, 2, 1), prec);
acb_submul(a, acb_mat_entry(A, 1, 1), acb_mat_entry(A, 2, 0), prec);
acb_mul (t, a, acb_mat_entry(A, 0, 2), prec);
acb_mul (a, acb_mat_entry(A, 1, 2), acb_mat_entry(A, 2, 0), prec);
acb_submul(a, acb_mat_entry(A, 1, 0), acb_mat_entry(A, 2, 2), prec);
acb_addmul(t, a, acb_mat_entry(A, 0, 1), prec);
acb_mul (a, acb_mat_entry(A, 1, 1), acb_mat_entry(A, 2, 2), prec);
acb_submul(a, acb_mat_entry(A, 1, 2), acb_mat_entry(A, 2, 1), prec);
acb_addmul(t, a, acb_mat_entry(A, 0, 0), prec);
acb_clear(a);
}
/* f(z) = exp(-z^2+iz) */
int
f_gaussian_twist(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_mul_onei(res, z);
acb_submul(res, z, z, prec);
acb_exp(res, res, prec);
return 0;
}
/* f(z) = sqrt(1-z^2) */
int
f_circle(acb_ptr res, const acb_t z, void * param, slong order, slong prec)
{
if (order > 1)
flint_abort(); /* Would be needed for Taylor method. */
acb_one(res);
acb_submul(res, z, z, prec);
acb_real_sqrtpos(res, res, order != 0, prec);
return 0;
}
/* assumes no aliasing */
slong
acb_lambertw_initial(acb_t res, const acb_t z, const acb_t ez1, const fmpz_t k, slong prec)
{
/* Handle z very close to 0 on the principal branch. */
if (fmpz_is_zero(k) &&
(arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), -20) <= 0 &&
arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), -20) <= 0))
{
acb_set(res, z);
acb_submul(res, res, res, prec);
return 40; /* could be tightened... */
}
/* For moderate input not close to the branch point, compute a double
approximation as the initial value. */
if (fmpz_is_zero(k) &&
arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), 400) < 0 &&
arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), 400) < 0 &&
(arf_cmp_d(arb_midref(acb_realref(z)), -0.37) < 0 ||
arf_cmp_d(arb_midref(acb_realref(z)), -0.36) > 0 ||
arf_cmpabs_d(arb_midref(acb_imagref(z)), 0.01) > 0))
{
acb_lambertw_principal_d(res, z);
return 48;
}
/* Check if we are close to the branch point at -1/e. */
if ((fmpz_is_zero(k) || (fmpz_is_one(k) && arb_is_negative(acb_imagref(z)))
|| (fmpz_equal_si(k, -1) && arb_is_nonnegative(acb_imagref(z))))
&& ((arf_cmpabs_2exp_si(arb_midref(acb_realref(ez1)), -2) <= 0 &&
arf_cmpabs_2exp_si(arb_midref(acb_imagref(ez1)), -2) <= 0)))
{
acb_t t;
acb_init(t);
acb_mul_2exp_si(t, ez1, 1);
mag_zero(arb_radref(acb_realref(t)));
mag_zero(arb_radref(acb_imagref(t)));
acb_mul_ui(t, t, 3, prec);
acb_sqrt(t, t, prec);
if (!fmpz_is_zero(k))
acb_neg(t, t);
acb_lambertw_branchpoint_series(res, t, 0, prec);
acb_clear(t);
return 1; /* todo: estimate */
}
acb_lambertw_initial_asymp(res, z, k, prec);
return 1; /* todo: estimate */
}
int main()
{
long iter;
flint_rand_t state;
printf("u....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 2000; iter++)
{
acb_t a0, a1, a2, b, z, w0, w1, w2, t, u;
long prec0, prec1, prec2;
acb_init(a0);
acb_init(a1);
acb_init(a2);
acb_init(b);
acb_init(z);
acb_init(w0);
acb_init(w1);
acb_init(w2);
acb_init(t);
acb_init(u);
prec0 = 2 + n_randint(state, 700);
prec1 = 2 + n_randint(state, 700);
prec2 = 2 + n_randint(state, 700);
acb_randtest_maybe_half_int(a0, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest_maybe_half_int(b, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest(z, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest(w0, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest(w1, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest(w2, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_add_ui(a1, a0, 1, prec0);
acb_add_ui(a2, a0, 2, prec0);
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_u_asymp_proper(w0, a0, b, z, prec0);
break;
case 1:
acb_hypgeom_u_1f1(w0, a0, b, z, prec0);
break;
default:
acb_hypgeom_u(w0, a0, b, z, prec0);
}
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_u_asymp_proper(w1, a0, b, z, prec1);
break;
case 1:
acb_hypgeom_u_1f1(w1, a0, b, z, prec1);
break;
default:
acb_hypgeom_u(w1, a0, b, z, prec1);
}
if (!acb_overlaps(w0, w1))
{
printf("FAIL: consistency\n\n");
printf("a = "); acb_printd(a0, 30); printf("\n\n");
printf("b = "); acb_printd(b, 30); printf("\n\n");
printf("z = "); acb_printd(z, 30); printf("\n\n");
printf("w0 = "); acb_printd(w0, 30); printf("\n\n");
printf("w1 = "); acb_printd(w1, 30); printf("\n\n");
abort();
}
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_u_asymp_proper(w1, a1, b, z, prec1);
break;
case 1:
acb_hypgeom_u_1f1(w1, a1, b, z, prec1);
break;
default:
acb_hypgeom_u(w1, a1, b, z, prec1);
}
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_u_asymp_proper(w2, a2, b, z, prec2);
break;
case 1:
acb_hypgeom_u_1f1(w2, a2, b, z, prec2);
break;
default:
acb_hypgeom_u(w2, a2, b, z, prec2);
}
acb_set(t, w0);
acb_mul_2exp_si(u, a0, 1);
acb_sub(u, u, b, prec0);
acb_add(u, u, z, prec0);
acb_add_ui(u, u, 2, prec0);
acb_submul(t, w1, u, prec0);
acb_sub(u, a2, b, prec0);
acb_mul(u, u, a1, prec0);
acb_addmul(t, w2, u, prec0);
if (!acb_contains_zero(t))
{
printf("FAIL: contiguous relation\n\n");
printf("a = "); acb_printd(a0, 30); printf("\n\n");
printf("b = "); acb_printd(b, 30); printf("\n\n");
printf("z = "); acb_printd(z, 30); printf("\n\n");
printf("w0 = "); acb_printd(w0, 30); printf("\n\n");
printf("w1 = "); acb_printd(w1, 30); printf("\n\n");
printf("w2 = "); acb_printd(w2, 30); printf("\n\n");
printf("t = "); acb_printd(t, 30); printf("\n\n");
abort();
}
acb_clear(a0);
acb_clear(a1);
acb_clear(a2);
acb_clear(b);
acb_clear(z);
acb_clear(w0);
acb_clear(w1);
acb_clear(w2);
acb_clear(t);
acb_clear(u);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
long iter;
flint_rand_t state;
printf("bessel_j....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 2000; iter++)
{
acb_t nu0, nu1, nu2, z, w0, w1, w2, t, u;
long prec0, prec1, prec2;
acb_init(nu0);
acb_init(nu1);
acb_init(nu2);
acb_init(z);
acb_init(w0);
acb_init(w1);
acb_init(w2);
acb_init(t);
acb_init(u);
prec0 = 2 + n_randint(state, 1000);
prec1 = 2 + n_randint(state, 1000);
prec2 = 2 + n_randint(state, 1000);
acb_randtest_param(nu0, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest(z, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest(w0, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest(w1, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest(w2, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_sub_ui(nu1, nu0, 1, prec0);
acb_sub_ui(nu2, nu0, 2, prec0);
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_bessel_j_asymp(w0, nu0, z, prec0);
break;
case 1:
acb_hypgeom_bessel_j_0f1(w0, nu0, z, prec0);
break;
default:
acb_hypgeom_bessel_j(w0, nu0, z, prec0);
}
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_bessel_j_asymp(w1, nu0, z, prec1);
break;
case 1:
acb_hypgeom_bessel_j_0f1(w1, nu0, z, prec1);
break;
default:
acb_hypgeom_bessel_j(w1, nu0, z, prec1);
}
if (!acb_overlaps(w0, w1))
{
printf("FAIL: consistency\n\n");
printf("nu = "); acb_printd(nu0, 30); printf("\n\n");
printf("z = "); acb_printd(z, 30); printf("\n\n");
printf("w0 = "); acb_printd(w0, 30); printf("\n\n");
printf("w1 = "); acb_printd(w1, 30); printf("\n\n");
abort();
}
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_bessel_j_asymp(w1, nu1, z, prec1);
break;
case 1:
acb_hypgeom_bessel_j_0f1(w1, nu1, z, prec1);
break;
default:
acb_hypgeom_bessel_j(w1, nu1, z, prec1);
}
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_bessel_j_asymp(w2, nu2, z, prec2);
break;
case 1:
acb_hypgeom_bessel_j_0f1(w2, nu2, z, prec2);
break;
default:
acb_hypgeom_bessel_j(w2, nu2, z, prec2);
}
acb_mul(t, w1, nu1, prec0);
acb_mul_2exp_si(t, t, 1);
acb_submul(t, w2, z, prec0);
acb_submul(t, w0, z, prec0);
if (!acb_contains_zero(t))
{
printf("FAIL: contiguous relation\n\n");
printf("nu = "); acb_printd(nu0, 30); printf("\n\n");
printf("z = "); acb_printd(z, 30); printf("\n\n");
printf("w0 = "); acb_printd(w0, 30); printf("\n\n");
printf("w1 = "); acb_printd(w1, 30); printf("\n\n");
printf("w2 = "); acb_printd(w2, 30); printf("\n\n");
printf("t = "); acb_printd(t, 30); printf("\n\n");
abort();
}
acb_neg(t, nu0);
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_bessel_j_asymp(w2, t, z, prec2);
break;
case 1:
acb_hypgeom_bessel_j_0f1(w2, t, z, prec2);
break;
default:
acb_hypgeom_bessel_j(w2, t, z, prec2);
}
acb_mul(w1, w1, w2, prec2);
acb_neg(t, nu1);
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_bessel_j_asymp(w2, t, z, prec2);
break;
case 1:
acb_hypgeom_bessel_j_0f1(w2, t, z, prec2);
break;
default:
acb_hypgeom_bessel_j(w2, t, z, prec2);
}
acb_mul(w0, w0, w2, prec2);
acb_add(w0, w0, w1, prec2);
acb_sin_pi(t, nu0, prec2);
acb_const_pi(u, prec2);
acb_mul(u, u, z, prec2);
acb_div(t, t, u, prec2);
acb_mul_2exp_si(t, t, 1);
if (!acb_overlaps(w0, t))
{
printf("FAIL: wronskian\n\n");
printf("nu = "); acb_printd(nu0, 30); printf("\n\n");
printf("z = "); acb_printd(z, 30); printf("\n\n");
printf("w0 = "); acb_printd(w0, 30); printf("\n\n");
printf("t = "); acb_printd(t, 30); printf("\n\n");
abort();
}
acb_clear(nu0);
acb_clear(nu1);
acb_clear(nu2);
acb_clear(z);
acb_clear(w0);
acb_clear(w1);
acb_clear(w2);
acb_clear(t);
acb_clear(u);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_ci_asymp(acb_t res, const acb_t z, slong prec)
{
acb_t t, u, w, v, one;
acb_init(t);
acb_init(u);
acb_init(w);
acb_init(v);
acb_init(one);
acb_one(one);
acb_mul_onei(w, z);
/* u = U(1,1,iz) */
acb_hypgeom_u_asymp(u, one, one, w, -1, prec);
/* v = e^(-iz) */
acb_neg(v, w);
acb_exp(v, v, prec);
acb_mul(t, u, v, prec);
if (acb_is_real(z))
{
arb_div(acb_realref(t), acb_imagref(t), acb_realref(z), prec);
arb_zero(acb_imagref(t));
acb_neg(t, t);
}
else
{
/* u = U(1,1,-iz) */
acb_neg(w, w);
acb_hypgeom_u_asymp(u, one, one, w, -1, prec);
acb_inv(v, v, prec);
acb_submul(t, u, v, prec);
acb_div(t, t, w, prec);
acb_mul_2exp_si(t, t, -1);
}
if (arb_is_zero(acb_realref(z)))
{
if (arb_is_positive(acb_imagref(z)))
{
arb_const_pi(acb_imagref(t), prec);
arb_mul_2exp_si(acb_imagref(t), acb_imagref(t), -1);
}
else if (arb_is_negative(acb_imagref(z)))
{
arb_const_pi(acb_imagref(t), prec);
arb_mul_2exp_si(acb_imagref(t), acb_imagref(t), -1);
arb_neg(acb_imagref(t), acb_imagref(t));
}
else
{
acb_const_pi(u, prec);
acb_mul_2exp_si(u, u, -1);
arb_zero(acb_imagref(t));
arb_add_error(acb_imagref(t), acb_realref(u));
}
}
else
{
/* 0 if positive or positive imaginary
pi if upper left quadrant (including negative real axis)
-pi if lower left quadrant (including negative imaginary axis) */
if (arb_is_positive(acb_realref(z)))
{
/* do nothing */
}
else if (arb_is_negative(acb_realref(z)) && arb_is_nonnegative(acb_imagref(z)))
{
acb_const_pi(u, prec);
arb_add(acb_imagref(t), acb_imagref(t), acb_realref(u), prec);
}
else if (arb_is_nonpositive(acb_realref(z)) && arb_is_negative(acb_imagref(z)))
{
acb_const_pi(u, prec);
arb_sub(acb_imagref(t), acb_imagref(t), acb_realref(u), prec);
}
else
{
/* add [-pi,pi] */
acb_const_pi(u, prec);
arb_add_error(acb_imagref(t), acb_realref(u));
}
}
acb_swap(res, t);
acb_clear(t);
acb_clear(u);
acb_clear(w);
acb_clear(v);
acb_clear(one);
}
/* todo: use log(1-z) when this is better? would also need to
adjust strategy in the main function */
void
acb_hypgeom_dilog_bernoulli(acb_t res, const acb_t z, slong prec)
{
acb_t s, w, w2;
slong n, k;
fmpz_t c, d;
mag_t m, err;
double lm;
int real;
acb_init(s);
acb_init(w);
acb_init(w2);
fmpz_init(c);
fmpz_init(d);
mag_init(m);
mag_init(err);
real = 0;
if (acb_is_real(z))
{
arb_sub_ui(acb_realref(w), acb_realref(z), 1, 30);
real = arb_is_nonpositive(acb_realref(w));
}
acb_log(w, z, prec);
acb_get_mag(m, w);
/* for k >= 4, the terms are bounded by (|w| / (2 pi))^k */
mag_set_ui_2exp_si(err, 2670177, -24); /* upper bound for 1/(2pi) */
mag_mul(err, err, m);
lm = mag_get_d_log2_approx(err);
if (lm < -0.25)
{
n = prec / (-lm) + 1;
n = FLINT_MAX(n, 4);
mag_geom_series(err, err, n);
BERNOULLI_ENSURE_CACHED(n)
acb_mul(w2, w, w, prec);
for (k = n - (n % 2 == 0); k >= 3; k -= 2)
{
fmpz_mul_ui(c, fmpq_denref(bernoulli_cache + k - 1), k - 1);
fmpz_mul_ui(d, c, (k + 1) * (k + 2));
acb_mul(s, s, w2, prec);
acb_mul_fmpz(s, s, c, prec);
fmpz_mul_ui(c, fmpq_numref(bernoulli_cache + k - 1), (k + 1) * (k + 2));
acb_sub_fmpz(s, s, c, prec);
acb_div_fmpz(s, s, d, prec);
}
acb_mul(s, s, w, prec);
acb_mul_2exp_si(s, s, 1);
acb_sub_ui(s, s, 3, prec);
acb_mul(s, s, w2, prec);
acb_mul_2exp_si(s, s, -1);
acb_const_pi(w2, prec);
acb_addmul(s, w2, w2, prec);
acb_div_ui(s, s, 6, prec);
acb_neg(w2, w);
acb_log(w2, w2, prec);
acb_submul(s, w2, w, prec);
acb_add(res, s, w, prec);
acb_add_error_mag(res, err);
if (real)
arb_zero(acb_imagref(res));
}
else
{
acb_indeterminate(res);
}
acb_clear(s);
acb_clear(w);
acb_clear(w2);
fmpz_clear(c);
fmpz_clear(d);
mag_clear(m);
mag_clear(err);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("hermite_h....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
acb_t n, n1, n2, z, res1, res2, res3, s;
slong prec1, prec2, prec3;
acb_init(n);
acb_init(n1);
acb_init(n2);
acb_init(z);
acb_init(res1);
acb_init(res2);
acb_init(res3);
acb_init(s);
prec1 = 2 + n_randint(state, 300);
prec2 = 2 + n_randint(state, 300);
prec3 = 2 + n_randint(state, 300);
acb_randtest_param(n, state, 1 + n_randint(state, 400), 10);
acb_sub_ui(n1, n, 1, prec1);
acb_sub_ui(n2, n, 2, prec1);
acb_randtest_param(z, state, 1 + n_randint(state, 400), 10);
acb_randtest_param(res1, state, 1 + n_randint(state, 400), 10);
acb_hypgeom_hermite_h(res1, n, z, prec1);
acb_hypgeom_hermite_h(res2, n1, z, prec2);
acb_hypgeom_hermite_h(res3, n2, z, prec3);
acb_mul(s, res2, z, prec1);
acb_submul(s, res3, n1, prec1);
acb_mul_2exp_si(s, s, 1);
if (!acb_overlaps(res1, s))
{
flint_printf("FAIL: consistency\n\n");
flint_printf("iter = %wd\n\n", iter);
flint_printf("n = "); acb_printd(n, 30); flint_printf("\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("res1 = "); acb_printd(res1, 30); flint_printf("\n\n");
flint_printf("res2 = "); acb_printd(res2, 30); flint_printf("\n\n");
flint_printf("res3 = "); acb_printd(res3, 30); flint_printf("\n\n");
flint_printf("s = "); acb_printd(s, 30); flint_printf("\n\n");
flint_abort();
}
acb_clear(n);
acb_clear(n1);
acb_clear(n2);
acb_clear(z);
acb_clear(res1);
acb_clear(res2);
acb_clear(res3);
acb_clear(s);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
acb_hypgeom_chi_asymp(acb_t res, const acb_t z, slong prec)
{
acb_t t, u, v, one;
acb_init(t);
acb_init(u);
acb_init(v);
acb_init(one);
acb_one(one);
/* u = U(1,1,z) */
acb_hypgeom_u_asymp(u, one, one, z, -1, prec);
/* v = e^(-z) */
acb_neg(v, z);
acb_exp(v, v, prec);
acb_mul(t, u, v, prec);
if (arb_is_zero(acb_realref(z)))
{
arb_div(acb_realref(t), acb_imagref(t), acb_imagref(z), prec);
arb_zero(acb_imagref(t));
acb_neg(t, t);
}
else
{
/* u = U(1,1,-z) */
acb_neg(u, z);
acb_hypgeom_u_asymp(u, one, one, u, -1, prec);
acb_inv(v, v, prec);
acb_submul(t, u, v, prec);
acb_div(t, t, z, prec);
acb_mul_2exp_si(t, t, -1);
acb_neg(t, t);
}
if (acb_is_real(z))
{
if (arb_is_positive(acb_realref(z)))
{
arb_zero(acb_imagref(t));
}
else if (arb_is_negative(acb_realref(z)))
{
arb_const_pi(acb_imagref(t), prec);
}
else
{
/* add [-pi,pi]/2 i */
acb_const_pi(u, prec);
arb_zero(acb_imagref(t));
arb_add_error(acb_imagref(t), acb_realref(u));
}
}
else
{
/* -pi/2 if positive real or in lower half plane
pi/2 if negative real or in upper half plane */
if (arb_is_negative(acb_imagref(z)))
{
acb_const_pi(u, prec);
acb_mul_2exp_si(u, u, -1);
arb_sub(acb_imagref(t), acb_imagref(t), acb_realref(u), prec);
}
else if (arb_is_positive(acb_imagref(z)))
{
acb_const_pi(u, prec);
acb_mul_2exp_si(u, u, -1);
arb_add(acb_imagref(t), acb_imagref(t), acb_realref(u), prec);
}
else
{
/* add [-pi,pi]/2 i */
acb_const_pi(u, prec);
acb_mul_2exp_si(u, u, -1);
arb_add_error(acb_imagref(t), acb_realref(u));
}
}
acb_swap(res, t);
acb_clear(t);
acb_clear(u);
acb_clear(v);
acb_clear(one);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("airy....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
acb_t z, t, w;
acb_t ai1, aip1, bi1, bip1;
acb_t ai2, aip2, bi2, bip2;
slong n1, n2, prec1, prec2;
unsigned int mask;
acb_init(z); acb_init(t); acb_init(w);
acb_init(ai1); acb_init(aip1); acb_init(bi1); acb_init(bip1);
acb_init(ai2); acb_init(aip2); acb_init(bi2); acb_init(bip2);
prec1 = 2 + n_randint(state, 1000);
prec2 = 2 + n_randint(state, 1000);
n1 = n_randint(state, 300);
n2 = n_randint(state, 300);
acb_randtest_param(z, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest_param(t, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_add(z, z, t, 1000);
acb_sub(z, z, t, 1000);
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_airy_direct(ai1, aip1, bi1, bip1, z, n1, prec1);
break;
case 1:
acb_hypgeom_airy_asymp(ai1, aip1, bi1, bip1, z, n1, prec1);
break;
default:
acb_hypgeom_airy(ai1, aip1, bi1, bip1, z, prec1);
break;
}
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_airy_direct(ai2, aip2, bi2, bip2, z, n2, prec2);
break;
case 1:
acb_hypgeom_airy_asymp(ai2, aip2, bi2, bip2, z, n2, prec2);
break;
default:
acb_hypgeom_airy(ai2, aip2, bi2, bip2, z, prec2);
break;
}
if (!acb_overlaps(ai1, ai2))
{
flint_printf("FAIL: consistency (Ai)\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("ai1 = "); acb_printd(ai1, 30); flint_printf("\n\n");
flint_printf("ai2 = "); acb_printd(ai2, 30); flint_printf("\n\n");
abort();
}
if (!acb_overlaps(aip1, aip2))
{
flint_printf("FAIL: consistency (Ai')\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("aip1 = "); acb_printd(aip1, 30); flint_printf("\n\n");
flint_printf("aip2 = "); acb_printd(aip2, 30); flint_printf("\n\n");
abort();
}
if (!acb_overlaps(bi1, bi2))
{
flint_printf("FAIL: consistency (Bi)\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("bi1 = "); acb_printd(bi1, 30); flint_printf("\n\n");
flint_printf("bi2 = "); acb_printd(bi2, 30); flint_printf("\n\n");
abort();
}
if (!acb_overlaps(bip1, bip2))
{
flint_printf("FAIL: consistency (Bi')\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("bip1 = "); acb_printd(bip1, 30); flint_printf("\n\n");
flint_printf("bip2 = "); acb_printd(bip2, 30); flint_printf("\n\n");
abort();
}
acb_mul(w, ai1, bip1, prec1);
acb_submul(w, bi1, aip1, prec1);
acb_const_pi(t, prec1);
acb_inv(t, t, prec1);
if (!acb_overlaps(w, t))
{
flint_printf("FAIL: wronskian\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("ai1 = "); acb_printd(ai1, 30); flint_printf("\n\n");
flint_printf("aip1 = "); acb_printd(aip1, 30); flint_printf("\n\n");
flint_printf("bi1 = "); acb_printd(bi1, 30); flint_printf("\n\n");
flint_printf("bip1 = "); acb_printd(bip1, 30); flint_printf("\n\n");
flint_printf("w = "); acb_printd(w, 30); flint_printf("\n\n");
abort();
}
mask = n_randlimb(state);
acb_hypgeom_airy((mask & 1) ? ai2 : NULL,
(mask & 2) ? aip2 : NULL,
(mask & 4) ? bi2 : NULL,
(mask & 8) ? bip2 : NULL, z, prec2);
if (!acb_overlaps(ai1, ai2) || !acb_overlaps(aip1, aip2) ||
!acb_overlaps(bi1, bi2) || !acb_overlaps(bip1, bip2))
{
flint_printf("FAIL: consistency (mask)\n\n");
flint_printf("mask = %u\n\n", mask);
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("ai1 = "); acb_printd(ai1, 30); flint_printf("\n\n");
flint_printf("ai2 = "); acb_printd(ai2, 30); flint_printf("\n\n");
flint_printf("aip1 = "); acb_printd(aip1, 30); flint_printf("\n\n");
flint_printf("aip2 = "); acb_printd(aip2, 30); flint_printf("\n\n");
flint_printf("bi1 = "); acb_printd(bi1, 30); flint_printf("\n\n");
flint_printf("bi2 = "); acb_printd(bi2, 30); flint_printf("\n\n");
flint_printf("bip1 = "); acb_printd(bip1, 30); flint_printf("\n\n");
flint_printf("bip2 = "); acb_printd(bip2, 30); flint_printf("\n\n");
abort();
}
acb_clear(z); acb_clear(t); acb_clear(w);
acb_clear(ai1); acb_clear(aip1); acb_clear(bi1); acb_clear(bip1);
acb_clear(ai2); acb_clear(aip2); acb_clear(bi2); acb_clear(bip2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("gamma_lower....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 2000 * arb_test_multiplier(); iter++)
{
acb_t a0, a1, b, z, w0, w1, t, u, enz;
slong prec0, prec1;
int regularized;
acb_init(a0);
acb_init(a1);
acb_init(b);
acb_init(z);
acb_init(w0);
acb_init(w1);
acb_init(t);
acb_init(u);
acb_init(enz);
regularized = n_randint(state, 3);
prec0 = 2 + n_randint(state, 1000);
prec1 = 2 + n_randint(state, 1000);
acb_randtest_param(a0, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest(z, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest(w0, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest(w1, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_add_ui(a1, a0, 1, prec0);
acb_hypgeom_gamma_lower(w0, a0, z, regularized, prec0);
acb_hypgeom_gamma_lower(w1, a1, z, regularized, prec1);
acb_neg(enz, z);
acb_exp(enz, enz, prec0);
/* recurrence relations */
if (regularized == 2)
{
/* gamma^{*}(a,z) - exp(-z)/Gamma(a+1) - z gamma^{*}(a+1,z) = 0 */
/* http://dlmf.nist.gov/8.8.E4 */
acb_set(t, w0);
acb_rgamma(u, a1, prec0);
acb_submul(t, enz, u, prec0);
acb_submul(t, z, w1, prec0);
}
else if (regularized == 1)
{
/* P(a,z) - exp(-z) z^a / Gamma(a+1) - P(a+1,z) = 0 */
/* http://dlmf.nist.gov/8.8.E5 */
acb_pow(u, z, a0, prec0);
acb_rgamma(b, a1, prec0);
acb_mul(u, u, b, prec0);
acb_sub(t, w0, w1, prec0);
acb_submul(t, enz, u, prec0);
}
else
{
/* a gamma(a,z) - exp(-z) z^a - gamma(a+1,z) = 0 */
/* http://dlmf.nist.gov/8.8.E1 */
acb_pow(u, z, a0, prec0);
acb_mul(t, a0, w0, prec0);
acb_submul(t, enz, u, prec0);
acb_sub(t, t, w1, prec0);
}
if (!acb_contains_zero(t))
{
flint_printf("FAIL: recurrence relation\n\n");
flint_printf("regularized = %d\n\n", regularized);
flint_printf("a0 = "); acb_printd(a0, 30); flint_printf("\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("w0 = "); acb_printd(w0, 30); flint_printf("\n\n");
flint_printf("w1 = "); acb_printd(w1, 30); flint_printf("\n\n");
flint_printf("t = "); acb_printd(t, 30); flint_printf("\n\n");
abort();
}
/* identities relating lower and upper incomplete gamma functions */
if (regularized == 0 || regularized == 1)
{
acb_t u0;
acb_init(u0);
acb_hypgeom_gamma_upper(u0, a0, z, regularized, prec0);
acb_zero(t);
if (regularized == 1)
{
/* P(s,z) + Q(s,z) - 1 = 0 */
/* http://dlmf.nist.gov/8.2.E5 */
acb_add(t, w0, u0, prec0);
acb_sub_ui(t, t, 1, prec0);
}
else
{
/* gamma(s,z) + Gamma(s,z) - Gamma(s) = 0 */
/* excludes non-positive integer values of s */
/* http://dlmf.nist.gov/8.2.E3 */
if (!acb_is_int(a0) || arb_is_positive(acb_realref(a0)))
{
acb_gamma(b, a0, prec0);
acb_add(t, w0, u0, prec0);
acb_sub(t, t, b, prec0);
}
}
if (!acb_contains_zero(t))
{
flint_printf("FAIL: lower plus upper\n\n");
flint_printf("regularized = %d\n\n", regularized);
flint_printf("a0 = "); acb_printd(a0, 30); flint_printf("\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("w0 = "); acb_printd(w0, 30); flint_printf("\n\n");
flint_printf("w1 = "); acb_printd(w1, 30); flint_printf("\n\n");
flint_printf("t = "); acb_printd(t, 30); flint_printf("\n\n");
abort();
}
acb_clear(u0);
}
acb_clear(a0);
acb_clear(a1);
acb_clear(b);
acb_clear(z);
acb_clear(w0);
acb_clear(w1);
acb_clear(t);
acb_clear(u);
acb_clear(enz);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
_acb_lambertw(acb_t res, const acb_t z, const acb_t ez1, const fmpz_t k, int flags, slong prec)
{
slong goal, ebits, ebits2, ls, lt;
const fmpz * expo;
/* Estimated accuracy goal. */
/* todo: account for exponent bits and bits in k. */
goal = acb_rel_accuracy_bits(z);
goal = FLINT_MAX(goal, 10);
goal = FLINT_MIN(goal, prec);
/* Handle tiny z directly. For k >= 2, |c_k| <= 4^k / 16. */
if (fmpz_is_zero(k)
&& arf_cmpabs_2exp_si(arb_midref(acb_realref(z)), -goal / 2) < 0
&& arf_cmpabs_2exp_si(arb_midref(acb_imagref(z)), -goal / 2) < 0)
{
mag_t err;
mag_init(err);
acb_get_mag(err, z);
mag_mul_2exp_si(err, err, 2);
acb_set(res, z);
acb_submul(res, res, res, prec);
mag_geom_series(err, err, 3);
mag_mul_2exp_si(err, err, -4);
acb_add_error_mag(res, err);
mag_clear(err);
return;
}
if (arf_cmpabs(arb_midref(acb_realref(z)), arb_midref(acb_imagref(z))) >= 0)
expo = ARF_EXPREF(arb_midref(acb_realref(z)));
else
expo = ARF_EXPREF(arb_midref(acb_imagref(z)));
ebits = fmpz_bits(expo);
/* ebits ~= log2(|log(z) + 2 pi i k|) */
/* ebits2 ~= log2(log(log(z))) */
ebits = FLINT_MAX(ebits, fmpz_bits(k));
ebits = FLINT_MAX(ebits, 1) - 1;
ebits2 = FLINT_BIT_COUNT(ebits);
ebits2 = FLINT_MAX(ebits2, 1) - 1;
/* We gain accuracy from the exponent when W ~ log - log log */
if (fmpz_sgn(expo) > 0 || (fmpz_sgn(expo) < 0 && !fmpz_is_zero(k)))
{
goal += ebits - ebits2;
goal = FLINT_MAX(goal, 10);
goal = FLINT_MIN(goal, prec);
/* The asymptotic series with truncation L, M gives us about
t - max(2+lt+L*(2+ls), M*(2+lt)) bits of accuracy where
ls = -ebits, lt = ebits2 - ebits. */
ls = 2 - ebits;
lt = 2 + ebits2 - ebits;
if (ebits - FLINT_MAX(lt + 1*ls, 1*lt) > goal)
{
acb_lambertw_asymp(res, z, k, 1, 1, goal);
acb_set_round(res, res, prec);
return;
}
else if (ebits - FLINT_MAX(lt + 3*ls, 5*lt) > goal)
{
acb_lambertw_asymp(res, z, k, 3, 5, goal);
acb_set_round(res, res, prec);
return;
}
}
/* Extremely close to the branch point at -1/e, use the series expansion directly. */
if (acb_lambertw_try_near_branch_point(res, z, ez1, k, flags, goal))
{
acb_set_round(res, res, prec);
return;
}
/* compute union of both sides */
if (acb_lambertw_branch_crossing(z, ez1, k))
{
acb_t za, zb, eza1, ezb1;
fmpz_t kk;
acb_init(za);
acb_init(zb);
acb_init(eza1);
acb_init(ezb1);
fmpz_init(kk);
fmpz_neg(kk, k);
acb_set(za, z);
acb_conj(zb, z);
arb_nonnegative_part(acb_imagref(za), acb_imagref(za));
arb_nonnegative_part(acb_imagref(zb), acb_imagref(zb));
acb_set(eza1, ez1);
acb_conj(ezb1, ez1);
arb_nonnegative_part(acb_imagref(eza1), acb_imagref(eza1));
arb_nonnegative_part(acb_imagref(ezb1), acb_imagref(ezb1));
/* Check series expansion again, because now there is no crossing. */
if (!acb_lambertw_try_near_branch_point(res, za, eza1, k, flags, goal))
acb_lambertw_cleared_cut_fix_small(za, za, eza1, k, flags, goal);
if (!acb_lambertw_try_near_branch_point(res, zb, ezb1, kk, flags, goal))
acb_lambertw_cleared_cut_fix_small(zb, zb, ezb1, kk, flags, goal);
acb_conj(zb, zb);
acb_union(res, za, zb, prec);
acb_clear(za);
acb_clear(zb);
acb_clear(eza1);
acb_clear(ezb1);
fmpz_clear(kk);
}
else
{
acb_lambertw_cleared_cut_fix_small(res, z, ez1, k, flags, goal);
acb_set_round(res, res, prec);
}
}
static void
_acb_mat_det_cofactor_2x2(acb_t t, const acb_mat_t A, slong prec)
{
acb_mul (t, acb_mat_entry(A, 0, 0), acb_mat_entry(A, 1, 1), prec);
acb_submul(t, acb_mat_entry(A, 0, 1), acb_mat_entry(A, 1, 0), prec);
}